DAI API v5.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:

• /ai

Authentication

• oAuth2 authentication.

  • Flow: password

  • Token URL = http://localhost:4568/ai/auth

Scope	Scope Description
user	User
admin	Admin

Agents

Create a new agent

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/x-www-form-urlencoded"},
        "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 = '{
  "type": "object",
  "properties": {
    "name": {
      "description": "Unique name",
      "type": "string"
    },
    "recordpath": {
      "description": "Record path",
      "type": "string",
      "default": ""
    },
    "suite": {
      "description": " EPF suite",
      "type": "string",
      "default": ""
    },
    "agenttype": {
      "description": "Agent type. Examples: DESIGN or RUN",
      "type": "string",
      "default": "DESIGN"
    },
    "epphost": {
      "description": "EPP host IP address",
      "type": "string",
      "default": ""
    },
    "epptestcontrollerport": {
      "description": "Port number of EPP Test Controller",
      "type": "integer",
      "default": 123
    },
    "eppanalyzerport": {
      "description": "Port number of EPP Analyzer",
      "type": "integer",
      "default": 123
    },
    "eppworkspacepath": {
      "description": "EPP workspace path",
      "type": "string",
      "default": ""
    },
    "isconnected": {
      "description": "Indicate connected Agent",
      "type": "boolean",
      "default": false
    },
    "ishosted": {
      "description": "Indicate hosted Agent",
      "type": "boolean",
      "default": false
    }
  },
  "required": [
    "name",
    "recordpath",
    "suite",
    "agenttype",
    "epphost",
    "epptestcontrollerport",
    "eppanalyzerport",
    "eppworkspacepath"
  ]
}';
const headers = {
  'Content-Type':'application/x-www-form-urlencoded',
  '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/x-www-form-urlencoded',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

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

print(r.json())

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

POST /agents

Body parameter

type: object
properties:
  name:
    description: Unique name
    type: string
  recordpath:
    description: Record path
    type: string
    default: ""
  suite:
    description: " EPF suite"
    type: string
    default: ""
  agenttype:
    description: "Agent type. Examples: DESIGN or RUN"
    type: string
    default: DESIGN
  epphost:
    description: EPP host IP address
    type: string
    default: ""
  epptestcontrollerport:
    description: Port number of EPP Test Controller
    type: integer
    default: 123
  eppanalyzerport:
    description: Port number of EPP Analyzer
    type: integer
    default: 123
  eppworkspacepath:
    description: EPP workspace path
    type: string
    default: ""
  isconnected:
    description: Indicate connected Agent
    type: boolean
    default: false
  ishosted:
    description: Indicate hosted Agent
    type: boolean
    default: false
required:
  - name
  - recordpath
  - suite
  - agenttype
  - epphost
  - epptestcontrollerport
  - eppanalyzerport
  - eppworkspacepath

Parameters

Name	In	Type	Required	Description
body	body	object	true	none
» name	body	string	true	Unique name
» recordpath	body	string	true	Record path
» suite	body	string	true	EPF suite
» agenttype	body	string	true	Agent type. Examples: DESIGN or RUN
» epphost	body	string	true	EPP host IP address
» epptestcontrollerport	body	integer	true	Port number of EPP Test Controller
» eppanalyzerport	body	integer	true	Port number of EPP Analyzer
» eppworkspacepath	body	string	true	EPP workspace path
» isconnected	body	boolean	false	Indicate connected Agent
» ishosted	body	boolean	false	Indicate hosted Agent

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

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

Parameters

Name	In	Type	Required	Description
include_hosted	query	boolean	false	Include hosted Agents in the result

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
» ishosted	boolean	false	none	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"
    },
    "ishosted": {
      "type": "boolean",
      "name": "ishosted"
    }
  },
  "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"
    },
    "ishosted": {
      "type": "boolean",
      "name": "ishosted"
    }
  },
  "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

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

Use this endpoint to obtain a bearer token, which can be passed in an Authorization header to any other endpoint that requires authentication. Note: Unlike other endpoints, the POST /auth endpoint requires username and password to be passed using Content-Type: application/x-www-form-urlencoded.

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	true	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	UserSwagger
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

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

Temporary Endpoint for Keycloak consumption

