FastScore DevHub

The FastScore DevOps Hub

Welcome to the FastScore DevOps hub. You'll find comprehensive guides and documentation to help you start integrating FastScore microservices into your infrastructure and deploying analytics as quickly and repeatably as possible, as well as support if you get stuck. Let's jump right in!

You can also contact us by email: support@opendatagroup.com

Get Started
Suggest Edits

/1/health

 
get/1/health
curl --request GET \
  --url https://example.com/api/1/service/1/health
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/health' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/health")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/health");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/health"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

Indicates that the instance is healthy

releasestring
built_onstring
idstring
Suggest Edits

/1/swagger

 
gethttps://example.com/api/1/service/1/swagger
curl --request GET \
  --url https://example.com/api/1/service/1/swagger
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/swagger' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/swagger")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/swagger");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/swagger"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Headers

Accept
string

Force Accept header value

Response

The service Swagger API specification

Suggest Edits

/1/connect

 
gethttps://example.com/api/1/service/1/connect
curl --request GET \
  --url https://example.com/api/1/service/1/connect
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/connect' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/connect")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/connect");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/connect"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

name
string

Return info for the named service only

api
string

Return only services providing the named API

host
string

Return only services running on the named host

port
integer

Return only services that use this port

release
string

Return only services that run the specific release

health
string

Return only services with the given health status

return
string

A comma-separated list of fields to return

Response

The information about the FastScore fleet

The configuration not set yet

Suggest Edits

/1/config

 
puthttps://example.com/api/1/service/1/config
curl --request PUT \
  --url https://example.com/api/1/service/1/config
var request = require("request");

