NAV Navigation
Go JavaScript Python Ruby

DAI API v4.2

Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.

Base URLs:

Authentication

Scope Scope Description
user User
admin Admin

Agents

Get a list of all agents

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/agents", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/agents',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/agents', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/agents',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /agents

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The list of agents Inline
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [Agent] false none none
» id integer false none none
» name string true none none
» recordpath string true none none
» suite string true none none
» agenttype string false none none
» epphost string true none none
» epptestcontrollerport integer true none none
» eppanalyzerport integer true none none
» eppworkspacepath string true none none
» isconnected boolean false none none

Create a new agent

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/ai/agents", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const inputBody = '{
  "properties": {
    "id": {
      "type": "integer",
      "name": "id"
    },
    "name": {
      "type": "string",
      "name": "name"
    },
    "recordpath": {
      "type": "string",
      "name": "recordpath"
    },
    "suite": {
      "type": "string",
      "name": "suite"
    },
    "agenttype": {
      "type": "string",
      "name": "agenttype"
    },
    "epphost": {
      "type": "string",
      "name": "epphost"
    },
    "epptestcontrollerport": {
      "type": "integer",
      "name": "epptestcontrollerport"
    },
    "eppanalyzerport": {
      "type": "integer",
      "name": "eppanalyzerport"
    },
    "eppworkspacepath": {
      "type": "string",
      "name": "eppworkspacepath"
    },
    "isconnected": {
      "type": "boolean",
      "name": "isconnected"
    }
  },
  "required": [
    "name",
    "recordpath",
    "suite",
    "epphost",
    "epptestcontrollerport",
    "eppanalyzerport",
    "eppworkspacepath"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/agents',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('/ai/agents', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post '/ai/agents',
  params: {
  }, headers: headers

p JSON.parse(result)

POST /agents

Body parameter

{
  "properties": {
    "id": {
      "type": "integer",
      "name": "id"
    },
    "name": {
      "type": "string",
      "name": "name"
    },
    "recordpath": {
      "type": "string",
      "name": "recordpath"
    },
    "suite": {
      "type": "string",
      "name": "suite"
    },
    "agenttype": {
      "type": "string",
      "name": "agenttype"
    },
    "epphost": {
      "type": "string",
      "name": "epphost"
    },
    "epptestcontrollerport": {
      "type": "integer",
      "name": "epptestcontrollerport"
    },
    "eppanalyzerport": {
      "type": "integer",
      "name": "eppanalyzerport"
    },
    "eppworkspacepath": {
      "type": "string",
      "name": "eppworkspacepath"
    },
    "isconnected": {
      "type": "boolean",
      "name": "isconnected"
    }
  },
  "required": [
    "name",
    "recordpath",
    "suite",
    "epphost",
    "epptestcontrollerport",
    "eppanalyzerport",
    "eppworkspacepath"
  ]
}

Parameters

Name In Type Required Description
body body Agent true Request body

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The agent was created and returned Agent
400 Bad Request The agent name was invalid None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Update an agent

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/ai/agents/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const inputBody = '{
  "properties": {
    "id": {
      "type": "integer",
      "name": "id"
    },
    "name": {
      "type": "string",
      "name": "name"
    },
    "recordpath": {
      "type": "string",
      "name": "recordpath"
    },
    "suite": {
      "type": "string",
      "name": "suite"
    },
    "agenttype": {
      "type": "string",
      "name": "agenttype"
    },
    "epphost": {
      "type": "string",
      "name": "epphost"
    },
    "epptestcontrollerport": {
      "type": "integer",
      "name": "epptestcontrollerport"
    },
    "eppanalyzerport": {
      "type": "integer",
      "name": "eppanalyzerport"
    },
    "eppworkspacepath": {
      "type": "string",
      "name": "eppworkspacepath"
    },
    "isconnected": {
      "type": "boolean",
      "name": "isconnected"
    }
  },
  "required": [
    "name",
    "recordpath",
    "suite",
    "epphost",
    "epptestcontrollerport",
    "eppanalyzerport",
    "eppworkspacepath"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/agents/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('/ai/agents/{id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put '/ai/agents/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

PUT /agents/{id}

Body parameter

{
  "properties": {
    "id": {
      "type": "integer",
      "name": "id"
    },
    "name": {
      "type": "string",
      "name": "name"
    },
    "recordpath": {
      "type": "string",
      "name": "recordpath"
    },
    "suite": {
      "type": "string",
      "name": "suite"
    },
    "agenttype": {
      "type": "string",
      "name": "agenttype"
    },
    "epphost": {
      "type": "string",
      "name": "epphost"
    },
    "epptestcontrollerport": {
      "type": "integer",
      "name": "epptestcontrollerport"
    },
    "eppanalyzerport": {
      "type": "integer",
      "name": "eppanalyzerport"
    },
    "eppworkspacepath": {
      "type": "string",
      "name": "eppworkspacepath"
    },
    "isconnected": {
      "type": "boolean",
      "name": "isconnected"
    }
  },
  "required": [
    "name",
    "recordpath",
    "suite",
    "epphost",
    "epptestcontrollerport",
    "eppanalyzerport",
    "eppworkspacepath"
  ]
}

Parameters

Name In Type Required Description
body body Agent true Request body

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The agent was updated and returned Agent
400 Bad Request The agent name was invalid None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Delete an agent

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/ai/agents/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/agents/{id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('/ai/agents/{id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete '/ai/agents/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

DELETE /agents/{id}

Responses

Status Meaning Description Schema
200 OK The agent was deleted None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Get a single agent

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/agents/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/agents/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/agents/{id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/agents/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /agents/{id}

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The agent Agent
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found The agent doesn't exist None

Associate an agent with a model

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/ai/models/{model_id}/agent", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const inputBody = '{
  "type": "object",
  "properties": {
    "agent": {
      "name": "agent",
      "type": "integer"
    }
  },
  "required": [
    "agent"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models/{model_id}/agent',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('/ai/models/{model_id}/agent', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put '/ai/models/{model_id}/agent',
  params: {
  }, headers: headers

p JSON.parse(result)

PUT /models/{model_id}/agent

Body parameter

{
  "type": "object",
  "properties": {
    "agent": {
      "name": "agent",
      "type": "integer"
    }
  },
  "required": [
    "agent"
  ]
}

Parameters

Name In Type Required Description
body body ModelAgent true Request body

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The agent was associated and returned Agent
400 Bad Request The agent name was invalid None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Get the agent associated to a model

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/models/{model_id}/agent", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models/{model_id}/agent',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/models/{model_id}/agent', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/models/{model_id}/agent',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /models/{model_id}/agent

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The agent Agent
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found The model doesn't exist None

Asset

Delete an asset from all associated models

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/ai/assets/{asset_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/assets/{asset_id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('/ai/assets/{asset_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete '/ai/assets/{asset_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

DELETE /assets/{asset_id}

Parameters

Name In Type Required Description
asset_id path int true none

Responses

Status Meaning Description Schema
204 No Content The Asset was disassociated from Models None
400 Bad Request The Asset data was invalid None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Get a list of models associated with an asset

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/assets/{asset_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/assets/{asset_id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/assets/{asset_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/assets/{asset_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /assets/{asset_id}

Parameters

Name In Type Required Description
asset_id path int true none

Responses

Status Meaning Description Schema
200 OK The list of associated models None
400 Bad Request The Asset data was invalid None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Authentication

Get token info

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/auth", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/auth',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/auth', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/auth',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /auth

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK Get token info SwaggerToken
404 Not Found Token info not available None

Delete an auth token

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/ai/auth", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/auth',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('/ai/auth', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete '/ai/auth',
  params: {
  }, headers: headers

p JSON.parse(result)

DELETE /auth

Responses

Status Meaning Description Schema
200 OK The token was deleted None
404 Not Found Token info not available None

Login and get token

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/x-www-form-urlencoded"},
        "Accept": []string{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/ai/auth", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const inputBody = '{
  "type": "object",
  "properties": {
    "username": {
      "description": "Your username",
      "type": "string"
    },
    "password": {
      "description": "your password",
      "type": "string"
    }
  },
  "required": [
    "username",
    "password"
  ]
}';
const headers = {
  'Content-Type':'application/x-www-form-urlencoded',
  'Accept':'*/*'
};

fetch('/ai/auth',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/x-www-form-urlencoded',
  'Accept': '*/*'
}

r = requests.post('/ai/auth', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/x-www-form-urlencoded',
  'Accept' => '*/*'
}

result = RestClient.post '/ai/auth',
  params: {
  }, headers: headers

p JSON.parse(result)

POST /auth

Body parameter

type: object
properties:
  username:
    description: Your username
    type: string
  password:
    description: your password
    type: string
required:
  - username
  - password

Parameters

Name In Type Required Description
body body object false none
» username body string true Your username
» password body string true your password

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The token response SwaggerToken
404 Not Found Token info not available None

Coverage

Update a coverage model

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/ai/coverage/model/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const inputBody = '{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "integer"
    },
    "name": {
      "name": "name",
      "type": "string"
    },
    "variable_depth": {
      "name": "variable_depth",
      "type": "integer"
    },
    "path_depth": {
      "name": "path_depth",
      "type": "integer"
    },
    "active": {
      "name": "active",
      "type": "boolean"
    },
    "created": {
      "name": "created",
      "type": "string"
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/coverage/model/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('/ai/coverage/model/{id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put '/ai/coverage/model/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

PUT /coverage/model/{id}

Body parameter

{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "integer"
    },
    "name": {
      "name": "name",
      "type": "string"
    },
    "variable_depth": {
      "name": "variable_depth",
      "type": "integer"
    },
    "path_depth": {
      "name": "path_depth",
      "type": "integer"
    },
    "active": {
      "name": "active",
      "type": "boolean"
    },
    "created": {
      "name": "created",
      "type": "string"
    }
  }
}

Parameters

Name In Type Required Description
body body Coverage_Model true Request body

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The coverage model was updated and returned CoverageModel
400 Bad Request The coverage model data was invalid None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Delete a coverage model

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/ai/coverage/model/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/coverage/model/{id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('/ai/coverage/model/{id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete '/ai/coverage/model/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

DELETE /coverage/model/{id}

Responses

Status Meaning Description Schema
200 OK The coverage model was deleted None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found The coverage model doesn't exist None

Get a coverage model by id

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/coverage/model/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/coverage/model/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/coverage/model/{id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/coverage/model/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /coverage/model/{id}

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK A coverage model CoverageModel
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found The coverage model doesn't exist None

Get a list of all coverage models

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/coverage/models", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/coverage/models',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/coverage/models', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/coverage/models',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /coverage/models

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The list of coverage models Inline
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [CoverageModel] false none none
» id integer false none none
» name string false none none
» variable_depth integer false none none
» path_depth integer false none none
» active boolean false none none
» created string false none none

Create a new coverage model

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/ai/coverage/models", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const inputBody = '{
  "properties": {
    "id": {
      "type": "integer",
      "name": "id"
    },
    "name": {
      "type": "string",
      "name": "name"
    },
    "variable_depth": {
      "type": "integer",
      "name": "variable_depth"
    },
    "path_depth": {
      "type": "integer",
      "name": "path_depth"
    },
    "active": {
      "type": "boolean",
      "name": "active"
    },
    "created": {
      "type": "string",
      "name": "created"
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/coverage/models',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('/ai/coverage/models', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post '/ai/coverage/models',
  params: {
  }, headers: headers

p JSON.parse(result)

POST /coverage/models

Body parameter

{
  "properties": {
    "id": {
      "type": "integer",
      "name": "id"
    },
    "name": {
      "type": "string",
      "name": "name"
    },
    "variable_depth": {
      "type": "integer",
      "name": "variable_depth"
    },
    "path_depth": {
      "type": "integer",
      "name": "path_depth"
    },
    "active": {
      "type": "boolean",
      "name": "active"
    },
    "created": {
      "type": "string",
      "name": "created"
    }
  }
}

Parameters

Name In Type Required Description
body body CoverageModel true Request body

Example responses

201 Response

Responses

Status Meaning Description Schema
201 Created The coverage model was created and returned CoverageModel
400 Bad Request The coverage model data was invalid None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
409 Conflict The coverage model already exists None

Errors

List Errors Details

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/errors", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/errors',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/errors', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/errors',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /errors

Parameters

Name In Type Required Description
id query integer false The Error iD to include in the results
task_instance_id query string false The Task Instance ID to include in the results
offset query string false Desired index of first item in response
limit query string false Maximum number of returned items

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The matching errors Inline
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Response Schema

Status Code 200

Name Type Required Restrictions Description
» items [Error] false none none
»» id integer true none none
»» created string true none none
»» task_instance_id string true none none
»» sender string true none none
»» severity string true none none
»» message string true none none
»» error_time string true none none
» total_count integer false none none
» date_as_of string(date-time) false none none

Groups

Get a list of all groups

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/groups", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/groups',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/groups', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/groups',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /groups

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The list of groups Inline
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found There are currently no groups None

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [Groups] false none none
» id integer false none none
» groupname string true none none

Create a new group

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/ai/groups", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const inputBody = '{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "integer"
    },
    "groupname": {
      "name": "groupname",
      "type": "string"
    }
  },
  "required": [
    "groupname"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/groups',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('/ai/groups', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post '/ai/groups',
  params: {
  }, headers: headers

p JSON.parse(result)

POST /groups

Body parameter

{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "integer"
    },
    "groupname": {
      "name": "groupname",
      "type": "string"
    }
  },
  "required": [
    "groupname"
  ]
}

Parameters

Name In Type Required Description
body body Group true Request body

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The group was created and returned Groups
400 Bad Request The group data was invalid None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Update a group

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/ai/groups/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const inputBody = '{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "integer"
    },
    "groupname": {
      "name": "groupname",
      "type": "string"
    }
  },
  "required": [
    "groupname"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/groups/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('/ai/groups/{id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put '/ai/groups/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

PUT /groups/{id}

Body parameter

{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "integer"
    },
    "groupname": {
      "name": "groupname",
      "type": "string"
    }
  },
  "required": [
    "groupname"
  ]
}

Parameters

Name In Type Required Description
body body Group true Request body

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The group was updated and returned Groups
400 Bad Request The group data was invalid None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Delete a group

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/ai/groups/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/groups/{id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('/ai/groups/{id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete '/ai/groups/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

DELETE /groups/{id}

Responses

Status Meaning Description Schema
200 OK The group was deleted None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found Group not found None

Get a group by id

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/groups/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/groups/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/groups/{id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/groups/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /groups/{id}

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK A group Groups
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Licenses

Get a list of licenses

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/licenses", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/licenses',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/licenses', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/licenses',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /licenses

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The list of licenses Inline
404 Not Found There are currently no licenses None

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [Licenses] false none none
» serialnumber integer true none none
» license string true none none

Create a new license

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/ai/licenses", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const inputBody = '{
  "type": "object",
  "properties": {
    "serialnumber": {
      "name": "serialnumber",
      "type": "integer"
    },
    "license": {
      "name": "license",
      "type": "string"
    }
  },
  "required": [
    "serialnumber",
    "license"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/licenses',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('/ai/licenses', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post '/ai/licenses',
  params: {
  }, headers: headers

p JSON.parse(result)

POST /licenses

Body parameter

{
  "type": "object",
  "properties": {
    "serialnumber": {
      "name": "serialnumber",
      "type": "integer"
    },
    "license": {
      "name": "license",
      "type": "string"
    }
  },
  "required": [
    "serialnumber",
    "license"
  ]
}

Parameters

Name In Type Required Description
body body License true Request body

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The license was created and returned Licenses
400 Bad Request The license params were invalid or the license already exists None
403 Forbidden Access denied None

Delete a license

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/ai/licenses/{ser_num}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/licenses/{ser_num}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('/ai/licenses/{ser_num}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete '/ai/licenses/{ser_num}',
  params: {
  }, headers: headers

p JSON.parse(result)

DELETE /licenses/{ser_num}

Responses

Status Meaning Description Schema
200 OK The license was deleted None
404 Not Found License not found None

Get a license

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/licenses/{ser_num}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/licenses/{ser_num}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/licenses/{ser_num}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/licenses/{ser_num}',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /licenses/{ser_num}

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK An eggplant AI license Licenses
404 Not Found License not found None

Get status info

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/status", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/status',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/status', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/status',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /status

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK Status details LicenseUsage

Get license usage details

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/usage", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/usage',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/usage', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/usage',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /usage

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK License usage details LicenseUsage

Models

Get a list of all models

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/models", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/models', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/models',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /models

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The list of models Inline
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found There are currently no models None

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [Model] false none none
» id integer false none none
» name string false none none
» group string true none none
» agent integer false none none
» created string false none none
» updated string false none none
» modeljson string false none none

Create a new model

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/ai/models", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const inputBody = '{
  "properties": {
    "id": {
      "type": "integer",
      "name": "id"
    },
    "name": {
      "type": "string",
      "name": "name"
    },
    "group": {
      "type": "string",
      "name": "group"
    },
    "agent": {
      "type": "integer",
      "name": "agent"
    },
    "created": {
      "type": "string",
      "name": "created"
    },
    "updated": {
      "type": "string",
      "name": "updated"
    },
    "modeljson": {
      "type": "string",
      "name": "modeljson"
    }
  },
  "required": [
    "group"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('/ai/models', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post '/ai/models',
  params: {
  }, headers: headers

p JSON.parse(result)

POST /models

Body parameter

{
  "properties": {
    "id": {
      "type": "integer",
      "name": "id"
    },
    "name": {
      "type": "string",
      "name": "name"
    },
    "group": {
      "type": "string",
      "name": "group"
    },
    "agent": {
      "type": "integer",
      "name": "agent"
    },
    "created": {
      "type": "string",
      "name": "created"
    },
    "updated": {
      "type": "string",
      "name": "updated"
    },
    "modeljson": {
      "type": "string",
      "name": "modeljson"
    }
  },
  "required": [
    "group"
  ]
}

Parameters

Name In Type Required Description
body body Model true Request body

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The model was created and returned Model
400 Bad Request The model data was invalid None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
409 Conflict The model already exists None

Update a model

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/ai/models/{model_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const inputBody = '{
  "properties": {
    "id": {
      "type": "integer",
      "name": "id"
    },
    "name": {
      "type": "string",
      "name": "name"
    },
    "group": {
      "type": "string",
      "name": "group"
    },
    "agent": {
      "type": "integer",
      "name": "agent"
    },
    "created": {
      "type": "string",
      "name": "created"
    },
    "updated": {
      "type": "string",
      "name": "updated"
    },
    "modeljson": {
      "type": "string",
      "name": "modeljson"
    }
  },
  "required": [
    "group"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models/{model_id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('/ai/models/{model_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put '/ai/models/{model_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

PUT /models/{model_id}

Body parameter

{
  "properties": {
    "id": {
      "type": "integer",
      "name": "id"
    },
    "name": {
      "type": "string",
      "name": "name"
    },
    "group": {
      "type": "string",
      "name": "group"
    },
    "agent": {
      "type": "integer",
      "name": "agent"
    },
    "created": {
      "type": "string",
      "name": "created"
    },
    "updated": {
      "type": "string",
      "name": "updated"
    },
    "modeljson": {
      "type": "string",
      "name": "modeljson"
    }
  },
  "required": [
    "group"
  ]
}

Parameters

Name In Type Required Description
body body Model true Request body

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The model was updated and returned Model
400 Bad Request The model data was invalid None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Not authorized to update the model None

Delete a model

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/ai/models/{model_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models/{model_id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('/ai/models/{model_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete '/ai/models/{model_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

DELETE /models/{model_id}

Responses

Status Meaning Description Schema
200 OK The model was deleted None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Not authorized to access the model None
404 Not Found Model not found None

Get a model by id

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/models/{model_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models/{model_id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/models/{model_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/models/{model_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /models/{model_id}

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The model Model
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Not authorized to access the model None
404 Not Found Could not load model None

Get a list of model defects

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/models/{model_id}/defects", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models/{model_id}/defects',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/models/{model_id}/defects', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/models/{model_id}/defects',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /models/{model_id}/defects

Responses

Status Meaning Description Schema
200 OK The model defects None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found Model not found None

Get a list of model tags

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/models/{model_id}/tags", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models/{model_id}/tags',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/models/{model_id}/tags', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/models/{model_id}/tags',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /models/{model_id}/tags

Responses

Status Meaning Description Schema
200 OK The model tags None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Not authorized to access the model tags None
404 Not Found Could not load model tags None

Add a new tag

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/ai/models/{model_id}/tags", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const inputBody = '{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "integer"
    },
    "model": {
      "name": "model",
      "type": "string"
    },
    "tag": {
      "name": "tag",
      "type": "string"
    },
    "created": {
      "name": "created",
      "type": "string"
    },
    "author": {
      "name": "author",
      "type": "string"
    }
  },
  "required": [
    "model",
    "tag",
    "author"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models/{model_id}/tags',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('/ai/models/{model_id}/tags', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post '/ai/models/{model_id}/tags',
  params: {
  }, headers: headers

p JSON.parse(result)

POST /models/{model_id}/tags

Body parameter

{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "integer"
    },
    "model": {
      "name": "model",
      "type": "string"
    },
    "tag": {
      "name": "tag",
      "type": "string"
    },
    "created": {
      "name": "created",
      "type": "string"
    },
    "author": {
      "name": "author",
      "type": "string"
    }
  },
  "required": [
    "model",
    "tag",
    "author"
  ]
}

Parameters

Name In Type Required Description
body body ModelTags true Request body

Responses

Status Meaning Description Schema
200 OK The model tag was created and returned None
400 Bad Request The model data was invalid None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
409 Conflict The model already exists None

Update a model tag

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/ai/models/{model_id}/tags/{tag_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const inputBody = '{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "integer"
    },
    "model": {
      "name": "model",
      "type": "string"
    },
    "tag": {
      "name": "tag",
      "type": "string"
    },
    "created": {
      "name": "created",
      "type": "string"
    },
    "author": {
      "name": "author",
      "type": "string"
    }
  },
  "required": [
    "model",
    "tag",
    "author"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models/{model_id}/tags/{tag_id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('/ai/models/{model_id}/tags/{tag_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put '/ai/models/{model_id}/tags/{tag_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

PUT /models/{model_id}/tags/{tag_id}

Body parameter

{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "integer"
    },
    "model": {
      "name": "model",
      "type": "string"
    },
    "tag": {
      "name": "tag",
      "type": "string"
    },
    "created": {
      "name": "created",
      "type": "string"
    },
    "author": {
      "name": "author",
      "type": "string"
    }
  },
  "required": [
    "model",
    "tag",
    "author"
  ]
}

Parameters

Name In Type Required Description
body body Update_model_tag true Request body

Responses

Status Meaning Description Schema
200 OK The model tag was updated and returned None
400 Bad Request The model tag data was invalid None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

ModelAssets

List model's associated assets

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/models/{model_id}/assets", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models/{model_id}/assets',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/models/{model_id}/assets', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/models/{model_id}/assets',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /models/{model_id}/assets

Parameters

Name In Type Required Description
model_id path int true none

Responses

Status Meaning Description Schema
200 OK A Model's Asset None
400 Bad Request The Model data was invalid None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found The Model was not found None

Create a new Model Asset

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/ai/models/{model_id}/assets", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const inputBody = '{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "integer"
    },
    "asset_id": {
      "name": "asset_id",
      "type": "string"
    },
    "model_id": {
      "name": "model_id",
      "type": "integer"
    }
  },
  "required": [
    "asset_id"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models/{model_id}/assets',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('/ai/models/{model_id}/assets', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post '/ai/models/{model_id}/assets',
  params: {
  }, headers: headers

p JSON.parse(result)

POST /models/{model_id}/assets

Body parameter

{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "integer"
    },
    "asset_id": {
      "name": "asset_id",
      "type": "string"
    },
    "model_id": {
      "name": "model_id",
      "type": "integer"
    }
  },
  "required": [
    "asset_id"
  ]
}

Parameters

Name In Type Required Description
body body Create_new_Model_Asset true Request body

Responses

Status Meaning Description Schema
201 Created The Model Asset was created and returned None
400 Bad Request The Model data was invalid None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found The Model was not found None
409 Conflict The Model already has an associated Asset None

Update a Model's Asset

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/ai/models/{model_id}/assets/{asset_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const inputBody = '{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "integer"
    },
    "asset_id": {
      "name": "asset_id",
      "type": "string"
    },
    "model_id": {
      "name": "model_id",
      "type": "integer"
    }
  },
  "required": [
    "asset_id"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models/{model_id}/assets/{asset_id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('/ai/models/{model_id}/assets/{asset_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put '/ai/models/{model_id}/assets/{asset_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

PUT /models/{model_id}/assets/{asset_id}

Body parameter

{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "integer"
    },
    "asset_id": {
      "name": "asset_id",
      "type": "string"
    },
    "model_id": {
      "name": "model_id",
      "type": "integer"
    }
  },
  "required": [
    "asset_id"
  ]
}

Parameters

Name In Type Required Description
body body NewModelAsset true Request body

Responses

Status Meaning Description Schema
200 OK The Model Asset was updated and returned None
400 Bad Request The Model data or Asset data was invalid None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found The Model or Asset was not found None

Get an asset by id

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/models/{model_id}/assets/{asset_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models/{model_id}/assets/{asset_id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/models/{model_id}/assets/{asset_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/models/{model_id}/assets/{asset_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /models/{model_id}/assets/{asset_id}

Parameters

Name In Type Required Description
model_id path int true none
asset_id path int true none

Responses

Status Meaning Description Schema
200 OK A Model Asset None
400 Bad Request The Model data or Asset data was invalid None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found The Model or Asset was not found None

ModelAsset

Delete a model's asset

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/ai/models/{model_id}/assets/{asset_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models/{model_id}/assets/{asset_id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('/ai/models/{model_id}/assets/{asset_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete '/ai/models/{model_id}/assets/{asset_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

DELETE /models/{model_id}/assets/{asset_id}

Parameters

Name In Type Required Description
model_id path int true none
asset_id path int true none

Responses

Status Meaning Description Schema
204 No Content The Model's associated Asset was deleted None
400 Bad Request The Model data or Asset data was invalid None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found The Model or Asset not found None

Coverage Report

Get model coverage report

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/models/{model_id}/coverage", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models/{model_id}/coverage',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/models/{model_id}/coverage', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/models/{model_id}/coverage',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /models/{model_id}/coverage

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK Model coverage report ModelCoverage
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found Model not found None

Release Insights

Get release insights

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/models/{model_id}/release-insights", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models/{model_id}/release-insights',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/models/{model_id}/release-insights', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/models/{model_id}/release-insights',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /models/{model_id}/release-insights

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK Release insights ReleaseInsights
400 Bad Request Bad request data None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found Release insights data or model not found None

Runs

Get model test runs

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/models/{model_id}/runs", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models/{model_id}/runs',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/models/{model_id}/runs', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/models/{model_id}/runs',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /models/{model_id}/runs

Parameters

Name In Type Required Description
model_id path integer true The model id

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK A list of model test runs Inline
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found Model not found None

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [Run] false none none
» id integer true none none
» hierarchyid integer true none none
» modelname string true none none
» groupid integer true none none
» teststatus string true none none
» starttime string true none none
» endtime string true none none
» seed integer true none none
» coverage float true none none
» logfile string true none none
» usedtests string true none none
» events boolean true none none
» runtype string true none none
» testcase string true none none
» testconfigtask any true none none
» step integer true none none
» failedaction string true none none

List runs details

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/runs", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/runs',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/runs', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/runs',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /runs

Parameters

Name In Type Required Description
id query integer false The test run ID to include in the results
teststatus query string false The test status to include in the results
modelname query string false The model name to include in the results
task_instance_id query string false The task instance ID to include in the results
sort query string false The sort critera
offset query string false Desired index of first item in response
limit query string false Maximum number of returned items
step query integer false The step in the test configuration run

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The matching test runs Inline
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Response Schema

Status Code 200

Name Type Required Restrictions Description
» items [Run] false none none
»» id integer true none none
»» hierarchyid integer true none none
»» modelname string true none none
»» groupid integer true none none
»» teststatus string true none none
»» starttime string true none none
»» endtime string true none none
»» seed integer true none none
»» coverage float true none none
»» logfile string true none none
»» usedtests string true none none
»» events boolean true none none
»» runtype string true none none
»» testcase string true none none
»» testconfigtask any true none none
»» step integer true none none
»» failedaction string true none none
» total_count integer false none none
» date_as_of string(date-time) false none none

Delete a run

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/ai/runs/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/runs/{id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('/ai/runs/{id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete '/ai/runs/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

DELETE /runs/{id}

Responses

Status Meaning Description Schema
200 OK The run was deleted None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found Run not found None

Get run details

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/runs/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/runs/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/runs/{id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/runs/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /runs/{id}

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK A model test run Run
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found Run not found None

Get summary information for a task instance

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/testconfigtasks/{id}/summary", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/testconfigtasks/{id}/summary',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/testconfigtasks/{id}/summary', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/testconfigtasks/{id}/summary',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /testconfigtasks/{id}/summary

Parameters

Name In Type Required Description
id path string true The task instance ID

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK Summary information for the task instance Inline
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Response Schema

Status Code 200

Name Type Required Restrictions Description
» properties any false none none
» required any false none none

Testcases Report

Get model test case runs

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/models/{model_id}/testcaseruns", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models/{model_id}/testcaseruns',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/models/{model_id}/testcaseruns', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/models/{model_id}/testcaseruns',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /models/{model_id}/testcaseruns

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The model test case runs ModelCoverage
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found Model not found None

Testcases

Get a list of model test cases

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/models/{model_id}/testcases", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models/{model_id}/testcases',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/models/{model_id}/testcases', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/models/{model_id}/testcases',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /models/{model_id}/testcases

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The testcases Inline
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found Model not found None

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [TestCases] false none none
» testcaseName string true none none
» testcase string true none none
» id integer false none none
» tests string false none none
» fails string false none none
» testcaseTags string false none none
» testcaseDescription string false none none
» testcaseOrigin string false none none
» testcaseExternalID string false none none
» testIds string false none none

Create new testcase

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/ai/models/{model_id}/testcases", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const inputBody = '{
  "type": "object",
  "properties": {
    "testcaseName": {
      "name": "testcaseName",
      "type": "string"
    },
    "testcase": {
      "name": "testcase",
      "type": "string"
    },
    "id": {
      "name": "id",
      "type": "integer"
    },
    "tests": {
      "name": "tests",
      "type": "string"
    },
    "fails": {
      "name": "fails",
      "type": "string"
    },
    "testcaseTags": {
      "name": "testcaseTags",
      "type": "string"
    },
    "testcaseDescription": {
      "name": "testcaseDescription",
      "type": "string"
    },
    "testcaseOrigin": {
      "name": "testcaseOrigin",
      "type": "string"
    },
    "testcaseExternalID": {
      "name": "testcaseExternalID",
      "type": "string"
    },
    "testIds": {
      "name": "testIds",
      "type": "string"
    }
  },
  "required": [
    "testcaseName",
    "testcase"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models/{model_id}/testcases',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('/ai/models/{model_id}/testcases', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post '/ai/models/{model_id}/testcases',
  params: {
  }, headers: headers

p JSON.parse(result)

POST /models/{model_id}/testcases

Body parameter

{
  "type": "object",
  "properties": {
    "testcaseName": {
      "name": "testcaseName",
      "type": "string"
    },
    "testcase": {
      "name": "testcase",
      "type": "string"
    },
    "id": {
      "name": "id",
      "type": "integer"
    },
    "tests": {
      "name": "tests",
      "type": "string"
    },
    "fails": {
      "name": "fails",
      "type": "string"
    },
    "testcaseTags": {
      "name": "testcaseTags",
      "type": "string"
    },
    "testcaseDescription": {
      "name": "testcaseDescription",
      "type": "string"
    },
    "testcaseOrigin": {
      "name": "testcaseOrigin",
      "type": "string"
    },
    "testcaseExternalID": {
      "name": "testcaseExternalID",
      "type": "string"
    },
    "testIds": {
      "name": "testIds",
      "type": "string"
    }
  },
  "required": [
    "testcaseName",
    "testcase"
  ]
}

Parameters

Name In Type Required Description
body body Create_test_case true Request body

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The test case was created and returned TestCases
400 Bad Request The testcase already exists None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Update a test case

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/ai/models/{model_id}/testcases/{testcase_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const inputBody = '{
  "type": "object",
  "properties": {
    "testcaseName": {
      "name": "testcaseName",
      "type": "string"
    },
    "testcase": {
      "name": "testcase",
      "type": "string"
    },
    "id": {
      "name": "id",
      "type": "integer"
    },
    "tests": {
      "name": "tests",
      "type": "string"
    },
    "fails": {
      "name": "fails",
      "type": "string"
    },
    "testcaseTags": {
      "name": "testcaseTags",
      "type": "string"
    },
    "testcaseDescription": {
      "name": "testcaseDescription",
      "type": "string"
    },
    "testcaseOrigin": {
      "name": "testcaseOrigin",
      "type": "string"
    },
    "testcaseExternalID": {
      "name": "testcaseExternalID",
      "type": "string"
    },
    "testIds": {
      "name": "testIds",
      "type": "string"
    }
  },
  "required": [
    "testcaseName",
    "testcase"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models/{model_id}/testcases/{testcase_id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('/ai/models/{model_id}/testcases/{testcase_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put '/ai/models/{model_id}/testcases/{testcase_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

PUT /models/{model_id}/testcases/{testcase_id}

Body parameter

{
  "type": "object",
  "properties": {
    "testcaseName": {
      "name": "testcaseName",
      "type": "string"
    },
    "testcase": {
      "name": "testcase",
      "type": "string"
    },
    "id": {
      "name": "id",
      "type": "integer"
    },
    "tests": {
      "name": "tests",
      "type": "string"
    },
    "fails": {
      "name": "fails",
      "type": "string"
    },
    "testcaseTags": {
      "name": "testcaseTags",
      "type": "string"
    },
    "testcaseDescription": {
      "name": "testcaseDescription",
      "type": "string"
    },
    "testcaseOrigin": {
      "name": "testcaseOrigin",
      "type": "string"
    },
    "testcaseExternalID": {
      "name": "testcaseExternalID",
      "type": "string"
    },
    "testIds": {
      "name": "testIds",
      "type": "string"
    }
  },
  "required": [
    "testcaseName",
    "testcase"
  ]
}

Parameters

Name In Type Required Description
body body Update_test_case true Request body

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The test case was updated and returned TestCases
400 Bad Request The test case data was invalid None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found Model not found None

Delete a test case

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/ai/models/{model_id}/testcases/{testcase_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models/{model_id}/testcases/{testcase_id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('/ai/models/{model_id}/testcases/{testcase_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete '/ai/models/{model_id}/testcases/{testcase_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

DELETE /models/{model_id}/testcases/{testcase_id}

Responses

Status Meaning Description Schema
200 OK The test case was deleted None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found Unable to delete test case None

Get a model test case

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/models/{model_id}/testcases/{testcase_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/models/{model_id}/testcases/{testcase_id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/models/{model_id}/testcases/{testcase_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/models/{model_id}/testcases/{testcase_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /models/{model_id}/testcases/{testcase_id}

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK A testcases TestCases
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found Model not found None

Ping

Ensures the API is up

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/ping", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/ping',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/ping', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/ping',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /ping

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK Returns the API status Ping

Run Logs

Get a single run log

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/runlogs/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/runlogs/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/runlogs/{id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/runlogs/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /runlogs/{id}

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK A model test run log RunLogs
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found Log not found None

Create run log

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/ai/runlogs/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/runlogs/{id}',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('/ai/runlogs/{id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post '/ai/runlogs/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

POST /runlogs/{id}

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The run log RunLogs
400 Bad Request Invalid or duplicated agent name None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Run Screenshots

Get a single run's screenshots and metadata

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/runs/{id}/screenshots", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/runs/{id}/screenshots',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/runs/{id}/screenshots', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/runs/{id}/screenshots',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /runs/{id}/screenshots

Parameters

Name In Type Required Description
id path integer true run id to get the screenshot from

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK A model test run screenshot metadata Inline
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found Run id does not exist None

Response Schema

Status Code 200

Name Type Required Restrictions Description
» items [Screenshots] false none none
»» timestamp string true none none
»» artifactid string true none none
»» name string true none none
»» capture_type string true none none
»» content_type string true none none
»» state string true none none
»» action string true none none
» total_count integer false none none
» date_as_of string(date-time) false none none

Performance

Get model run timings

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/runs/{id}/timings", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/runs/{id}/timings',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/runs/{id}/timings', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/runs/{id}/timings',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /runs/{id}/timings

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK A list of timings for model test runs Inline
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found No timings were found None

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [Timings] false none none
» order integer true none none
» state string true none none
» action string true none none
» timing float true none none

Screenshots

Post a msgpack encoded dict containing a screenshot and metadata
Received post data is expected in msgpack format.

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/ai/screenshots", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/screenshots',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('/ai/screenshots', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post '/ai/screenshots',
  params: {
  }, headers: headers

p JSON.parse(result)

POST /screenshots

Responses

Status Meaning Description Schema
202 Accepted Received binary blob msgpack can unpack None
400 Bad Request Received invalid data None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Get presigned object URL for screenshot with given artifact id
Redirect to screenshot file in object storage

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/screenshots/{artifact_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


fetch('/ai/screenshots/{artifact_id}',
{
  method: 'GET'

})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests

r = requests.get('/ai/screenshots/{artifact_id}')

print(r.json())

require 'rest-client'
require 'json'

result = RestClient.get '/ai/screenshots/{artifact_id}',
  params: {
  }

p JSON.parse(result)

GET /screenshots/{artifact_id}

Parameters

Name In Type Required Description
artifact_id path string true Screenshot artifact_id (UUID)

Responses

Status Meaning Description Schema
303 See Other See Other None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found Not Found None

Get presigned object URL for screenshot with given artifact id and Content-Disposition set to attachment
Redirect to screenshot file in object storage

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/screenshots/{artifact_id}/download", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


fetch('/ai/screenshots/{artifact_id}/download',
{
  method: 'GET'

})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests

r = requests.get('/ai/screenshots/{artifact_id}/download')

print(r.json())

require 'rest-client'
require 'json'

result = RestClient.get '/ai/screenshots/{artifact_id}/download',
  params: {
  }

p JSON.parse(result)

GET /screenshots/{artifact_id}/download

Parameters

Name In Type Required Description
artifact_id path string true Screenshot artifact_id (UUID)

Responses

Status Meaning Description Schema
303 See Other See Other None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found Not Found None

SMTP

Update SMTP config

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/ai/smtp", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const inputBody = '{
  "properties": {
    "id": {
      "type": "integer",
      "name": "id"
    },
    "serverhost": {
      "type": "string",
      "name": "serverhost"
    },
    "username": {
      "type": "string",
      "name": "username"
    },
    "password": {
      "type": "string",
      "name": "password"
    },
    "port": {
      "type": "integer",
      "name": "port"
    },
    "recipient": {
      "type": "string",
      "name": "recipient"
    }
  },
  "required": [
    "id",
    "serverhost",
    "username",
    "password",
    "port",
    "recipient"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/smtp',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('/ai/smtp', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put '/ai/smtp',
  params: {
  }, headers: headers

p JSON.parse(result)

PUT /smtp

Body parameter

{
  "properties": {
    "id": {
      "type": "integer",
      "name": "id"
    },
    "serverhost": {
      "type": "string",
      "name": "serverhost"
    },
    "username": {
      "type": "string",
      "name": "username"
    },
    "password": {
      "type": "string",
      "name": "password"
    },
    "port": {
      "type": "integer",
      "name": "port"
    },
    "recipient": {
      "type": "string",
      "name": "recipient"
    }
  },
  "required": [
    "id",
    "serverhost",
    "username",
    "password",
    "port",
    "recipient"
  ]
}

Parameters

Name In Type Required Description
body body SMTP true Request body

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The updated SMTP settings SMTP
400 Bad Request Data structure error. None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Get the current SMTP configuration

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/smtp", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/smtp',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/smtp', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/smtp',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /smtp

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The current SMTP config SMTP
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Test Config Tasks

Get a list of all test config tasks

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/testconfigtasks", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/testconfigtasks',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/testconfigtasks', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/testconfigtasks',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /testconfigtasks

Parameters

Name In Type Required Description
test_config_id query string false Filter by test_config_id
offset query integer false The number of items to skip before result
limit query integer false The numbers of items to return
sort query string false Sort by column: -cname = Descending; +cname = Ascending
limit_per_test_config query integer false The maximum number of items to return for each test configuration

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The list of test config tasks Inline
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [TestConfigTask] false none none
» created_datetime string false none none
» runstatus string true none none
» test_config_id string false none none
» task_instance_id string false none none
» updated_datetime string false none none

Create a new test config task

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/ai/testconfigtasks", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const inputBody = '{
  "properties": {
    "created_datetime": {
      "type": "string",
      "name": "created_datetime"
    },
    "runstatus": {
      "type": "string",
      "name": "runstatus"
    },
    "test_config_id": {
      "type": "string",
      "name": "test_config_id"
    },
    "task_instance_id": {
      "type": "string",
      "name": "task_instance_id"
    },
    "updated_datetime": {
      "type": "string",
      "name": "updated_datetime"
    }
  },
  "required": [
    "runstatus"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/testconfigtasks',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('/ai/testconfigtasks', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post '/ai/testconfigtasks',
  params: {
  }, headers: headers

p JSON.parse(result)

POST /testconfigtasks

Body parameter

{
  "properties": {
    "created_datetime": {
      "type": "string",
      "name": "created_datetime"
    },
    "runstatus": {
      "type": "string",
      "name": "runstatus"
    },
    "test_config_id": {
      "type": "string",
      "name": "test_config_id"
    },
    "task_instance_id": {
      "type": "string",
      "name": "task_instance_id"
    },
    "updated_datetime": {
      "type": "string",
      "name": "updated_datetime"
    }
  },
  "required": [
    "runstatus"
  ]
}

Parameters

Name In Type Required Description
body body TestConfigTask true Request body

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The test config task was created and returned TestConfigTask
400 Bad Request The test instance id was invalid None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Update a test config task

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/ai/testconfigtasks/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const inputBody = '{
  "properties": {
    "created_datetime": {
      "type": "string",
      "name": "created_datetime"
    },
    "runstatus": {
      "type": "string",
      "name": "runstatus"
    },
    "test_config_id": {
      "type": "string",
      "name": "test_config_id"
    },
    "task_instance_id": {
      "type": "string",
      "name": "task_instance_id"
    },
    "updated_datetime": {
      "type": "string",
      "name": "updated_datetime"
    }
  },
  "required": [
    "runstatus"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/testconfigtasks/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('/ai/testconfigtasks/{id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put '/ai/testconfigtasks/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

PUT /testconfigtasks/{id}

Body parameter

{
  "properties": {
    "created_datetime": {
      "type": "string",
      "name": "created_datetime"
    },
    "runstatus": {
      "type": "string",
      "name": "runstatus"
    },
    "test_config_id": {
      "type": "string",
      "name": "test_config_id"
    },
    "task_instance_id": {
      "type": "string",
      "name": "task_instance_id"
    },
    "updated_datetime": {
      "type": "string",
      "name": "updated_datetime"
    }
  },
  "required": [
    "runstatus"
  ]
}

Parameters

Name In Type Required Description
id path string true none
body body TestConfigTask true Request body

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The test config task was updated and returned TestConfigTask
400 Bad Request The run status was invalid None
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found The test config task doesn't exist None

Get a single test config task

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/testconfigtasks/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/testconfigtasks/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/testconfigtasks/{id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/testconfigtasks/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /testconfigtasks/{id}

Parameters

Name In Type Required Description
id path string true none

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The test config task TestConfigTask
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found The test config task doesn't exist None

Get detailed information on a single test config task

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/testconfigtasks/{id}/details", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/testconfigtasks/{id}/details',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/testconfigtasks/{id}/details', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/testconfigtasks/{id}/details',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /testconfigtasks/{id}/details

Parameters

Name In Type Required Description
id path string true none

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The test config task TestConfigTaskDetails
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found The test config task doesn't exist None

Users

Get a list of all users

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/users", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/users',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/users', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/users',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /users

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The list of users Inline
401 Unauthorized Invalid token or token timed out. None
402 Payment Required License limits exceeded. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found There are currently no models None

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [UserSwagger] false none none
» User UserSwagger false none none
»» id any false none none
»» username any false none none
»» role any false none none
»» groups [GroupSwagger] false none none
»»» Group GroupSwagger false none none
»»»» id any false none none
»»»» name any false none none
»» hide_welcome_popup any false none none

Create a user

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/ai/users", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const inputBody = '{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "string"
    },
    "username": {
      "name": "username",
      "type": "string"
    },
    "role": {
      "name": "role",
      "enum": [
        "None",
        "User",
        "Admin"
      ],
      "default": "User",
      "type": "string"
    },
    "groups": {
      "name": "groups",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "password": {
      "name": "password",
      "type": "string"
    },
    "license": {
      "name": "license",
      "type": "string"
    },
    "hide_welcome_popup": {
      "name": "hide_welcome_popup",
      "type": "string"
    }
  },
  "required": [
    "username"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/users',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('/ai/users', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post '/ai/users',
  params: {
  }, headers: headers

p JSON.parse(result)

POST /users

Body parameter

{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "string"
    },
    "username": {
      "name": "username",
      "type": "string"
    },
    "role": {
      "name": "role",
      "enum": [
        "None",
        "User",
        "Admin"
      ],
      "default": "User",
      "type": "string"
    },
    "groups": {
      "name": "groups",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "password": {
      "name": "password",
      "type": "string"
    },
    "license": {
      "name": "license",
      "type": "string"
    },
    "hide_welcome_popup": {
      "name": "hide_welcome_popup",
      "type": "string"
    }
  },
  "required": [
    "username"
  ]
}

Parameters

Name In Type Required Description
body body User true Request body

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The created user UserSwagger
400 Bad Request Invalid username. None
402 Payment Required License limits exceeded. None
403 Forbidden Unauthorised if not admin or initial user. None

Update a user

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/ai/users/{user_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const inputBody = '{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "string"
    },
    "username": {
      "name": "username",
      "type": "string"
    },
    "role": {
      "name": "role",
      "enum": [
        "None",
        "User",
        "Admin"
      ],
      "default": "User",
      "type": "string"
    },
    "groups": {
      "name": "groups",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "password": {
      "name": "password",
      "type": "string"
    },
    "license": {
      "name": "license",
      "type": "string"
    },
    "hide_welcome_popup": {
      "name": "hide_welcome_popup",
      "type": "string"
    }
  },
  "required": [
    "username"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/users/{user_id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('/ai/users/{user_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put '/ai/users/{user_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

PUT /users/{user_id}

Body parameter

{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "string"
    },
    "username": {
      "name": "username",
      "type": "string"
    },
    "role": {
      "name": "role",
      "enum": [
        "None",
        "User",
        "Admin"
      ],
      "default": "User",
      "type": "string"
    },
    "groups": {
      "name": "groups",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "password": {
      "name": "password",
      "type": "string"
    },
    "license": {
      "name": "license",
      "type": "string"
    },
    "hide_welcome_popup": {
      "name": "hide_welcome_popup",
      "type": "string"
    }
  },
  "required": [
    "username"
  ]
}

Parameters

Name In Type Required Description
body body User true Request body

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The updated user UserSwagger
401 Unauthorized Invalid token or token timed out. None
402 Payment Required License limits exceeded. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Delete a user

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/ai/users/{user_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const inputBody = '{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "string"
    },
    "username": {
      "name": "username",
      "type": "string"
    },
    "role": {
      "name": "role",
      "enum": [
        "None",
        "User",
        "Admin"
      ],
      "default": "User",
      "type": "string"
    },
    "groups": {
      "name": "groups",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "password": {
      "name": "password",
      "type": "string"
    },
    "license": {
      "name": "license",
      "type": "string"
    },
    "hide_welcome_popup": {
      "name": "hide_welcome_popup",
      "type": "string"
    }
  },
  "required": [
    "username"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/users/{user_id}',
{
  method: 'DELETE',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('/ai/users/{user_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete '/ai/users/{user_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

DELETE /users/{user_id}

Body parameter

{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "string"
    },
    "username": {
      "name": "username",
      "type": "string"
    },
    "role": {
      "name": "role",
      "enum": [
        "None",
        "User",
        "Admin"
      ],
      "default": "User",
      "type": "string"
    },
    "groups": {
      "name": "groups",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "password": {
      "name": "password",
      "type": "string"
    },
    "license": {
      "name": "license",
      "type": "string"
    },
    "hide_welcome_popup": {
      "name": "hide_welcome_popup",
      "type": "string"
    }
  },
  "required": [
    "username"
  ]
}

Parameters

Name In Type Required Description
body body User true Request body

Responses

Status Meaning Description Schema
200 OK User was deleted successfully None
401 Unauthorized Invalid token or token timed out. None
402 Payment Required License limits exceeded. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Get a single user

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/ai/users/{user_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}


const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/users/{user_id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/ai/users/{user_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get '/ai/users/{user_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /users/{user_id}

Parameters

Name In Type Required Description
user_id path int true none

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The list of users UserSwagger
401 Unauthorized Invalid token or token timed out. None
403 Forbidden Attempt to access a restricted or admin-only resource. None
404 Not Found There are currently no models None

Show / Hide the welcome popup message for a user

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/ai/users/{user_id}/welcome_popup", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const inputBody = '{
  "type": "object",
  "properties": {
    "hide_welcome_popup": {
      "name": "hide_welcome_popup",
      "type": "string"
    }
  },
  "required": [
    "hide_welcome_popup"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/users/{user_id}/welcome_popup',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('/ai/users/{user_id}/welcome_popup', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post '/ai/users/{user_id}/welcome_popup',
  params: {
  }, headers: headers

p JSON.parse(result)

POST /users/{user_id}/welcome_popup

Body parameter

{
  "type": "object",
  "properties": {
    "hide_welcome_popup": {
      "name": "hide_welcome_popup",
      "type": "string"
    }
  },
  "required": [
    "hide_welcome_popup"
  ]
}

Parameters

Name In Type Required Description
body body UserWelcome true Request body

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK The updated user UserSwagger
401 Unauthorized Invalid token or token timed out. None
402 Payment Required License limits exceeded. None
403 Forbidden Attempt to access a restricted or admin-only resource. None

Schemas

TestConfigTask

{
  "properties": {
    "created_datetime": {
      "type": "string",
      "name": "created_datetime"
    },
    "runstatus": {
      "type": "string",
      "name": "runstatus"
    },
    "test_config_id": {
      "type": "string",
      "name": "test_config_id"
    },
    "task_instance_id": {
      "type": "string",
      "name": "task_instance_id"
    },
    "updated_datetime": {
      "type": "string",
      "name": "updated_datetime"
    }
  },
  "required": [
    "runstatus"
  ]
}

Properties

Name Type Required Restrictions Description
created_datetime string false none none
runstatus string true none none
test_config_id string false none none
task_instance_id string false none none
updated_datetime string false none none

TestConfigTaskDetails

{
  "properties": {
    "created_datetime": {
      "type": "string",
      "name": "created_datetime"
    },
    "runstatus": {
      "type": "string",
      "name": "runstatus"
    },
    "test_config_id": {
      "type": "string",
      "name": "test_config_id"
    },
    "task_instance_id": {
      "type": "string",
      "name": "task_instance_id"
    },
    "updated_datetime": {
      "type": "string",
      "name": "updated_datetime"
    },
    "messages": {
      "name": "messages"
    }
  },
  "required": [
    "runstatus",
    "messages"
  ]
}

Properties

Name Type Required Restrictions Description
created_datetime string false none none
runstatus string true none none
test_config_id string false none none
task_instance_id string false none none
updated_datetime string false none none
messages any true none none

Agent

{
  "properties": {
    "id": {
      "type": "integer",
      "name": "id"
    },
    "name": {
      "type": "string",
      "name": "name"
    },
    "recordpath": {
      "type": "string",
      "name": "recordpath"
    },
    "suite": {
      "type": "string",
      "name": "suite"
    },
    "agenttype": {
      "type": "string",
      "name": "agenttype"
    },
    "epphost": {
      "type": "string",
      "name": "epphost"
    },
    "epptestcontrollerport": {
      "type": "integer",
      "name": "epptestcontrollerport"
    },
    "eppanalyzerport": {
      "type": "integer",
      "name": "eppanalyzerport"
    },
    "eppworkspacepath": {
      "type": "string",
      "name": "eppworkspacepath"
    },
    "isconnected": {
      "type": "boolean",
      "name": "isconnected"
    }
  },
  "required": [
    "name",
    "recordpath",
    "suite",
    "epphost",
    "epptestcontrollerport",
    "eppanalyzerport",
    "eppworkspacepath"
  ]
}

Properties

Name Type Required Restrictions Description
id integer false none none
name string true none none
recordpath string true none none
suite string true none none
agenttype string false none none
epphost string true none none
epptestcontrollerport integer true none none
eppanalyzerport integer true none none
eppworkspacepath string true none none
isconnected boolean false none none

CoverageModel

{
  "properties": {
    "id": {
      "type": "integer",
      "name": "id"
    },
    "name": {
      "type": "string",
      "name": "name"
    },
    "variable_depth": {
      "type": "integer",
      "name": "variable_depth"
    },
    "path_depth": {
      "type": "integer",
      "name": "path_depth"
    },
    "active": {
      "type": "boolean",
      "name": "active"
    },
    "created": {
      "type": "string",
      "name": "created"
    }
  }
}

Properties

Name Type Required Restrictions Description
id integer false none none
name string false none none
variable_depth integer false none none
path_depth integer false none none
active boolean false none none
created string false none none

Model

{
  "properties": {
    "id": {
      "type": "integer",
      "name": "id"
    },
    "name": {
      "type": "string",
      "name": "name"
    },
    "group": {
      "type": "string",
      "name": "group"
    },
    "agent": {
      "type": "integer",
      "name": "agent"
    },
    "created": {
      "type": "string",
      "name": "created"
    },
    "updated": {
      "type": "string",
      "name": "updated"
    },
    "modeljson": {
      "type": "string",
      "name": "modeljson"
    }
  },
  "required": [
    "group"
  ]
}

Properties

Name Type Required Restrictions Description
id integer false none none
name string false none none
group string true none none
agent integer false none none
created string false none none
updated string false none none
modeljson string false none none

ModelAgent

{
  "type": "object",
  "properties": {
    "agent": {
      "name": "agent",
      "type": "integer"
    }
  },
  "required": [
    "agent"
  ]
}

Properties

Name Type Required Restrictions Description
agent integer true none none

Run

{
  "properties": {
    "id": {
      "type": "integer",
      "name": "id"
    },
    "hierarchyid": {
      "type": "integer",
      "name": "hierarchyid"
    },
    "modelname": {
      "type": "string",
      "name": "modelname"
    },
    "groupid": {
      "type": "integer",
      "name": "groupid"
    },
    "teststatus": {
      "type": "string",
      "name": "teststatus"
    },
    "starttime": {
      "type": "string",
      "name": "starttime"
    },
    "endtime": {
      "type": "string",
      "name": "endtime"
    },
    "seed": {
      "type": "integer",
      "name": "seed"
    },
    "coverage": {
      "type": "float",
      "name": "coverage"
    },
    "logfile": {
      "type": "string",
      "name": "logfile"
    },
    "usedtests": {
      "type": "string",
      "name": "usedtests"
    },
    "events": {
      "type": "boolean",
      "name": "events"
    },
    "runtype": {
      "type": "string",
      "name": "runtype"
    },
    "testcase": {
      "type": "string",
      "name": "testcase"
    },
    "testconfigtask": {
      "name": "testconfigtask"
    },
    "step": {
      "type": "integer",
      "name": "step"
    },
    "failedaction": {
      "type": "string",
      "name": "failedaction"
    }
  },
  "required": [
    "id",
    "hierarchyid",
    "modelname",
    "groupid",
    "teststatus",
    "starttime",
    "endtime",
    "seed",
    "coverage",
    "logfile",
    "usedtests",
    "events",
    "runtype",
    "testcase",
    "testconfigtask",
    "step",
    "failedaction"
  ]
}

Properties

Name Type Required Restrictions Description
id integer true none none
hierarchyid integer true none none
modelname string true none none
groupid integer true none none
teststatus string true none none
starttime string true none none
endtime string true none none
seed integer true none none
coverage float true none none
logfile string true none none
usedtests string true none none
events boolean true none none
runtype string true none none
testcase string true none none
testconfigtask any true none none
step integer true none none
failedaction string true none none

ModelCoverage

{
  "properties": {
    "bob": {
      "type": "string",
      "name": "bob"
    }
  },
  "required": [
    "bob"
  ]
}

Properties

Name Type Required Restrictions Description
bob string true none none

TestCases

{
  "properties": {
    "testcaseName": {
      "type": "string",
      "name": "testcaseName"
    },
    "testcase": {
      "type": "string",
      "name": "testcase"
    },
    "id": {
      "type": "integer",
      "name": "id"
    },
    "tests": {
      "type": "string",
      "name": "tests"
    },
    "fails": {
      "type": "string",
      "name": "fails"
    },
    "testcaseTags": {
      "type": "string",
      "name": "testcaseTags"
    },
    "testcaseDescription": {
      "type": "string",
      "name": "testcaseDescription"
    },
    "testcaseOrigin": {
      "type": "string",
      "name": "testcaseOrigin"
    },
    "testcaseExternalID": {
      "type": "string",
      "name": "testcaseExternalID"
    },
    "testIds": {
      "type": "string",
      "name": "testIds"
    }
  },
  "required": [
    "testcaseName",
    "testcase"
  ]
}

Properties

Name Type Required Restrictions Description
testcaseName string true none none
testcase string true none none
id integer false none none
tests string false none none
fails string false none none
testcaseTags string false none none
testcaseDescription string false none none
testcaseOrigin string false none none
testcaseExternalID string false none none
testIds string false none none

ModelTags

{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "integer"
    },
    "model": {
      "name": "model",
      "type": "string"
    },
    "tag": {
      "name": "tag",
      "type": "string"
    },
    "created": {
      "name": "created",
      "type": "string"
    },
    "author": {
      "name": "author",
      "type": "string"
    }
  },
  "required": [
    "model",
    "tag",
    "author"
  ]
}

Properties

Name Type Required Restrictions Description
id integer false none none
model string true none none
tag string true none none
created string false none none
author string true none none

Timings

{
  "properties": {
    "order": {
      "type": "integer",
      "name": "order"
    },
    "state": {
      "type": "string",
      "name": "state"
    },
    "action": {
      "type": "string",
      "name": "action"
    },
    "timing": {
      "type": "float",
      "name": "timing"
    }
  },
  "required": [
    "order",
    "state",
    "action",
    "timing"
  ]
}

Properties

Name Type Required Restrictions Description
order integer true none none
state string true none none
action string true none none
timing float true none none

Screenshots

{
  "properties": {
    "timestamp": {
      "type": "string",
      "name": "timestamp"
    },
    "artifactid": {
      "type": "string",
      "name": "artifactid"
    },
    "name": {
      "type": "string",
      "name": "name"
    },
    "capture_type": {
      "type": "string",
      "name": "capture_type"
    },
    "content_type": {
      "type": "string",
      "name": "content_type"
    },
    "state": {
      "type": "string",
      "name": "state"
    },
    "action": {
      "type": "string",
      "name": "action"
    }
  },
  "required": [
    "timestamp",
    "artifactid",
    "name",
    "capture_type",
    "content_type",
    "state",
    "action"
  ]
}

Properties

Name Type Required Restrictions Description
timestamp string true none none
artifactid string true none none
name string true none none
capture_type string true none none
content_type string true none none
state string true none none
action string true none none

TestConfigTaskSummary

{
  "properties": {
    "total_steps_in_test_config": {
      "type": "integer",
      "name": "total_steps_in_test_config"
    },
    "test_config_total_runs_complete": {
      "type": "integer",
      "name": "test_config_total_runs_complete"
    },
    "test_config_total_runs_passes": {
      "type": "integer",
      "name": "test_config_total_runs_passes"
    },
    "test_config_total_runs_failures": {
      "type": "integer",
      "name": "test_config_total_runs_failures"
    },
    "test_config_total_runs_incomplete": {
      "type": "integer",
      "name": "test_config_total_runs_incomplete"
    },
    "test_config_total_runs_cancelled": {
      "type": "integer",
      "name": "test_config_total_runs_cancelled"
    },
    "test_config_total_runs_in_error": {
      "type": "integer",
      "name": "test_config_total_runs_in_error"
    },
    "total_execution_time_secs": {
      "type": "float",
      "name": "total_execution_time_secs"
    },
    "task_instance_steps_completed": {
      "type": "integer",
      "name": "task_instance_steps_completed"
    },
    "sut_used": {
      "type": "string",
      "name": "sut_used"
    }
  },
  "required": [
    "total_steps_in_test_config",
    "test_config_total_runs_complete",
    "test_config_total_runs_passes",
    "test_config_total_runs_failures",
    "test_config_total_runs_incomplete",
    "test_config_total_runs_cancelled",
    "test_config_total_runs_in_error",
    "total_execution_time_secs",
    "task_instance_steps_completed",
    "sut_used"
  ]
}

Properties

Name Type Required Restrictions Description
total_steps_in_test_config integer true none none
test_config_total_runs_complete integer true none none
test_config_total_runs_passes integer true none none
test_config_total_runs_failures integer true none none
test_config_total_runs_incomplete integer true none none
test_config_total_runs_cancelled integer true none none
test_config_total_runs_in_error integer true none none
total_execution_time_secs float true none none
task_instance_steps_completed integer true none none
sut_used string true none none

NewModelAsset

{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "integer"
    },
    "asset_id": {
      "name": "asset_id",
      "type": "string"
    },
    "model_id": {
      "name": "model_id",
      "type": "integer"
    }
  },
  "required": [
    "asset_id"
  ]
}

Properties

Name Type Required Restrictions Description
id integer false none none
asset_id string true none none
model_id integer false none none

RunLogs

{
  "properties": {
    "id": {
      "type": "integer",
      "name": "id"
    },
    "eventtime": {
      "type": "string",
      "name": "eventtime"
    },
    "testrunid": {
      "type": "integer",
      "name": "testrunid"
    },
    "message": {
      "type": "string",
      "name": "message"
    }
  },
  "required": [
    "id",
    "eventtime",
    "testrunid",
    "message"
  ]
}

Properties

Name Type Required Restrictions Description
id integer true none none
eventtime string true none none
testrunid integer true none none
message string true none none

ReleaseInsights

{
  "properties": {
    "id": {
      "type": "integer",
      "name": "id"
    }
  },
  "required": [
    "id"
  ]
}

Properties

Name Type Required Restrictions Description
id integer true none none

Error

{
  "properties": {
    "id": {
      "type": "integer",
      "name": "id"
    },
    "created": {
      "type": "string",
      "name": "created"
    },
    "task_instance_id": {
      "type": "string",
      "name": "task_instance_id"
    },
    "sender": {
      "type": "string",
      "name": "sender"
    },
    "severity": {
      "type": "string",
      "name": "severity"
    },
    "message": {
      "type": "string",
      "name": "message"
    },
    "error_time": {
      "type": "string",
      "name": "error_time"
    }
  },
  "required": [
    "id",
    "created",
    "task_instance_id",
    "sender",
    "severity",
    "message",
    "error_time"
  ]
}

Properties

Name Type Required Restrictions Description
id integer true none none
created string true none none
task_instance_id string true none none
sender string true none none
severity string true none none
message string true none none
error_time string true none none

Ping

{
  "type": "object",
  "properties": {
    "status": "string",
    "allow_log_download": "bool"
  }
}

Properties

Name Type Required Restrictions Description
status any false none none
allow_log_download any false none none

SwaggerToken

{
  "type": "object",
  "title": "Token",
  "properties": {
    "access_token": {
      "type": "string"
    },
    "expires_in": {
      "type": "int"
    },
    "token_type": {
      "type": "string"
    },
    "payload": {
      "type": "object",
      "title": "TokenPayload",
      "properties": {
        "exp": {
          "type": "int"
        },
        "iat": {
          "type": "datetime"
        },
        "iss": {
          "type": "string"
        },
        "rand": {
          "type": "int"
        },
        "user": {
          "type": "object",
          "title": "TokenUsername",
          "properties": {
            "username": {
              "type": "string"
            },
            "role": {
              "type": "string",
              "enum": [
                "admin",
                "user",
                "none"
              ]
            }
          }
        }
      }
    }
  }
}

Token

Properties

Name Type Required Restrictions Description
access_token string false none none
expires_in int false none none
token_type string false none none
payload SwaggerTokenPayload false none none

SwaggerTokenPayload

{
  "type": "object",
  "title": "TokenPayload",
  "properties": {
    "exp": {
      "type": "int"
    },
    "iat": {
      "type": "datetime"
    },
    "iss": {
      "type": "string"
    },
    "rand": {
      "type": "int"
    },
    "user": {
      "type": "object",
      "title": "TokenUsername",
      "properties": {
        "username": {
          "type": "string"
        },
        "role": {
          "type": "string",
          "enum": [
            "admin",
            "user",
            "none"
          ]
        }
      }
    }
  }
}

TokenPayload

Properties

Name Type Required Restrictions Description
exp int false none none
iat datetime false none none
iss string false none none
rand int false none none
user SwaggerTokenUserInfo false none none

SwaggerTokenUserInfo

{
  "type": "object",
  "title": "TokenUsername",
  "properties": {
    "username": {
      "type": "string"
    },
    "role": {
      "type": "string",
      "enum": [
        "admin",
        "user",
        "none"
      ]
    }
  }
}

TokenUsername

Properties

Name Type Required Restrictions Description
username string false none none
role string false none none

Enumerated Values

Property Value
role admin
role user
role none

Groups

{
  "properties": {
    "id": {
      "type": "integer",
      "name": "id"
    },
    "groupname": {
      "type": "string",
      "name": "groupname"
    }
  },
  "required": [
    "groupname"
  ]
}

Properties

Name Type Required Restrictions Description
id integer false none none
groupname string true none none

Group

{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "integer"
    },
    "groupname": {
      "name": "groupname",
      "type": "string"
    }
  },
  "required": [
    "groupname"
  ]
}

Properties

Name Type Required Restrictions Description
id integer false none none
groupname string true none none

UserSwagger

{
  "type": "object",
  "title": "User",
  "properties": {
    "id": "int",
    "username": "string",
    "role": "string",
    "groups": {
      "type": "array",
      "items": {
        "title": "Group",
        "properties": {
          "id": "string",
          "name": "string"
        },
        "type": "object"
      }
    },
    "hide_welcome_popup": "bool"
  }
}

User

Properties

Name Type Required Restrictions Description
id any false none none
username any false none none
role any false none none
groups [GroupSwagger] false none none
hide_welcome_popup any false none none

GroupSwagger

{
  "title": "Group",
  "properties": {
    "id": "string",
    "name": "string"
  },
  "type": "object"
}

Group

Properties

Name Type Required Restrictions Description
id any false none none
name any false none none

User

{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "string"
    },
    "username": {
      "name": "username",
      "type": "string"
    },
    "role": {
      "name": "role",
      "enum": [
        "None",
        "User",
        "Admin"
      ],
      "default": "User",
      "type": "string"
    },
    "groups": {
      "name": "groups",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "password": {
      "name": "password",
      "type": "string"
    },
    "license": {
      "name": "license",
      "type": "string"
    },
    "hide_welcome_popup": {
      "name": "hide_welcome_popup",
      "type": "string"
    }
  },
  "required": [
    "username"
  ]
}

Properties

Name Type Required Restrictions Description
id string false none none
username string true none none
role string false none none
groups [string] false none none
password string false none none
license string false none none
hide_welcome_popup string false none none

Enumerated Values

Property Value
role None
role User
role Admin

UserWelcome

{
  "type": "object",
  "properties": {
    "hide_welcome_popup": {
      "name": "hide_welcome_popup",
      "type": "string"
    }
  },
  "required": [
    "hide_welcome_popup"
  ]
}

Properties

Name Type Required Restrictions Description
hide_welcome_popup string true none none

SMTP

{
  "properties": {
    "id": {
      "type": "integer",
      "name": "id"
    },
    "serverhost": {
      "type": "string",
      "name": "serverhost"
    },
    "username": {
      "type": "string",
      "name": "username"
    },
    "password": {
      "type": "string",
      "name": "password"
    },
    "port": {
      "type": "integer",
      "name": "port"
    },
    "recipient": {
      "type": "string",
      "name": "recipient"
    }
  },
  "required": [
    "id",
    "serverhost",
    "username",
    "password",
    "port",
    "recipient"
  ]
}

Properties

Name Type Required Restrictions Description
id integer true none none
serverhost string true none none
username string true none none
password string true none none
port integer true none none
recipient string true none none

Licenses

{
  "properties": {
    "serialnumber": {
      "type": "integer",
      "name": "serialnumber"
    },
    "license": {
      "type": "string",
      "name": "license"
    }
  },
  "required": [
    "serialnumber",
    "license"
  ]
}

Properties

Name Type Required Restrictions Description
serialnumber integer true none none
license string true none none

License

{
  "type": "object",
  "properties": {
    "serialnumber": {
      "name": "serialnumber",
      "type": "integer"
    },
    "license": {
      "name": "license",
      "type": "string"
    }
  },
  "required": [
    "serialnumber",
    "license"
  ]
}

Properties

Name Type Required Restrictions Description
serialnumber integer true none none
license string true none none

LicenseUsage

{
  "type": "object",
  "properties": {
    "num_users": "int",
    "num_sessions": "int",
    "num_execs": "int"
  }
}

Properties

Name Type Required Restrictions Description
num_users any false none none
num_sessions any false none none
num_execs any false none none

Coverage_Model

{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "integer"
    },
    "name": {
      "name": "name",
      "type": "string"
    },
    "variable_depth": {
      "name": "variable_depth",
      "type": "integer"
    },
    "path_depth": {
      "name": "path_depth",
      "type": "integer"
    },
    "active": {
      "name": "active",
      "type": "boolean"
    },
    "created": {
      "name": "created",
      "type": "string"
    }
  }
}

Properties

Name Type Required Restrictions Description
id integer false none none
name string false none none
variable_depth integer false none none
path_depth integer false none none
active boolean false none none
created string false none none

Create_test_case

{
  "type": "object",
  "properties": {
    "testcaseName": {
      "name": "testcaseName",
      "type": "string"
    },
    "testcase": {
      "name": "testcase",
      "type": "string"
    },
    "id": {
      "name": "id",
      "type": "integer"
    },
    "tests": {
      "name": "tests",
      "type": "string"
    },
    "fails": {
      "name": "fails",
      "type": "string"
    },
    "testcaseTags": {
      "name": "testcaseTags",
      "type": "string"
    },
    "testcaseDescription": {
      "name": "testcaseDescription",
      "type": "string"
    },
    "testcaseOrigin": {
      "name": "testcaseOrigin",
      "type": "string"
    },
    "testcaseExternalID": {
      "name": "testcaseExternalID",
      "type": "string"
    },
    "testIds": {
      "name": "testIds",
      "type": "string"
    }
  },
  "required": [
    "testcaseName",
    "testcase"
  ]
}

Properties

Name Type Required Restrictions Description
testcaseName string true none none
testcase string true none none
id integer false none none
tests string false none none
fails string false none none
testcaseTags string false none none
testcaseDescription string false none none
testcaseOrigin string false none none
testcaseExternalID string false none none
testIds string false none none

Update_test_case

{
  "type": "object",
  "properties": {
    "testcaseName": {
      "name": "testcaseName",
      "type": "string"
    },
    "testcase": {
      "name": "testcase",
      "type": "string"
    },
    "id": {
      "name": "id",
      "type": "integer"
    },
    "tests": {
      "name": "tests",
      "type": "string"
    },
    "fails": {
      "name": "fails",
      "type": "string"
    },
    "testcaseTags": {
      "name": "testcaseTags",
      "type": "string"
    },
    "testcaseDescription": {
      "name": "testcaseDescription",
      "type": "string"
    },
    "testcaseOrigin": {
      "name": "testcaseOrigin",
      "type": "string"
    },
    "testcaseExternalID": {
      "name": "testcaseExternalID",
      "type": "string"
    },
    "testIds": {
      "name": "testIds",
      "type": "string"
    }
  },
  "required": [
    "testcaseName",
    "testcase"
  ]
}

Properties

Name Type Required Restrictions Description
testcaseName string true none none
testcase string true none none
id integer false none none
tests string false none none
fails string false none none
testcaseTags string false none none
testcaseDescription string false none none
testcaseOrigin string false none none
testcaseExternalID string false none none
testIds string false none none

Update_model_tag

{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "integer"
    },
    "model": {
      "name": "model",
      "type": "string"
    },
    "tag": {
      "name": "tag",
      "type": "string"
    },
    "created": {
      "name": "created",
      "type": "string"
    },
    "author": {
      "name": "author",
      "type": "string"
    }
  },
  "required": [
    "model",
    "tag",
    "author"
  ]
}

Properties

Name Type Required Restrictions Description
id integer false none none
model string true none none
tag string true none none
created string false none none
author string true none none

Create_new_Model_Asset

{
  "type": "object",
  "properties": {
    "id": {
      "name": "id",
      "type": "integer"
    },
    "asset_id": {
      "name": "asset_id",
      "type": "string"
    },
    "model_id": {
      "name": "model_id",
      "type": "integer"
    }
  },
  "required": [
    "asset_id"
  ]
}

Properties

Name Type Required Restrictions Description
id integer false none none
asset_id string true none none
model_id integer false none none

Generated at 13:13:52 GMT+0000 (Coordinated Universal Time) on Tue Oct 27 2020 from AUB-6220 (fac9509b)