Code samples

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/ai/internal/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':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('/ai/internal/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': '*/*',
  'Authorization': 'Bearer {access-token}'
}

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

print(r.json())

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

POST /internal/auth

Use this endpoint to obtain user details with username and password. To be used by Keycloak for login. Requires username and password to be passed using Content-Type: application/x-www-form-urlencoded.

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	true	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	SwaggerUser
400	Bad Request	Bad request	None
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

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

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

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

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

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

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

Update all licenses

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("PATCH", "/ai/licenses", data)
    req.Header = headers

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

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

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

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

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

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

print(r.json())

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

PATCH /licenses

Responses

Status	Meaning	Description	Schema
200	OK	The license was updated	None
403	Forbidden	Access denied	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"
    },
    "eula_accepted": {
      "name": "eula_accepted",
      "type": "boolean"
    }
  },
  "required": [
    "serialnumber",
    "license",
    "eula_accepted"
  ]
}';
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"
    },
    "eula_accepted": {
      "name": "eula_accepted",
      "type": "boolean"
    }
  },
  "required": [
    "serialnumber",
    "license",
    "eula_accepted"
  ]
}

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

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
403	Forbidden	User must be an Admin	None
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
» eula_accepted	boolean	true	none	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	LicenseStatus

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

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"
    },
    "modeluuid": {
      "type": "string",
      "name": "modeluuid"
    },
    "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"
    },
    "modeluuid": {
      "type": "string",
      "name": "modeluuid"
    },
    "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

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
» modeluuid	string	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

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"
    },
    "modeluuid": {
      "type": "string",
      "name": "modeluuid"
    },
    "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"
    },
    "modeluuid": {
      "type": "string",
      "name": "modeluuid"
    },
    "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 actions with RCI and failure summary

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}/actions", data)
    req.Header = headers

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

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

fetch('/ai/models/{model_id}/actions',
{
  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}/actions', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

GET /models/{model_id}/actions

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	The model actions list	Inline
400	Bad Request	The model data was invalid	None
401	Unauthorized	Invalid token or token timed out.	None
403	Forbidden	Not authorized to access the model.	None
404	Not Found	The model not found.	None

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
anonymous	[ModelAction]	false	none	none
» stateName	string	true	none	none
» actionName	string	true	none	none
» passes	integer	true	none	none
» is_rci	boolean	true	none	none
» fails	integer	true	none	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

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

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

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

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

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

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
starttime	query	string	false	Only include runs that occurred after this time
endtime	query	string	false	Only include runs that occurred before this time

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
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
» scriptname	string	true	none	none
» suitename	string	true	none	none

Get count of each test status for each test cases in 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}/testcasesummary", data)
    req.Header = headers

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

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

fetch('/ai/models/{model_id}/testcasesummary',
{
  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}/testcasesummary', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

GET /models/{model_id}/testcasesummary

Parameters

Name	In	Type	Required	Description
model_id	path	integer	true	The model id
starttime	query	string	false	Only include runs that occurred after this time
endtime	query	string	false	Only include runs that occurred before this time

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
404	Not Found	Model not found	None

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
» items	[RunSummary]	false	none	none
»» testcase	string	true	none	none
»» passcount	integer	true	none	none
»» failcount	integer	true	none	none
»» cancelcount	integer	true	none	none
»» errorcount	integer	true	none	none
»» incompletecount	integer	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
testcase	query	string	false	The test case 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
modeluuid	query	integer	false	The test modeluuid to include in results

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
»» scriptname	string	true	none	none
»» suitename	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

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"
    },
    "modelId": {
      "name": "modelId",
      "type": "string"
    },
    "modelName": {
      "name": "modelName",
      "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"
    },
    "modelId": {
      "name": "modelId",
      "type": "string"
    },
    "modelName": {
      "name": "modelName",
      "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

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/testcases", data)
    req.Header = headers

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

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

fetch('/ai/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/testcases', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

GET /testcases

Parameters

Name	In	Type	Required	Description
modelid	query	string	false	The model UUID to include in the results
searchText	query	string	false	The search criteria to include in the results
sort	query	string	false	The sort criteria
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 testcases	Inline
400	Bad Request	parameter is incorrect	None
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	[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
» modelId	string	false	none	none
» modelName	string	false	none	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"
    },
    "modelId": {
      "name": "modelId",
      "type": "string"
    },
    "modelName": {
      "name": "modelName",
      "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"
    },
    "modelId": {
      "name": "modelId",
      "type": "string"
    },
    "modelName": {
      "name": "modelName",
      "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

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

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

Run Screenshots

Get screenshots for a run

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

Get a single run's screenshots and metadata

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
»» script	string	true	none	none
»» suite	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

Add a screenshot

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

Post a MessagePack-encoded object containing a screenshot and metadata

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 a presigned screenshot URL

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}

Get presigned object URL for screenshot with given 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 a presigned screenshot URL with Content-Disposition

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

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

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

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

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

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

Get a list of all test config tasks with extra information from ExecutionStatus

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_extended", data)
    req.Header = headers

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

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

fetch('/ai/testconfigtasks_extended',
{
  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_extended', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

GET /testconfigtasks_extended

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	[TestConfigTaskExtended]	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
» suts	string	true	none	none
» test_config_name	string	true	none	none
» agents	string	true	none	none
» model_name	string	true	none	none

Users

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	Exceeded the maximum number of users	None
403	Forbidden	User must be an Admin.	None
409	Conflict	User or group already exists	None

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 users	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

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 user	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
400	Bad Request	Incorrect params passed.	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

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

TestConfigTaskExtended

{
  "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"
    },
    "suts": {
      "type": "string",
      "name": "suts"
    },
    "test_config_name": {
      "type": "string",
      "name": "test_config_name"
    },
    "agents": {
      "type": "string",
      "name": "agents"
    },
    "model_name": {
      "type": "string",
      "name": "model_name"
    }
  },
  "required": [
    "runstatus",
    "suts",
    "test_config_name",
    "agents",
    "model_name"
  ]
}

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
suts	string	true	none	none
test_config_name	string	true	none	none
agents	string	true	none	none
model_name	string	true	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"
    },
    "ishosted": {
      "type": "boolean",
      "name": "ishosted"
    }
  },
  "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
ishosted	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"
    },
    "modeluuid": {
      "type": "string",
      "name": "modeluuid"
    },
    "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
modeluuid	string	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"
    },
    "scriptname": {
      "type": "string",
      "name": "scriptname"
    },
    "suitename": {
      "type": "string",
      "name": "suitename"
    }
  },
  "required": [
    "id",
    "hierarchyid",
    "modelname",
    "groupid",
    "teststatus",
    "starttime",
    "endtime",
    "seed",
    "coverage",
    "logfile",
    "usedtests",
    "events",
    "runtype",
    "testcase",
    "testconfigtask",
    "step",
    "failedaction",
    "scriptname",
    "suitename"
  ]
}

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
scriptname	string	true	none	none
suitename	string	true	none	none

RunSummary

{
  "properties": {
    "testcase": {
      "type": "string",
      "name": "testcase"
    },
    "passcount": {
      "type": "integer",
      "name": "passcount"
    },
    "failcount": {
      "type": "integer",
      "name": "failcount"
    },
    "cancelcount": {
      "type": "integer",
      "name": "cancelcount"
    },
    "errorcount": {
      "type": "integer",
      "name": "errorcount"
    },
    "incompletecount": {
      "type": "integer",
      "name": "incompletecount"
    }
  },
  "required": [
    "testcase",
    "passcount",
    "failcount",
    "cancelcount",
    "errorcount",
    "incompletecount"
  ]
}

Properties

Name	Type	Required	Restrictions	Description
testcase	string	true	none	none
passcount	integer	true	none	none
failcount	integer	true	none	none
cancelcount	integer	true	none	none
errorcount	integer	true	none	none
incompletecount	integer	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"
    },
    "modelId": {
      "type": "string",
      "name": "modelId"
    },
    "modelName": {
      "type": "string",
      "name": "modelName"
    }
  },
  "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
modelId	string	false	none	none
modelName	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"
    },
    "script": {
      "type": "string",
      "name": "script"
    },
    "suite": {
      "type": "string",
      "name": "suite"
    }
  },
  "required": [
    "timestamp",
    "artifactid",
    "name",
    "capture_type",
    "content_type",
    "state",
    "action",
    "script",
    "suite"
  ]
}

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
script	string	true	none	none
suite	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

ModelAction

{
  "properties": {
    "stateName": {
      "type": "string",
      "name": "stateName"
    },
    "actionName": {
      "type": "string",
      "name": "actionName"
    },
    "passes": {
      "type": "integer",
      "name": "passes"
    },
    "is_rci": {
      "type": "boolean",
      "name": "is_rci"
    },
    "fails": {
      "type": "integer",
      "name": "fails"
    }
  },
  "required": [
    "stateName",
    "actionName",
    "passes",
    "is_rci",
    "fails"
  ]
}

Properties

Name	Type	Required	Restrictions	Description
stateName	string	true	none	none
actionName	string	true	none	none
passes	integer	true	none	none
is_rci	boolean	true	none	none
fails	integer	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

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

SwaggerToken

{
  "type": "object",
  "title": "Token",
  "properties": {
    "access_token": {
      "type": "string"
    },
    "expires_in": {
      "type": "integer"
    },
    "token_type": {
      "type": "string"
    },
    "payload": {
      "type": "object",
      "title": "TokenPayload",
      "properties": {
        "exp": {
          "type": "integer"
        },
        "iat": {
          "type": "datetime"
        },
        "iss": {
          "type": "string"
        },
        "rand": {
          "type": "integer"
        },
        "user": {
          "type": "object",
          "title": "TokenUsername",
          "properties": {
            "username": {
              "type": "string"
            },
            "role": {
              "type": "string",
              "enum": [
                "admin",
                "user",
                "none"
              ],
              "is_service": "boolean"
            }
          }
        }
      }
    }
  }
}

Token

Properties

Name	Type	Required	Restrictions	Description
access_token	string	false	none	none
expires_in	integer	false	none	none
token_type	string	false	none	none
payload	SwaggerTokenPayload	false	none	none

SwaggerTokenPayload

{
  "type": "object",
  "title": "TokenPayload",
  "properties": {
    "exp": {
      "type": "integer"
    },
    "iat": {
      "type": "datetime"
    },
    "iss": {
      "type": "string"
    },
    "rand": {
      "type": "integer"
    },
    "user": {
      "type": "object",
      "title": "TokenUsername",
      "properties": {
        "username": {
          "type": "string"
        },
        "role": {
          "type": "string",
          "enum": [
            "admin",
            "user",
            "none"
          ],
          "is_service": "boolean"
        }
      }
    }
  }
}

TokenPayload

Properties

Name	Type	Required	Restrictions	Description
exp	integer	false	none	none
iat	datetime	false	none	none
iss	string	false	none	none
rand	integer	false	none	none
user	SwaggerTokenUserInfo	false	none	none

SwaggerTokenUserInfo

{
  "type": "object",
  "title": "TokenUsername",
  "properties": {
    "username": {
      "type": "string"
    },
    "role": {
      "type": "string",
      "enum": [
        "admin",
        "user",
        "none"
      ],
      "is_service": "boolean"
    }
  }
}

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

SwaggerUser

{
  "type": "object",
  "title": "Merged user and token data",
  "properties": {
    "id": {
      "type": "string"
    },
    "username": {
      "type": "string"
    },
    "role": {
      "type": "string"
    },
    "groups": {
      "type": "array",
      "items": {
        "type": "object",
        "title": "Group",
        "properties": {
          "id": {
            "type": "integer"
          },
          "name": {
            "type": "string"
          }
        }
      }
    },
    "hide_welcome_popup": {
      "type": "boolean"
    }
  }
}

Merged user and token data

Properties

Name	Type	Required	Restrictions	Description
id	string	false	none	none
username	string	false	none	none
role	string	false	none	none
groups	[SwaggerGroupSchema]	false	none	none
hide_welcome_popup	boolean	false	none	none

SwaggerGroupSchema

{
  "type": "object",
  "title": "Group",
  "properties": {
    "id": {
      "type": "integer"
    },
    "name": {
      "type": "string"
    }
  }
}

Group

Properties

Name	Type	Required	Restrictions	Description
id	integer	false	none	none
name	string	false	none	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

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"
    },
    "eula_accepted": {
      "type": "boolean",
      "name": "eula_accepted"
    }
  },
  "required": [
    "serialnumber",
    "license",
    "eula_accepted"
  ]
}

Properties

Name	Type	Required	Restrictions	Description
serialnumber	integer	true	none	none
license	string	true	none	none
eula_accepted	boolean	true	none	none

License

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

Properties

Name	Type	Required	Restrictions	Description
serialnumber	integer	true	none	none
license	string	true	none	none
eula_accepted	boolean	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

LicenseStatus

{
  "type": "object",
  "properties": {
    "status": "str",
    "version": "str",
    "configured": "bool",
    "has_valid_license": "bool",
    "eula_accepted": "bool"
  }
}

Properties

Name	Type	Required	Restrictions	Description
status	any	false	none	none
version	any	false	none	none
configured	any	false	none	none
has_valid_license	any	false	none	none
eula_accepted	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"
    },
    "modelId": {
      "name": "modelId",
      "type": "string"
    },
    "modelName": {
      "name": "modelName",
      "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
modelId	string	false	none	none
modelName	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"
    },
    "modelId": {
      "name": "modelId",
      "type": "string"
    },
    "modelName": {
      "name": "modelName",
      "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
modelId	string	false	none	none
modelName	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 14:47:42 GMT+0000 (Coordinated Universal Time) on Fri Apr 09 2021 from 5.2.0-5 (e6d396c0)