var options = { method: 'PUT',
  url: 'https://example.com/api/1/service/1/config' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/config")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "https://example.com/api/1/service/1/config");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/config"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Headers

Content-Type
string

configuration MIME type

Response

The configuration updated successfully

Malformed YAML

gethttps://example.com/api/1/service/1/config
curl --request GET \
  --url https://example.com/api/1/service/1/config
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/config' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/config")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/config");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/config"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

q
string

Request only the named section

Headers

Accept
string

Force Accept header value

Response

Returns the (section of the) current configuration

The configuration not set or section missing

Suggest Edits

/1/control/sensor/{tap-id}

 
deletehttps://example.com/api/1/service/1/control/sensor/tap-id
curl --request DELETE \
  --url https://example.com/api/1/service/1/control/sensor/tap-id
var request = require("request");

var options = { method: 'DELETE',
  url: 'https://example.com/api/1/service/1/control/sensor/tap-id' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/control/sensor/tap-id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://example.com/api/1/service/1/control/sensor/tap-id");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/control/sensor/tap-id"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

tap-id
integer
required

The identifier of the sensor connection

Response

The sensor successfully detached

Sensor connection not found

gethttps://example.com/api/1/service/1/control/sensor/tap-id
curl --request GET \
  --url https://example.com/api/1/service/1/control/sensor/tap-id
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/control/sensor/tap-id' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/control/sensor/tap-id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/control/sensor/tap-id");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/control/sensor/tap-id"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

tap-id
integer
required

The identifier of the sensor connection

Response

Returns the information about the sensor connection

permanentboolean
tapstring
idinteger

The sensor connection not found

Suggest Edits

/1/control/sensor/available

 
gethttps://example.com/api/1/service/1/control/sensor/available
curl --request GET \
  --url https://example.com/api/1/service/1/control/sensor/available
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/control/sensor/available' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/control/sensor/available")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/control/sensor/available");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/control/sensor/available"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

Returns the list of tapping points

Suggest Edits

/1/control/sensor

 
posthttps://example.com/api/1/service/1/control/sensor
curl --request POST \
  --url https://example.com/api/1/service/1/control/sensor
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/api/1/service/1/control/sensor' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/control/sensor")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://example.com/api/1/service/1/control/sensor");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/control/sensor"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

The sensor attached successfully

idinteger

The identifier of the sensor connection

The sensor descriptor is invalid

gethttps://example.com/api/1/service/1/control/sensor
curl --request GET \
  --url https://example.com/api/1/service/1/control/sensor
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/control/sensor' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/control/sensor")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/control/sensor");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/control/sensor"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

Returns the list of attached sensors

Suggest Edits

/1/health

 
get/1/health
curl --request GET \
  --url https://example.com/api/1/service/1/health
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/health' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/health")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/health");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/health"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

Indicates that the instance is healthy

releasestring
built_onstring
idstring
Suggest Edits

/1/swagger

 
gethttps://example.com/api/1/service/1/swagger
curl --request GET \
  --url https://example.com/api/1/service/1/swagger
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/swagger' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/swagger")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/swagger");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/swagger"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Headers

Accept
string

Force Accept header value

Response

The service Swagger API specification

 
gethttps://example.com/api/1/service/1/model
curl --request GET \
  --url https://example.com/api/1/service/1/model
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/model' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/model")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/model");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/model"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

return
string

A comma-separated list of fields to return

Response

Returns a list of model names or model info objects

Invalid parameter provided

Suggest Edits

/1/model/{model}

 
puthttps://example.com/api/1/service/1/model/model
curl --request PUT \
  --url https://example.com/api/1/service/1/model/model
var request = require("request");

var options = { method: 'PUT',
  url: 'https://example.com/api/1/service/1/model/model' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/model/model")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "https://example.com/api/1/service/1/model/model");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/model/model"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

model
string
required

model name

Headers

Content-Type
string

model MIME type

Response

The model successfully added

The model successfully updated

deletehttps://example.com/api/1/service/1/model/model
curl --request DELETE \
  --url https://example.com/api/1/service/1/model/model
var request = require("request");

var options = { method: 'DELETE',
  url: 'https://example.com/api/1/service/1/model/model' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/model/model")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://example.com/api/1/service/1/model/model");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/model/model"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

model
string
required

model name

Response

The model successfully deleted

Model not found

gethttps://example.com/api/1/service/1/model/model
curl --request GET \
  --url https://example.com/api/1/service/1/model/model
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/model/model' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/model/model")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/model/model");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/model/model"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

model
string
required

model name

Response

Returns the source code of the requested model

Model not found

Suggest Edits

/1/model/{model}/attachment/{attachment}

 
puthttps://example.com/api/1/service/1/model/model/attachment/attachment
curl --request PUT \
  --url https://example.com/api/1/service/1/model/model/attachment/attachment \
  --header 'content-type: Content-Type'
var request = require("request");

var options = { method: 'PUT',
  url: 'https://example.com/api/1/service/1/model/model/attachment/attachment',
  headers: { 'content-type': 'Content-Type' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/model/model/attachment/attachment")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'Content-Type'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "https://example.com/api/1/service/1/model/model/attachment/attachment");
xhr.setRequestHeader("content-type", "Content-Type");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/model/model/attachment/attachment"

headers = {'content-type': 'Content-Type'}

response = requests.request("PUT", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

model
string
required

model name

attachment
string
required

attachment name

Headers

Content-Type
string
required

attachment MIME type

Response

The attachment successfully added

The attachment successfully updated

headhttps://example.com/api/1/service/1/model/model/attachment/attachment
curl --request HEAD \
  --url https://example.com/api/1/service/1/model/model/attachment/attachment
var request = require("request");

var options = { method: 'HEAD',
  url: 'https://example.com/api/1/service/1/model/model/attachment/attachment' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/model/model/attachment/attachment")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Head.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("HEAD", "https://example.com/api/1/service/1/model/model/attachment/attachment");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/model/model/attachment/attachment"

response = requests.request("HEAD", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

model
string
required

model name

attachment
string
required

attachment name

Response

The Content-Length header contains the attachment size

Attachment not found

deletehttps://example.com/api/1/service/1/model/model/attachment/attachment
curl --request DELETE \
  --url https://example.com/api/1/service/1/model/model/attachment/attachment
var request = require("request");

var options = { method: 'DELETE',
  url: 'https://example.com/api/1/service/1/model/model/attachment/attachment' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/model/model/attachment/attachment")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://example.com/api/1/service/1/model/model/attachment/attachment");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/model/model/attachment/attachment"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

model
string
required

model name

attachment
string
required

attachment name

Response

The attachment successfully deleted

Attachment not found

gethttps://example.com/api/1/service/1/model/model/attachment/attachment
curl --request GET \
  --url https://example.com/api/1/service/1/model/model/attachment/attachment
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/model/model/attachment/attachment' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/model/model/attachment/attachment")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/model/model/attachment/attachment");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/model/model/attachment/attachment"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

model
string
required

model name

attachment
string
required

attachment name

Response

Returns the contents of the attachment

Attachment not found

Suggest Edits

/1/model/{model}/snapshot

 
gethttps://example.com/api/1/service/1/model/model/snapshot
curl --request GET \
  --url https://example.com/api/1/service/1/model/model/snapshot
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/model/model/snapshot' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/model/model/snapshot")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/model/model/snapshot");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/model/model/snapshot"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

model
string
required

model name

Query Params

count
integer

The maximum number of items to return

date-range
string

The range of snapshot dates, e.g. 2017-04-11--2017-04-13

Response

Returns a list of snapshots of the given model

Model not found

Suggest Edits

/1/model/{model}/snapshot/{snap-id-prefix}

 
puthttps://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix
curl --request PUT \
  --url https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix
var request = require("request");

var options = { method: 'PUT',
  url: 'https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

model
string
required

model name

snap-id-prefix
string
required

The (prefix of the id ) of the snapshot

Response

The snapshot successfully added

The snapshot already exists (one possibility)

deletehttps://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix
curl --request DELETE \
  --url https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix
var request = require("request");

var options = { method: 'DELETE',
  url: 'https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

model
string
required

model name

snap-id-prefix
string
required

The (prefix of the id ) of the snapshot

Response

The snapshot successfully deleted

The id prefix is ambiguous

Snapshot not found

gethttps://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix
curl --request GET \
  --url https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

model
string
required

model name

snap-id-prefix
string
required

The (prefix of the id ) of the snapshot

Response

Returns the snapshot metadata and its contents

The id prefix is ambiguous

Model not found

Snapshot not found

Suggest Edits

/1/model/{model}/snapshot/{snap-id-prefix}/contents

 
gethttps://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix/contents
curl --request GET \
  --url https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix/contents
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix/contents' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix/contents")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix/contents");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix/contents"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

model
string
required

model name

snap-id-prefix
string
required

The (prefix of the id ) of the snapshot

Response

Returns the snapshot contents

The id prefix is ambiguous

Snapshot not found

Suggest Edits

/1/model/{model}/snapshot/{snap-id-prefix}/metadata

 
gethttps://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix/metadata
curl --request GET \
  --url https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix/metadata
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix/metadata' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix/metadata")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix/metadata");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/model/model/snapshot/snap-id-prefix/metadata"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

model
string
required

model name

snap-id-prefix
string
required

The (prefix of the id ) of the snapshot

Response

Returns the snapshot metadata

The id prefix is ambiguous

Snapshot not found

Suggest Edits

/1/model/{model}/attachment

 
gethttps://example.com/api/1/service/1/model/model/attachment
curl --request GET \
  --url https://example.com/api/1/service/1/model/model/attachment
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/model/model/attachment' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/model/model/attachment")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/model/model/attachment");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/model/model/attachment"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

model
string
required

model name

Response

Returns a list of attachments of the given model

Model not found

Suggest Edits

/1/stream

 
gethttps://example.com/api/1/service/1/stream
curl --request GET \
  --url https://example.com/api/1/service/1/stream
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/stream' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/stream")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/stream");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/stream"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

Returns the list of stream descriptors

Suggest Edits

/1/stream/{stream}

 
puthttps://example.com/api/1/service/1/stream/stream
curl --request PUT \
  --url https://example.com/api/1/service/1/stream/stream
var request = require("request");

var options = { method: 'PUT',
  url: 'https://example.com/api/1/service/1/stream/stream' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/stream/stream")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "https://example.com/api/1/service/1/stream/stream");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/stream/stream"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

stream
string
required

The name of the stream

Response

The stream successfully added

The stream successfully updated

deletehttps://example.com/api/1/service/1/stream/stream
curl --request DELETE \
  --url https://example.com/api/1/service/1/stream/stream
var request = require("request");

var options = { method: 'DELETE',
  url: 'https://example.com/api/1/service/1/stream/stream' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/stream/stream")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://example.com/api/1/service/1/stream/stream");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/stream/stream"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

stream
string
required

The name of the stream

Response

The stream successfully deleted

Stream not found

gethttps://example.com/api/1/service/1/stream/stream
curl --request GET \
  --url https://example.com/api/1/service/1/stream/stream
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/stream/stream' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/stream/stream")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/stream/stream");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/stream/stream"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

stream
string
required

The name of the stream

Response

Returns the stream descriptor

Stream not found

Suggest Edits

/1/schema

 
gethttps://example.com/api/1/service/1/schema
curl --request GET \
  --url https://example.com/api/1/service/1/schema
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/schema' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/schema")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/schema");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/schema"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

Returns the list of registered schemas

Suggest Edits

/1/schema/{schema}

 
puthttps://example.com/api/1/service/1/schema/schema
curl --request PUT \
  --url https://example.com/api/1/service/1/schema/schema
var request = require("request");

var options = { method: 'PUT',
  url: 'https://example.com/api/1/service/1/schema/schema' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/schema/schema")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "https://example.com/api/1/service/1/schema/schema");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/schema/schema"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

schema
string
required

The name of the schema

Response

The schema successfully added

The schema successfully updated

deletehttps://example.com/api/1/service/1/schema/schema
curl --request DELETE \
  --url https://example.com/api/1/service/1/schema/schema
var request = require("request");

var options = { method: 'DELETE',
  url: 'https://example.com/api/1/service/1/schema/schema' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/schema/schema")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://example.com/api/1/service/1/schema/schema");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/schema/schema"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

schema
string
required

The name of the schema

Response

The schema successfully deleted

Schema not found

gethttps://example.com/api/1/service/1/schema/schema
curl --request GET \
  --url https://example.com/api/1/service/1/schema/schema
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/schema/schema' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/schema/schema")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/schema/schema");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/schema/schema"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

schema
string
required

The name of the schema

Response

Returns the schema contents

Schema not found

Suggest Edits

/1/sensor

 
gethttps://example.com/api/1/service/1/sensor
curl --request GET \
  --url https://example.com/api/1/service/1/sensor
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/sensor' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/sensor")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/sensor");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/sensor"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

Returns the list of sensor descriptors

Suggest Edits

/1/sensor/{sensor}

 
puthttps://example.com/api/1/service/1/sensor/sensor
curl --request PUT \
  --url https://example.com/api/1/service/1/sensor/sensor
var request = require("request");

var options = { method: 'PUT',
  url: 'https://example.com/api/1/service/1/sensor/sensor' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/sensor/sensor")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "https://example.com/api/1/service/1/sensor/sensor");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/sensor/sensor"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

sensor
string
required

The name of the sensor

Response

The sensor successfully added

The sensor successfully updated

deletehttps://example.com/api/1/service/1/sensor/sensor
curl --request DELETE \
  --url https://example.com/api/1/service/1/sensor/sensor
var request = require("request");

var options = { method: 'DELETE',
  url: 'https://example.com/api/1/service/1/sensor/sensor' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/sensor/sensor")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://example.com/api/1/service/1/sensor/sensor");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/sensor/sensor"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

sensor
string
required

The name of the sensor

Response

The sensor successfully deleted

Sensor not found

gethttps://example.com/api/1/service/1/sensor/sensor
curl --request GET \
  --url https://example.com/api/1/service/1/sensor/sensor
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/sensor/sensor' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/sensor/sensor")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/sensor/sensor");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/sensor/sensor"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

sensor
string
required

The name of the sensor

Response

Returns the sensor descriptor

Sensor not found

Suggest Edits

/1/control/sensor

 
posthttps://example.com/api/1/service/1/control/sensor
curl --request POST \
  --url https://example.com/api/1/service/1/control/sensor
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/api/1/service/1/control/sensor' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/control/sensor")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://example.com/api/1/service/1/control/sensor");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/control/sensor"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

The sensor attached successfully

idinteger

The identifier of the sensor connection

The sensor descriptor is invalid

gethttps://example.com/api/1/service/1/control/sensor
curl --request GET \
  --url https://example.com/api/1/service/1/control/sensor
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/control/sensor' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/control/sensor")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/control/sensor");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/control/sensor"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

Returns the list of attached sensors

Suggest Edits

/1/control/sensor/{tap-id}

 
deletehttps://example.com/api/1/service/1/control/sensor/tap-id
curl --request DELETE \
  --url https://example.com/api/1/service/1/control/sensor/tap-id
var request = require("request");

var options = { method: 'DELETE',
  url: 'https://example.com/api/1/service/1/control/sensor/tap-id' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/control/sensor/tap-id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://example.com/api/1/service/1/control/sensor/tap-id");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/control/sensor/tap-id"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

tap-id
integer
required

The identifier of the sensor connection

Response

The sensor successfully detached

Sensor connection not found

gethttps://example.com/api/1/service/1/control/sensor/tap-id
curl --request GET \
  --url https://example.com/api/1/service/1/control/sensor/tap-id
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/control/sensor/tap-id' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/control/sensor/tap-id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/control/sensor/tap-id");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/control/sensor/tap-id"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

tap-id
integer
required

The identifier of the sensor connection

Response

Returns the information about the sensor connection

permanentboolean
tapstring
idinteger

The sensor connection not found

Suggest Edits

/1/control/sensor/available

 
gethttps://example.com/api/1/service/1/control/sensor/available
curl --request GET \
  --url https://example.com/api/1/service/1/control/sensor/available
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/control/sensor/available' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/control/sensor/available")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/control/sensor/available");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/control/sensor/available"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

Returns the list of tapping points

Suggest Edits

/1/health

 
get/1/health
curl --request GET \
  --url https://example.com/api/1/service/1/health
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/health' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/health")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/health");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/health"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

Indicates that the instance is healthy

releasestring
built_onstring
idstring
Suggest Edits

/1/swagger

 
gethttps://example.com/api/1/service/1/swagger
curl --request GET \
  --url https://example.com/api/1/service/1/swagger
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/swagger' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/swagger")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/swagger");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/swagger"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Headers

Accept
string

Force Accept header value

Response

The service Swagger API specification

Suggest Edits

/1/job/model

 
puthttps://example.com/api/1/service/1/job/model
curl --request PUT \
  --url https://example.com/api/1/service/1/job/model
var request = require("request");

var options = { method: 'PUT',
  url: 'https://example.com/api/1/service/1/job/model' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/job/model")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "https://example.com/api/1/service/1/job/model");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/job/model"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

dry-run
boolean

verificaton only

Headers

Content-Type
string

model MIME type

Content-Disposition
string

pass model name

Response

The model loaded successfully (dry run)

slotsarray
install_libsarray
warn_libsarray
snapshotsstring
attach_libsarray

The model successfully added to the engine

See the error message - a lot can go wrong

deletehttps://example.com/api/1/service/1/job/model
curl --request DELETE \
  --url https://example.com/api/1/service/1/job/model
var request = require("request");

var options = { method: 'DELETE',
  url: 'https://example.com/api/1/service/1/job/model' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/job/model")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://example.com/api/1/service/1/job/model");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/job/model"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

The model unloaded successfully

Suggest Edits

/1/job/stream/{slot}

 
puthttps://example.com/api/1/service/1/job/stream/slot
curl --request PUT \
  --url https://example.com/api/1/service/1/job/stream/slot
var request = require("request");

var options = { method: 'PUT',
  url: 'https://example.com/api/1/service/1/job/stream/slot' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/job/stream/slot")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "https://example.com/api/1/service/1/job/stream/slot");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/job/stream/slot"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

slot
string
required

The stream slot

Response

The input/output stream attached successfully

Invalid stream descriptor

Suggest Edits

/1/job/status

 
gethttps://example.com/api/1/service/1/job/status
curl --request GET \
  --url https://example.com/api/1/service/1/job/status
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/job/status' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/job/status")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/job/status");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/job/status"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

return
string

A comma-separated list of field names (slots, jets, snapshots, state)

Response

Returns the engine status information

jetsarray
modelobject
model.sourcestring
model.typestring
model.namestring
model.attachmentsarray
slotsarray
snapshotsstring
statestring
Suggest Edits

/1/job/input

 
posthttps://example.com/api/1/service/1/job/input
curl --request POST \
  --url https://example.com/api/1/service/1/job/input
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/api/1/service/1/job/input' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/job/input")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://example.com/api/1/service/1/job/input");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/job/input"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

Data put to REST at slot 0

REST stream transport at slot 0 not found

Suggest Edits

/1/job/input/{slot}

 
posthttps://example.com/api/1/service/1/job/input/slot
curl --request POST \
  --url https://example.com/api/1/service/1/job/input/slot
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/api/1/service/1/job/input/slot' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/job/input/slot")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://example.com/api/1/service/1/job/input/slot");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/job/input/slot"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

slot
string
required

The stream slot

Response

Data put to REST stream trasport

REST stream transport not found

Suggest Edits

/1/job/output

 
gethttps://example.com/api/1/service/1/job/output
curl --request GET \
  --url https://example.com/api/1/service/1/job/output
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/job/output' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/job/output")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/job/output");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/job/output"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

Retrieves a data chunk from REST stream at slot 1

REST stream transport at slot 1 not found

Suggest Edits

/1/job/output/{slot}

 
gethttps://example.com/api/1/service/1/job/output/slot
curl --request GET \
  --url https://example.com/api/1/service/1/job/output/slot
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/job/output/slot' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/job/output/slot")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/job/output/slot");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/job/output/slot"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

slot
string
required

The stream slot

Response

Retrieves a data chunk from REST stream transport

REST stream transport not found

Suggest Edits

/1/stream/sample

 
posthttps://example.com/api/1/service/1/stream/sample
curl --request POST \
  --url https://example.com/api/1/service/1/stream/sample
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/api/1/service/1/stream/sample' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/stream/sample")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://example.com/api/1/service/1/stream/sample");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/stream/sample"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

n
integer

The number of data items to read from the stream

Response

Sample data successfully read

The stream descriptor is invalid

Suggest Edits

/1/stream/rate

 
posthttps://example.com/api/1/service/1/stream/rate
curl --request POST \
  --url https://example.com/api/1/service/1/stream/rate
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/api/1/service/1/stream/rate' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/stream/rate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://example.com/api/1/service/1/stream/rate");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/stream/rate"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

The data rates measured successfully

Stream descriptor invalid or stream too short

Suggest Edits

/1/policy

 
puthttps://example.com/api/1/service/1/policy
curl --request PUT \
  --url https://example.com/api/1/service/1/policy
var request = require("request");

var options = { method: 'PUT',
  url: 'https://example.com/api/1/service/1/policy' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/policy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "https://example.com/api/1/service/1/policy");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/policy"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

preinstall
boolean

preinstall all libs

Headers

Content-Type
string

model MIME type

Response

The policy successfully updated

gethttps://example.com/api/1/service/1/policy
curl --request GET \
  --url https://example.com/api/1/service/1/policy
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/policy' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/policy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/policy");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/policy"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Headers

Accept
string

Force Accept header value

Response

Returns content of the requested policy

deletehttps://example.com/api/1/service/1/job
curl --request DELETE \
  --url https://example.com/api/1/service/1/job
var request = require("request");

var options = { method: 'DELETE',
  url: 'https://example.com/api/1/service/1/job' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/job")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://example.com/api/1/service/1/job");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/job"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

The engine stopped

Suggest Edits

/1/job/scale

 
posthttps://example.com/api/1/service/1/job/scale
curl --request POST \
  --url 'https://example.com/api/1/service/1/job/scale?n=n'
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/api/1/service/1/job/scale',
  qs: { n: 'n' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/job/scale?n=n")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://example.com/api/1/service/1/job/scale?n=n");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/job/scale"

querystring = {"n":"n"}

response = requests.request("POST", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

n
integer
required

The number of jets to scale model to

Response

The model scaled successfully

Invalid parameter

Suggest Edits

/1/job/state

 
puthttps://example.com/api/1/service/1/job/state
curl --request PUT \
  --url https://example.com/api/1/service/1/job/state
var request = require("request");

var options = { method: 'PUT',
  url: 'https://example.com/api/1/service/1/job/state' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/job/state")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "https://example.com/api/1/service/1/job/state");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/job/state"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

The model state restored successfully

The state date is corrupted (one possibility)

Suggest Edits

/1/control/sensor

 
posthttps://example.com/api/1/service/1/control/sensor
curl --request POST \
  --url https://example.com/api/1/service/1/control/sensor
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/api/1/service/1/control/sensor' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/control/sensor")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://example.com/api/1/service/1/control/sensor");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/control/sensor"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

The sensor attached successfully

idinteger

The identifier of the sensor connection

The sensor descriptor is invalid

gethttps://example.com/api/1/service/1/control/sensor
curl --request GET \
  --url https://example.com/api/1/service/1/control/sensor
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/control/sensor' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/control/sensor")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/control/sensor");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/control/sensor"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

Returns the list of attached sensors

Suggest Edits

/1/control/sensor/{tap-id}

 
deletehttps://example.com/api/1/service/1/control/sensor/tap-id
curl --request DELETE \
  --url https://example.com/api/1/service/1/control/sensor/tap-id
var request = require("request");

var options = { method: 'DELETE',
  url: 'https://example.com/api/1/service/1/control/sensor/tap-id' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/control/sensor/tap-id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://example.com/api/1/service/1/control/sensor/tap-id");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/control/sensor/tap-id"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

tap-id
integer
required

The identifier of the sensor connection

Response

The sensor successfully detached

Sensor connection not found

gethttps://example.com/api/1/service/1/control/sensor/tap-id
curl --request GET \
  --url https://example.com/api/1/service/1/control/sensor/tap-id
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/control/sensor/tap-id' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/control/sensor/tap-id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/control/sensor/tap-id");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/control/sensor/tap-id"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

tap-id
integer
required

The identifier of the sensor connection

Response

Returns the information about the sensor connection

permanentboolean
tapstring
idinteger

The sensor connection not found

Suggest Edits

/1/control/sensor/available

 
gethttps://example.com/api/1/service/1/control/sensor/available
curl --request GET \
  --url https://example.com/api/1/service/1/control/sensor/available
var request = require("request");

var options = { method: 'GET',
  url: 'https://example.com/api/1/service/1/control/sensor/available' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/api/1/service/1/control/sensor/available")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://example.com/api/1/service/1/control/sensor/available");

xhr.send(data);
import requests

url = "https://example.com/api/1/service/1/control/sensor/available"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

Returns the list of tapping points