FastScore Engine API

Default

activeModelDelete


/2/active/model

Usage and SDK Samples

curl -X DELETE "https://localhost/2/active/model"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            apiInstance.activeModelDelete();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeModelDelete");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            apiInstance.activeModelDelete();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeModelDelete");
            e.printStackTrace();
        }
    }
}

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance activeModelDeleteWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.activeModelDelete(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class activeModelDeleteExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                apiInstance.activeModelDelete();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.activeModelDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $api_instance->activeModelDelete();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->activeModelDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    $api_instance->activeModelDelete();
};
if ($@) {
    warn "Exception when calling DefaultApi->activeModelDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    api_instance.active_model_delete()
except ApiException as e:
    print("Exception when calling DefaultApi->activeModelDelete: %s\n" % e)

Parameters

Responses

Status: 204 - model unload ok

Status: 400 - model unload error

Status: 404 - model not loaded


activeModelGet


/2/active/model

Usage and SDK Samples

curl -X GET "https://localhost/2/active/model"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            inline_response_200_10 result = apiInstance.activeModelGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeModelGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            inline_response_200_10 result = apiInstance.activeModelGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeModelGet");
            e.printStackTrace();
        }
    }
}

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance activeModelGetWithCompletionHandler: 
              ^(inline_response_200_10 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.activeModelGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class activeModelGetExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                inline_response_200_10 result = apiInstance.activeModelGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.activeModelGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->activeModelGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->activeModelGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->activeModelGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->activeModelGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    api_response = api_instance.active_model_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->activeModelGet: %s\n" % e)

Parameters

Responses

Status: 200 - active model info

Status: 404 - model not loaded


activeModelScale


/2/active/model/scale

Usage and SDK Samples

curl -X POST "https://localhost/2/active/model/scale"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Integer factor = 56; // Integer | jet count
        try {
            apiInstance.activeModelScale(factor);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeModelScale");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer factor = 56; // Integer | jet count
        try {
            apiInstance.activeModelScale(factor);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeModelScale");
            e.printStackTrace();
        }
    }
}
Integer *factor = 56; // jet count

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance activeModelScaleWith:factor
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var factor = 56; // {Integer} jet count


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.activeModelScale(factor, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class activeModelScaleExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var factor = 56;  // Integer | jet count

            try
            {
                apiInstance.activeModelScale(factor);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.activeModelScale: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$factor = 56; // Integer | jet count

try {
    $api_instance->activeModelScale($factor);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->activeModelScale: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $factor = WWW::SwaggerClient::Object::Integer->new(); # Integer | jet count

eval { 
    $api_instance->activeModelScale(factor => $factor);
};
if ($@) {
    warn "Exception when calling DefaultApi->activeModelScale: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
factor = 56 # Integer | jet count

try: 
    api_instance.active_model_scale(factor)
except ApiException as e:
    print("Exception when calling DefaultApi->activeModelScale: %s\n" % e)

Parameters

Body parameters
Name Description
factor *

Responses

Status: 204 - scale ok

Status: 400 - scale error


activeSchemaUnverify


/2/active/schema/verify/{sid}

Usage and SDK Samples

curl -X DELETE "https://localhost/2/active/schema/verify/{sid}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Integer sid = 56; // Integer | schema id
        try {
            apiInstance.activeSchemaUnverify(sid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeSchemaUnverify");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer sid = 56; // Integer | schema id
        try {
            apiInstance.activeSchemaUnverify(sid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeSchemaUnverify");
            e.printStackTrace();
        }
    }
}
Integer *sid = 56; // schema id

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance activeSchemaUnverifyWith:sid
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var sid = 56; // {Integer} schema id


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.activeSchemaUnverify(sid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class activeSchemaUnverifyExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var sid = 56;  // Integer | schema id

            try
            {
                apiInstance.activeSchemaUnverify(sid);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.activeSchemaUnverify: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$sid = 56; // Integer | schema id

try {
    $api_instance->activeSchemaUnverify($sid);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->activeSchemaUnverify: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $sid = 56; # Integer | schema id

eval { 
    $api_instance->activeSchemaUnverify(sid => $sid);
};
if ($@) {
    warn "Exception when calling DefaultApi->activeSchemaUnverify: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
sid = 56 # Integer | schema id

try: 
    api_instance.active_schema_unverify(sid)
except ApiException as e:
    print("Exception when calling DefaultApi->activeSchemaUnverify: %s\n" % e)

Parameters

Path parameters
Name Description
sid*
Integer
schema id
Required

Responses

Status: 204 - schema removed


activeSchemaVerify


/2/active/schema/verify

Usage and SDK Samples

curl -X POST "https://localhost/2/active/schema/verify"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Object schema = ; // Object | Avro schema
        try {
            inline_response_200_9 result = apiInstance.activeSchemaVerify(schema);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeSchemaVerify");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Object schema = ; // Object | Avro schema
        try {
            inline_response_200_9 result = apiInstance.activeSchemaVerify(schema);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeSchemaVerify");
            e.printStackTrace();
        }
    }
}
Object *schema = ; // Avro schema

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance activeSchemaVerifyWith:schema
              completionHandler: ^(inline_response_200_9 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var schema = ; // {Object} Avro schema


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.activeSchemaVerify(schema, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class activeSchemaVerifyExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var schema = new Object(); // Object | Avro schema

            try
            {
                inline_response_200_9 result = apiInstance.activeSchemaVerify(schema);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.activeSchemaVerify: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$schema = ; // Object | Avro schema

try {
    $result = $api_instance->activeSchemaVerify($schema);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->activeSchemaVerify: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $schema = WWW::SwaggerClient::Object::Object->new(); # Object | Avro schema

eval { 
    my $result = $api_instance->activeSchemaVerify(schema => $schema);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->activeSchemaVerify: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
schema =  # Object | Avro schema

try: 
    api_response = api_instance.active_schema_verify(schema)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->activeSchemaVerify: %s\n" % e)

Parameters

Body parameters
Name Description
schema *

Responses

Status: 200 - schema ok

Status: 400 - schema invalid


activeSchemaVerifyData


/2/active/schema/verify/{sid}

Usage and SDK Samples

curl -X POST "https://localhost/2/active/schema/verify/{sid}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Integer sid = 56; // Integer | schema id
        Record record = ; // Record | data record to verify
        try {
            apiInstance.activeSchemaVerifyData(sid, record);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeSchemaVerifyData");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer sid = 56; // Integer | schema id
        Record record = ; // Record | data record to verify
        try {
            apiInstance.activeSchemaVerifyData(sid, record);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeSchemaVerifyData");
            e.printStackTrace();
        }
    }
}
Integer *sid = 56; // schema id
Record *record = ; // data record to verify

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance activeSchemaVerifyDataWith:sid
    record:record
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var sid = 56; // {Integer} schema id

var record = ; // {Record} data record to verify


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.activeSchemaVerifyData(sid, record, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class activeSchemaVerifyDataExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var sid = 56;  // Integer | schema id
            var record = new Record(); // Record | data record to verify

            try
            {
                apiInstance.activeSchemaVerifyData(sid, record);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.activeSchemaVerifyData: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$sid = 56; // Integer | schema id
$record = ; // Record | data record to verify

try {
    $api_instance->activeSchemaVerifyData($sid, $record);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->activeSchemaVerifyData: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $sid = 56; # Integer | schema id
my $record = WWW::SwaggerClient::Object::Record->new(); # Record | data record to verify

eval { 
    $api_instance->activeSchemaVerifyData(sid => $sid, record => $record);
};
if ($@) {
    warn "Exception when calling DefaultApi->activeSchemaVerifyData: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
sid = 56 # Integer | schema id
record =  # Record | data record to verify

try: 
    api_instance.active_schema_verify_data(sid, record)
except ApiException as e:
    print("Exception when calling DefaultApi->activeSchemaVerifyData: %s\n" % e)

Parameters

Path parameters
Name Description
sid*
Integer
schema id
Required
Body parameters
Name Description
record *

Responses

Status: 204 - data ok

Status: 400 - data invalid


activeSensorAttach


/1/control/sensor

Usage and SDK Samples

curl -X POST "https://localhost/1/control/sensor"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Object desc = ; // Object | sensor descriptor
        try {
            inline_response_200_7 result = apiInstance.activeSensorAttach(desc);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeSensorAttach");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Object desc = ; // Object | sensor descriptor
        try {
            inline_response_200_7 result = apiInstance.activeSensorAttach(desc);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeSensorAttach");
            e.printStackTrace();
        }
    }
}
Object *desc = ; // sensor descriptor

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance activeSensorAttachWith:desc
              completionHandler: ^(inline_response_200_7 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var desc = ; // {Object} sensor descriptor


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.activeSensorAttach(desc, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class activeSensorAttachExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var desc = new Object(); // Object | sensor descriptor

            try
            {
                inline_response_200_7 result = apiInstance.activeSensorAttach(desc);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.activeSensorAttach: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$desc = ; // Object | sensor descriptor

try {
    $result = $api_instance->activeSensorAttach($desc);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->activeSensorAttach: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $desc = WWW::SwaggerClient::Object::Object->new(); # Object | sensor descriptor

eval { 
    my $result = $api_instance->activeSensorAttach(desc => $desc);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->activeSensorAttach: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
desc =  # Object | sensor descriptor

try: 
    api_response = api_instance.active_sensor_attach(desc)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->activeSensorAttach: %s\n" % e)

Parameters

Body parameters
Name Description
desc *

Responses

Status: 200 - The sensor attached successfully

Status: 400 - The sensor descriptor is invalid


activeSensorAvailable


/1/control/sensor/available

Usage and SDK Samples

curl -X GET "https://localhost/1/control/sensor/available"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            array['String'] result = apiInstance.activeSensorAvailable();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeSensorAvailable");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            array['String'] result = apiInstance.activeSensorAvailable();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeSensorAvailable");
            e.printStackTrace();
        }
    }
}

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance activeSensorAvailableWithCompletionHandler: 
              ^(array['String'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.activeSensorAvailable(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class activeSensorAvailableExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                array['String'] result = apiInstance.activeSensorAvailable();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.activeSensorAvailable: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->activeSensorAvailable();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->activeSensorAvailable: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->activeSensorAvailable();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->activeSensorAvailable: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    api_response = api_instance.active_sensor_available()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->activeSensorAvailable: %s\n" % e)

Parameters

Responses

Status: 200 - Returns the list of tapping points


activeSensorDescribe


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

Usage and SDK Samples

curl -X GET "https://localhost/1/control/sensor/{tap-id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Integer tapId = 56; // Integer | The identifier of the sensor connection
        try {
            inline_response_200_4 result = apiInstance.activeSensorDescribe(tapId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeSensorDescribe");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer tapId = 56; // Integer | The identifier of the sensor connection
        try {
            inline_response_200_4 result = apiInstance.activeSensorDescribe(tapId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeSensorDescribe");
            e.printStackTrace();
        }
    }
}
Integer *tapId = 56; // The identifier of the sensor connection

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance activeSensorDescribeWith:tapId
              completionHandler: ^(inline_response_200_4 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var tapId = 56; // {Integer} The identifier of the sensor connection


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.activeSensorDescribe(tapId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class activeSensorDescribeExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var tapId = 56;  // Integer | The identifier of the sensor connection

            try
            {
                inline_response_200_4 result = apiInstance.activeSensorDescribe(tapId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.activeSensorDescribe: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$tapId = 56; // Integer | The identifier of the sensor connection

try {
    $result = $api_instance->activeSensorDescribe($tapId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->activeSensorDescribe: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $tapId = 56; # Integer | The identifier of the sensor connection

eval { 
    my $result = $api_instance->activeSensorDescribe(tapId => $tapId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->activeSensorDescribe: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
tapId = 56 # Integer | The identifier of the sensor connection

try: 
    api_response = api_instance.active_sensor_describe(tapId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->activeSensorDescribe: %s\n" % e)

Parameters

Path parameters
Name Description
tap-id*
Integer
The identifier of the sensor connection
Required

Responses

Status: 200 - Returns the information about the sensor connection

Status: 404 - The sensor connection not found


activeSensorDetach


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

Usage and SDK Samples

curl -X DELETE "https://localhost/1/control/sensor/{tap-id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Integer tapId = 56; // Integer | The identifier of the sensor connection
        try {
            apiInstance.activeSensorDetach(tapId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeSensorDetach");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer tapId = 56; // Integer | The identifier of the sensor connection
        try {
            apiInstance.activeSensorDetach(tapId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeSensorDetach");
            e.printStackTrace();
        }
    }
}
Integer *tapId = 56; // The identifier of the sensor connection

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance activeSensorDetachWith:tapId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var tapId = 56; // {Integer} The identifier of the sensor connection


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.activeSensorDetach(tapId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class activeSensorDetachExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var tapId = 56;  // Integer | The identifier of the sensor connection

            try
            {
                apiInstance.activeSensorDetach(tapId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.activeSensorDetach: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$tapId = 56; // Integer | The identifier of the sensor connection

try {
    $api_instance->activeSensorDetach($tapId);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->activeSensorDetach: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $tapId = 56; # Integer | The identifier of the sensor connection

eval { 
    $api_instance->activeSensorDetach(tapId => $tapId);
};
if ($@) {
    warn "Exception when calling DefaultApi->activeSensorDetach: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
tapId = 56 # Integer | The identifier of the sensor connection

try: 
    api_instance.active_sensor_detach(tapId)
except ApiException as e:
    print("Exception when calling DefaultApi->activeSensorDetach: %s\n" % e)

Parameters

Path parameters
Name Description
tap-id*
Integer
The identifier of the sensor connection
Required

Responses

Status: 204 - The sensor successfully detached

Status: 404 - Sensor connection not found


activeSensorInstall


/2/active/sensor

Usage and SDK Samples

curl -X POST "https://localhost/2/active/sensor"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Desc_1 desc = ; // Desc_1 | sensor descriptor
        try {
            inline_response_200_9 result = apiInstance.activeSensorInstall(desc);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeSensorInstall");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Desc_1 desc = ; // Desc_1 | sensor descriptor
        try {
            inline_response_200_9 result = apiInstance.activeSensorInstall(desc);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeSensorInstall");
            e.printStackTrace();
        }
    }
}
Desc_1 *desc = ; // sensor descriptor

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance activeSensorInstallWith:desc
              completionHandler: ^(inline_response_200_9 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var desc = ; // {Desc_1} sensor descriptor


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.activeSensorInstall(desc, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class activeSensorInstallExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var desc = new Desc_1(); // Desc_1 | sensor descriptor

            try
            {
                inline_response_200_9 result = apiInstance.activeSensorInstall(desc);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.activeSensorInstall: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$desc = ; // Desc_1 | sensor descriptor

try {
    $result = $api_instance->activeSensorInstall($desc);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->activeSensorInstall: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $desc = WWW::SwaggerClient::Object::Desc_1->new(); # Desc_1 | sensor descriptor

eval { 
    my $result = $api_instance->activeSensorInstall(desc => $desc);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->activeSensorInstall: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
desc =  # Desc_1 | sensor descriptor

try: 
    api_response = api_instance.active_sensor_install(desc)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->activeSensorInstall: %s\n" % e)

Parameters

Body parameters
Name Description
desc *

Responses

Status: 200 - sensor install ok

Status: 400 - sensor install error


activeSensorList


/1/control/sensor

Usage and SDK Samples

curl -X GET "https://localhost/1/control/sensor"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            array[inline_response_200_6] result = apiInstance.activeSensorList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeSensorList");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            array[inline_response_200_6] result = apiInstance.activeSensorList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeSensorList");
            e.printStackTrace();
        }
    }
}

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance activeSensorListWithCompletionHandler: 
              ^(array[inline_response_200_6] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.activeSensorList(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class activeSensorListExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                array[inline_response_200_6] result = apiInstance.activeSensorList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.activeSensorList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->activeSensorList();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->activeSensorList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->activeSensorList();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->activeSensorList: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    api_response = api_instance.active_sensor_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->activeSensorList: %s\n" % e)

Parameters

Responses

Status: 200 - Returns the list of attached sensors


activeSensorList_1


/2/active/sensor

Usage and SDK Samples

curl -X GET "https://localhost/2/active/sensor"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            array[inline_response_200_8] result = apiInstance.activeSensorList_0();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeSensorList_0");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            array[inline_response_200_8] result = apiInstance.activeSensorList_0();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeSensorList_0");
            e.printStackTrace();
        }
    }
}

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance activeSensorList_1WithCompletionHandler: 
              ^(array[inline_response_200_8] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.activeSensorList_0(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class activeSensorList_0Example
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                array[inline_response_200_8] result = apiInstance.activeSensorList_0();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.activeSensorList_0: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->activeSensorList_0();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->activeSensorList_0: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->activeSensorList_0();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->activeSensorList_0: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    api_response = api_instance.active_sensor_list_0()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->activeSensorList_0: %s\n" % e)

Parameters

Responses

Status: 200 - active sensor list


activeSensorPoints


/2/active/sensor/points

Usage and SDK Samples

curl -X GET "https://localhost/2/active/sensor/points"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            array['String'] result = apiInstance.activeSensorPoints();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeSensorPoints");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            array['String'] result = apiInstance.activeSensorPoints();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeSensorPoints");
            e.printStackTrace();
        }
    }
}

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance activeSensorPointsWithCompletionHandler: 
              ^(array['String'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.activeSensorPoints(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class activeSensorPointsExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                array['String'] result = apiInstance.activeSensorPoints();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.activeSensorPoints: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->activeSensorPoints();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->activeSensorPoints: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->activeSensorPoints();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->activeSensorPoints: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    api_response = api_instance.active_sensor_points()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->activeSensorPoints: %s\n" % e)

Parameters

Responses

Status: 200 - tapping point list


activeSensorUninstall


/2/active/sensor/{tap-id}

Usage and SDK Samples

curl -X DELETE "https://localhost/2/active/sensor/{tap-id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Integer tapId = 56; // Integer | The identifier of the sensor connection
        try {
            apiInstance.activeSensorUninstall(tapId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeSensorUninstall");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer tapId = 56; // Integer | The identifier of the sensor connection
        try {
            apiInstance.activeSensorUninstall(tapId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeSensorUninstall");
            e.printStackTrace();
        }
    }
}
Integer *tapId = 56; // The identifier of the sensor connection

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance activeSensorUninstallWith:tapId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var tapId = 56; // {Integer} The identifier of the sensor connection


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.activeSensorUninstall(tapId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class activeSensorUninstallExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var tapId = 56;  // Integer | The identifier of the sensor connection

            try
            {
                apiInstance.activeSensorUninstall(tapId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.activeSensorUninstall: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$tapId = 56; // Integer | The identifier of the sensor connection

try {
    $api_instance->activeSensorUninstall($tapId);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->activeSensorUninstall: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $tapId = 56; # Integer | The identifier of the sensor connection

eval { 
    $api_instance->activeSensorUninstall(tapId => $tapId);
};
if ($@) {
    warn "Exception when calling DefaultApi->activeSensorUninstall: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
tapId = 56 # Integer | The identifier of the sensor connection

try: 
    api_instance.active_sensor_uninstall(tapId)
except ApiException as e:
    print("Exception when calling DefaultApi->activeSensorUninstall: %s\n" % e)

Parameters

Path parameters
Name Description
tap-id*
Integer
The identifier of the sensor connection
Required

Responses

Status: 204 - sensor uninstall ok

Status: 400 - sensor uninstall error

Status: 404 - sensor not found


activeStreamAttach


/2/active/stream/{slot}

Usage and SDK Samples

curl -X PUT "https://localhost/2/active/stream/{slot}?dry-run="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Desc desc = ; // Desc | The stream descriptor
        Integer slot = 56; // Integer | The stream slot
        Boolean dryRun = true; // Boolean | verificaton only
        String contentDisposition = contentDisposition_example; // String | pass stream name
        try {
            Object result = apiInstance.activeStreamAttach(desc, slot, dryRun, contentDisposition);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeStreamAttach");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Desc desc = ; // Desc | The stream descriptor
        Integer slot = 56; // Integer | The stream slot
        Boolean dryRun = true; // Boolean | verificaton only
        String contentDisposition = contentDisposition_example; // String | pass stream name
        try {
            Object result = apiInstance.activeStreamAttach(desc, slot, dryRun, contentDisposition);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeStreamAttach");
            e.printStackTrace();
        }
    }
}
Desc *desc = ; // The stream descriptor
Integer *slot = 56; // The stream slot
Boolean *dryRun = true; // verificaton only (optional)
String *contentDisposition = contentDisposition_example; // pass stream name (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance activeStreamAttachWith:desc
    slot:slot
    dryRun:dryRun
    contentDisposition:contentDisposition
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var desc = ; // {Desc} The stream descriptor

var slot = 56; // {Integer} The stream slot

var opts = { 
  'dryRun': true, // {Boolean} verificaton only
  'contentDisposition': contentDisposition_example // {String} pass stream name
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.activeStreamAttach(desc, slot, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class activeStreamAttachExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var desc = new Desc(); // Desc | The stream descriptor
            var slot = 56;  // Integer | The stream slot
            var dryRun = true;  // Boolean | verificaton only (optional) 
            var contentDisposition = contentDisposition_example;  // String | pass stream name (optional) 

            try
            {
                Object result = apiInstance.activeStreamAttach(desc, slot, dryRun, contentDisposition);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.activeStreamAttach: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$desc = ; // Desc | The stream descriptor
$slot = 56; // Integer | The stream slot
$dryRun = true; // Boolean | verificaton only
$contentDisposition = contentDisposition_example; // String | pass stream name

try {
    $result = $api_instance->activeStreamAttach($desc, $slot, $dryRun, $contentDisposition);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->activeStreamAttach: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $desc = WWW::SwaggerClient::Object::Desc->new(); # Desc | The stream descriptor
my $slot = 56; # Integer | The stream slot
my $dryRun = true; # Boolean | verificaton only
my $contentDisposition = contentDisposition_example; # String | pass stream name

eval { 
    my $result = $api_instance->activeStreamAttach(desc => $desc, slot => $slot, dryRun => $dryRun, contentDisposition => $contentDisposition);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->activeStreamAttach: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
desc =  # Desc | The stream descriptor
slot = 56 # Integer | The stream slot
dryRun = true # Boolean | verificaton only (optional)
contentDisposition = contentDisposition_example # String | pass stream name (optional)

try: 
    api_response = api_instance.active_stream_attach(desc, slot, dryRun=dryRun, contentDisposition=contentDisposition)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->activeStreamAttach: %s\n" % e)

Parameters

Path parameters
Name Description
slot*
Integer
The stream slot
Required
Header parameters
Name Description
Content-Disposition
String
pass stream name
Body parameters
Name Description
desc *
Query parameters
Name Description
dry-run
Boolean
verificaton only

Responses

Status: 200 - stream ok - dry run

Status: 204 - stream attached ok

Status: 400 - stream attach error


activeStreamDetach


/2/active/stream/{slot}

Usage and SDK Samples

curl -X DELETE "https://localhost/2/active/stream/{slot}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Integer slot = 56; // Integer | The stream slot
        try {
            apiInstance.activeStreamDetach(slot);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeStreamDetach");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer slot = 56; // Integer | The stream slot
        try {
            apiInstance.activeStreamDetach(slot);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeStreamDetach");
            e.printStackTrace();
        }
    }
}
Integer *slot = 56; // The stream slot

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance activeStreamDetachWith:slot
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var slot = 56; // {Integer} The stream slot


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.activeStreamDetach(slot, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class activeStreamDetachExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var slot = 56;  // Integer | The stream slot

            try
            {
                apiInstance.activeStreamDetach(slot);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.activeStreamDetach: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$slot = 56; // Integer | The stream slot

try {
    $api_instance->activeStreamDetach($slot);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->activeStreamDetach: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $slot = 56; # Integer | The stream slot

eval { 
    $api_instance->activeStreamDetach(slot => $slot);
};
if ($@) {
    warn "Exception when calling DefaultApi->activeStreamDetach: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
slot = 56 # Integer | The stream slot

try: 
    api_instance.active_stream_detach(slot)
except ApiException as e:
    print("Exception when calling DefaultApi->activeStreamDetach: %s\n" % e)

Parameters

Path parameters
Name Description
slot*
Integer
The stream slot
Required

Responses

Status: 204 - stream detached ok

Status: 400 - stream detach error

Status: 404 - stream not found


activeStreamList


/2/active/stream

Usage and SDK Samples

curl -X GET "https://localhost/2/active/stream"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            array[inline_response_200_12] result = apiInstance.activeStreamList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeStreamList");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            array[inline_response_200_12] result = apiInstance.activeStreamList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activeStreamList");
            e.printStackTrace();
        }
    }
}

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance activeStreamListWithCompletionHandler: 
              ^(array[inline_response_200_12] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.activeStreamList(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class activeStreamListExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                array[inline_response_200_12] result = apiInstance.activeStreamList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.activeStreamList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->activeStreamList();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->activeStreamList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->activeStreamList();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->activeStreamList: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    api_response = api_instance.active_stream_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->activeStreamList: %s\n" % e)

Parameters

Responses

Status: 200 - active stream list


enginePause


/2/engine/pause

Usage and SDK Samples

curl -X POST "https://localhost/2/engine/pause"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            apiInstance.enginePause();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#enginePause");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            apiInstance.enginePause();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#enginePause");
            e.printStackTrace();
        }
    }
}

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance enginePauseWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.enginePause(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class enginePauseExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                apiInstance.enginePause();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.enginePause: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $api_instance->enginePause();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->enginePause: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    $api_instance->enginePause();
};
if ($@) {
    warn "Exception when calling DefaultApi->enginePause: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    api_instance.engine_pause()
except ApiException as e:
    print("Exception when calling DefaultApi->enginePause: %s\n" % e)

Parameters

Responses

Status: 204 - paused ok

Status: 400 - pausing error


engineReset


/2/engine/reset

Usage and SDK Samples

curl -X POST "https://localhost/2/engine/reset"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            apiInstance.engineReset();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#engineReset");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            apiInstance.engineReset();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#engineReset");
            e.printStackTrace();
        }
    }
}

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance engineResetWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.engineReset(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class engineResetExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                apiInstance.engineReset();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.engineReset: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $api_instance->engineReset();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->engineReset: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    $api_instance->engineReset();
};
if ($@) {
    warn "Exception when calling DefaultApi->engineReset: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    api_instance.engine_reset()
except ApiException as e:
    print("Exception when calling DefaultApi->engineReset: %s\n" % e)

Parameters

Responses

Status: 204 - reset ok

Status: 400 - reset error


engineStateGet


/2/engine/state

Usage and SDK Samples

curl -X GET "https://localhost/2/engine/state"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            inline_response_200_11 result = apiInstance.engineStateGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#engineStateGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            inline_response_200_11 result = apiInstance.engineStateGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#engineStateGet");
            e.printStackTrace();
        }
    }
}

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance engineStateGetWithCompletionHandler: 
              ^(inline_response_200_11 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.engineStateGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class engineStateGetExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                inline_response_200_11 result = apiInstance.engineStateGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.engineStateGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->engineStateGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->engineStateGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->engineStateGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->engineStateGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    api_response = api_instance.engine_state_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->engineStateGet: %s\n" % e)

Parameters

Responses

Status: 200 - engine state


engineUnpause


/2/engine/unpause

Usage and SDK Samples

curl -X POST "https://localhost/2/engine/unpause"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            apiInstance.engineUnpause();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#engineUnpause");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            apiInstance.engineUnpause();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#engineUnpause");
            e.printStackTrace();
        }
    }
}

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance engineUnpauseWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.engineUnpause(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class engineUnpauseExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                apiInstance.engineUnpause();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.engineUnpause: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $api_instance->engineUnpause();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->engineUnpause: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    $api_instance->engineUnpause();
};
if ($@) {
    warn "Exception when calling DefaultApi->engineUnpause: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    api_instance.engine_unpause()
except ApiException as e:
    print("Exception when calling DefaultApi->engineUnpause: %s\n" % e)

Parameters

Responses

Status: 204 - unpaused ok

Status: 400 - unpausing error


healthGet


/1/health

Usage and SDK Samples

curl -X GET "https://localhost/1/health"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            inline_response_200_5 result = apiInstance.healthGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#healthGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            inline_response_200_5 result = apiInstance.healthGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#healthGet");
            e.printStackTrace();
        }
    }
}

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance healthGetWithCompletionHandler: 
              ^(inline_response_200_5 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.healthGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class healthGetExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                inline_response_200_5 result = apiInstance.healthGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.healthGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->healthGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->healthGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->healthGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->healthGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    api_response = api_instance.health_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->healthGet: %s\n" % e)

Parameters

Responses

Status: 200 - Indicates that the instance is healthy


inputStreamSet


/1/job/stream/in

Usage and SDK Samples

curl -X PUT "https://localhost/1/job/stream/in"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Object stream = ; // Object | The input stream descriptor
        try {
            apiInstance.inputStreamSet(stream);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#inputStreamSet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Object stream = ; // Object | The input stream descriptor
        try {
            apiInstance.inputStreamSet(stream);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#inputStreamSet");
            e.printStackTrace();
        }
    }
}
Object *stream = ; // The input stream descriptor

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance inputStreamSetWith:stream
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var stream = ; // {Object} The input stream descriptor


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.inputStreamSet(stream, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class inputStreamSetExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var stream = new Object(); // Object | The input stream descriptor

            try
            {
                apiInstance.inputStreamSet(stream);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.inputStreamSet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$stream = ; // Object | The input stream descriptor

try {
    $api_instance->inputStreamSet($stream);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->inputStreamSet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $stream = WWW::SwaggerClient::Object::Object->new(); # Object | The input stream descriptor

eval { 
    $api_instance->inputStreamSet(stream => $stream);
};
if ($@) {
    warn "Exception when calling DefaultApi->inputStreamSet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
stream =  # Object | The input stream descriptor

try: 
    api_instance.input_stream_set(stream)
except ApiException as e:
    print("Exception when calling DefaultApi->inputStreamSet: %s\n" % e)

Parameters

Body parameters
Name Description
stream *

Responses

Status: 204 - The input stream set successfully

Status: 400 - Invalid stream descriptor


jobDelete


/1/job

Usage and SDK Samples

curl -X DELETE "https://localhost/1/job"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            apiInstance.jobDelete();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#jobDelete");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            apiInstance.jobDelete();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#jobDelete");
            e.printStackTrace();
        }
    }
}

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance jobDeleteWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.jobDelete(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class jobDeleteExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                apiInstance.jobDelete();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.jobDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $api_instance->jobDelete();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->jobDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    $api_instance->jobDelete();
};
if ($@) {
    warn "Exception when calling DefaultApi->jobDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    api_instance.job_delete()
except ApiException as e:
    print("Exception when calling DefaultApi->jobDelete: %s\n" % e)

Parameters

Responses

Status: 204 - The engine stopped


jobIoInput


/1/job/input/{slot}

Usage and SDK Samples

curl -X POST "https://localhost/1/job/input/{slot}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        byte[] data = BINARY_DATA_HERE; // byte[] | Input data
        Integer slot = 56; // Integer | The stream slot
        try {
            apiInstance.jobIoInput(data, slot);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#jobIoInput");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        byte[] data = BINARY_DATA_HERE; // byte[] | Input data
        Integer slot = 56; // Integer | The stream slot
        try {
            apiInstance.jobIoInput(data, slot);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#jobIoInput");
            e.printStackTrace();
        }
    }
}
byte[] *data = BINARY_DATA_HERE; // Input data
Integer *slot = 56; // The stream slot

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance jobIoInputWith:data
    slot:slot
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var data = BINARY_DATA_HERE; // {byte[]} Input data

var slot = 56; // {Integer} The stream slot


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.jobIoInput(data, slot, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class jobIoInputExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var data = BINARY_DATA_HERE;  // byte[] | Input data
            var slot = 56;  // Integer | The stream slot

            try
            {
                apiInstance.jobIoInput(data, slot);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.jobIoInput: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$data = BINARY_DATA_HERE; // byte[] | Input data
$slot = 56; // Integer | The stream slot

try {
    $api_instance->jobIoInput($data, $slot);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->jobIoInput: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $data = WWW::SwaggerClient::Object::byte[]->new(); # byte[] | Input data
my $slot = 56; # Integer | The stream slot

eval { 
    $api_instance->jobIoInput(data => $data, slot => $slot);
};
if ($@) {
    warn "Exception when calling DefaultApi->jobIoInput: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
data = BINARY_DATA_HERE # byte[] | Input data
slot = 56 # Integer | The stream slot

try: 
    api_instance.job_io_input(data, slot)
except ApiException as e:
    print("Exception when calling DefaultApi->jobIoInput: %s\n" % e)

Parameters

Path parameters
Name Description
slot*
Integer
The stream slot
Required
Body parameters
Name Description
data *

Responses

Status: 204 - Data put to REST stream trasport

Status: 403 - REST stream transport not found


jobIoInput0


/1/job/input

Usage and SDK Samples

curl -X POST "https://localhost/1/job/input"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            apiInstance.jobIoInput0();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#jobIoInput0");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            apiInstance.jobIoInput0();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#jobIoInput0");
            e.printStackTrace();
        }
    }
}

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance jobIoInput0WithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.jobIoInput0(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class jobIoInput0Example
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                apiInstance.jobIoInput0();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.jobIoInput0: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $api_instance->jobIoInput0();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->jobIoInput0: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    $api_instance->jobIoInput0();
};
if ($@) {
    warn "Exception when calling DefaultApi->jobIoInput0: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    api_instance.job_io_input0()
except ApiException as e:
    print("Exception when calling DefaultApi->jobIoInput0: %s\n" % e)

Parameters

Responses

Status: 204 - Data put to REST at slot 0

Status: 403 - REST stream transport at slot 0 not found


jobIoOutput


/1/job/output/{slot}

Usage and SDK Samples

curl -X GET "https://localhost/1/job/output/{slot}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Integer slot = 56; // Integer | The stream slot
        try {
            byte[] result = apiInstance.jobIoOutput(slot);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#jobIoOutput");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer slot = 56; // Integer | The stream slot
        try {
            byte[] result = apiInstance.jobIoOutput(slot);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#jobIoOutput");
            e.printStackTrace();
        }
    }
}
Integer *slot = 56; // The stream slot

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance jobIoOutputWith:slot
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var slot = 56; // {Integer} The stream slot


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.jobIoOutput(slot, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class jobIoOutputExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var slot = 56;  // Integer | The stream slot

            try
            {
                byte[] result = apiInstance.jobIoOutput(slot);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.jobIoOutput: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$slot = 56; // Integer | The stream slot

try {
    $result = $api_instance->jobIoOutput($slot);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->jobIoOutput: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $slot = 56; # Integer | The stream slot

eval { 
    my $result = $api_instance->jobIoOutput(slot => $slot);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->jobIoOutput: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
slot = 56 # Integer | The stream slot

try: 
    api_response = api_instance.job_io_output(slot)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->jobIoOutput: %s\n" % e)

Parameters

Path parameters
Name Description
slot*
Integer
The stream slot
Required

Responses

Status: 200 - Retrieves a data chunk from REST stream transport

Status: 403 - REST stream transport not found


jobIoOutput1


/1/job/output

Usage and SDK Samples

curl -X GET "https://localhost/1/job/output"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            apiInstance.jobIoOutput1();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#jobIoOutput1");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            apiInstance.jobIoOutput1();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#jobIoOutput1");
            e.printStackTrace();
        }
    }
}

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance jobIoOutput1WithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.jobIoOutput1(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class jobIoOutput1Example
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                apiInstance.jobIoOutput1();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.jobIoOutput1: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $api_instance->jobIoOutput1();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->jobIoOutput1: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    $api_instance->jobIoOutput1();
};
if ($@) {
    warn "Exception when calling DefaultApi->jobIoOutput1: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    api_instance.job_io_output1()
except ApiException as e:
    print("Exception when calling DefaultApi->jobIoOutput1: %s\n" % e)

Parameters

Responses

Status: 200 - Retrieves a data chunk from REST stream at slot 1

Status: 403 - REST stream transport at slot 1 not found


jobSampleCpu


/1/job/sample/cpu

Usage and SDK Samples

curl -X POST "https://localhost/1/job/sample/cpu?duration="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Integer duration = 56; // Integer | The number of seconds to sample CPU usage for
        try {
            inline_response_200_3 result = apiInstance.jobSampleCpu(duration);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#jobSampleCpu");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer duration = 56; // Integer | The number of seconds to sample CPU usage for
        try {
            inline_response_200_3 result = apiInstance.jobSampleCpu(duration);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#jobSampleCpu");
            e.printStackTrace();
        }
    }
}
Integer *duration = 56; // The number of seconds to sample CPU usage for (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance jobSampleCpuWith:duration
              completionHandler: ^(inline_response_200_3 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var opts = { 
  'duration': 56 // {Integer} The number of seconds to sample CPU usage for
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.jobSampleCpu(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class jobSampleCpuExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var duration = 56;  // Integer | The number of seconds to sample CPU usage for (optional) 

            try
            {
                inline_response_200_3 result = apiInstance.jobSampleCpu(duration);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.jobSampleCpu: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$duration = 56; // Integer | The number of seconds to sample CPU usage for

try {
    $result = $api_instance->jobSampleCpu($duration);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->jobSampleCpu: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $duration = 56; # Integer | The number of seconds to sample CPU usage for

eval { 
    my $result = $api_instance->jobSampleCpu(duration => $duration);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->jobSampleCpu: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
duration = 56 # Integer | The number of seconds to sample CPU usage for (optional)

try: 
    api_response = api_instance.job_sample_cpu(duration=duration)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->jobSampleCpu: %s\n" % e)

Parameters

Query parameters
Name Description
duration
Integer
The number of seconds to sample CPU usage for

Responses

Status: 200 - CPU usage data collected successfully

Status: 403 - Invalid parameter


jobScale


/1/job/scale

Usage and SDK Samples

curl -X POST "https://localhost/1/job/scale?n="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Integer n = 56; // Integer | The number of jets to scale model to
        try {
            apiInstance.jobScale(n);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#jobScale");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer n = 56; // Integer | The number of jets to scale model to
        try {
            apiInstance.jobScale(n);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#jobScale");
            e.printStackTrace();
        }
    }
}
Integer *n = 56; // The number of jets to scale model to

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance jobScaleWith:n
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var n = 56; // {Integer} The number of jets to scale model to


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.jobScale(n, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class jobScaleExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var n = 56;  // Integer | The number of jets to scale model to

            try
            {
                apiInstance.jobScale(n);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.jobScale: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$n = 56; // Integer | The number of jets to scale model to

try {
    $api_instance->jobScale($n);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->jobScale: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $n = 56; # Integer | The number of jets to scale model to

eval { 
    $api_instance->jobScale(n => $n);
};
if ($@) {
    warn "Exception when calling DefaultApi->jobScale: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
n = 56 # Integer | The number of jets to scale model to

try: 
    api_instance.job_scale(n)
except ApiException as e:
    print("Exception when calling DefaultApi->jobScale: %s\n" % e)

Parameters

Query parameters
Name Description
n*
Integer
The number of jets to scale model to
Required

Responses

Status: 204 - The model scaled successfully

Status: 403 - Invalid parameter


jobStateRestore


/1/job/state

Usage and SDK Samples

curl -X PUT "https://localhost/1/job/state"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        byte[] state = BINARY_DATA_HERE; // byte[] | The model state blob
        try {
            apiInstance.jobStateRestore(state);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#jobStateRestore");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        byte[] state = BINARY_DATA_HERE; // byte[] | The model state blob
        try {
            apiInstance.jobStateRestore(state);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#jobStateRestore");
            e.printStackTrace();
        }
    }
}
byte[] *state = BINARY_DATA_HERE; // The model state blob

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance jobStateRestoreWith:state
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var state = BINARY_DATA_HERE; // {byte[]} The model state blob


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.jobStateRestore(state, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class jobStateRestoreExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var state = BINARY_DATA_HERE;  // byte[] | The model state blob

            try
            {
                apiInstance.jobStateRestore(state);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.jobStateRestore: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$state = BINARY_DATA_HERE; // byte[] | The model state blob

try {
    $api_instance->jobStateRestore($state);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->jobStateRestore: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $state = WWW::SwaggerClient::Object::byte[]->new(); # byte[] | The model state blob

eval { 
    $api_instance->jobStateRestore(state => $state);
};
if ($@) {
    warn "Exception when calling DefaultApi->jobStateRestore: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
state = BINARY_DATA_HERE # byte[] | The model state blob

try: 
    api_instance.job_state_restore(state)
except ApiException as e:
    print("Exception when calling DefaultApi->jobStateRestore: %s\n" % e)

Parameters

Body parameters
Name Description
state *

Responses

Status: 204 - The model state restored successfully

Status: 403 - The state date is corrupted (one possibility)


jobStatus


/1/job/status

Usage and SDK Samples

curl -X GET "https://localhost/1/job/status?return="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String return = return_example; // String | A comma-separated list of field names (slots, jets, snapshots, state)
        try {
            inline_response_200_2 result = apiInstance.jobStatus(return);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#jobStatus");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String return = return_example; // String | A comma-separated list of field names (slots, jets, snapshots, state)
        try {
            inline_response_200_2 result = apiInstance.jobStatus(return);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#jobStatus");
            e.printStackTrace();
        }
    }
}
String *return = return_example; // A comma-separated list of field names (slots, jets, snapshots, state) (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance jobStatusWith:return
              completionHandler: ^(inline_response_200_2 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var opts = { 
  'return': return_example // {String} A comma-separated list of field names (slots, jets, snapshots, state)
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.jobStatus(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class jobStatusExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var return = return_example;  // String | A comma-separated list of field names (slots, jets, snapshots, state) (optional) 

            try
            {
                inline_response_200_2 result = apiInstance.jobStatus(return);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.jobStatus: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$return = return_example; // String | A comma-separated list of field names (slots, jets, snapshots, state)

try {
    $result = $api_instance->jobStatus($return);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->jobStatus: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $return = return_example; # String | A comma-separated list of field names (slots, jets, snapshots, state)

eval { 
    my $result = $api_instance->jobStatus(return => $return);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->jobStatus: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
return = return_example # String | A comma-separated list of field names (slots, jets, snapshots, state) (optional)

try: 
    api_response = api_instance.job_status(return=return)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->jobStatus: %s\n" % e)

Parameters

Query parameters
Name Description
return
String
A comma-separated list of field names (slots, jets, snapshots, state)

Responses

Status: 200 - Returns the engine status information


modelLoad


/1/job/model

Usage and SDK Samples

curl -X PUT "https://localhost/1/job/model?dry-run="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String data = data_example; // String | model+attachments
        Boolean dryRun = true; // Boolean | verificaton only
        String contentType = contentType_example; // String | model MIME type
        String contentDisposition = contentDisposition_example; // String | pass model name
        try {
            inline_response_200 result = apiInstance.modelLoad(data, dryRun, contentType, contentDisposition);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#modelLoad");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String data = data_example; // String | model+attachments
        Boolean dryRun = true; // Boolean | verificaton only
        String contentType = contentType_example; // String | model MIME type
        String contentDisposition = contentDisposition_example; // String | pass model name
        try {
            inline_response_200 result = apiInstance.modelLoad(data, dryRun, contentType, contentDisposition);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#modelLoad");
            e.printStackTrace();
        }
    }
}
String *data = data_example; // model+attachments
Boolean *dryRun = true; // verificaton only (optional)
String *contentType = contentType_example; // model MIME type (optional)
String *contentDisposition = contentDisposition_example; // pass model name (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance modelLoadWith:data
    dryRun:dryRun
    contentType:contentType
    contentDisposition:contentDisposition
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var data = data_example; // {String} model+attachments

var opts = { 
  'dryRun': true, // {Boolean} verificaton only
  'contentType': contentType_example, // {String} model MIME type
  'contentDisposition': contentDisposition_example // {String} pass model name
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.modelLoad(data, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class modelLoadExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var data = data_example;  // String | model+attachments
            var dryRun = true;  // Boolean | verificaton only (optional) 
            var contentType = contentType_example;  // String | model MIME type (optional) 
            var contentDisposition = contentDisposition_example;  // String | pass model name (optional) 

            try
            {
                inline_response_200 result = apiInstance.modelLoad(data, dryRun, contentType, contentDisposition);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.modelLoad: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$data = data_example; // String | model+attachments
$dryRun = true; // Boolean | verificaton only
$contentType = contentType_example; // String | model MIME type
$contentDisposition = contentDisposition_example; // String | pass model name

try {
    $result = $api_instance->modelLoad($data, $dryRun, $contentType, $contentDisposition);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->modelLoad: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $data = WWW::SwaggerClient::Object::String->new(); # String | model+attachments
my $dryRun = true; # Boolean | verificaton only
my $contentType = contentType_example; # String | model MIME type
my $contentDisposition = contentDisposition_example; # String | pass model name

eval { 
    my $result = $api_instance->modelLoad(data => $data, dryRun => $dryRun, contentType => $contentType, contentDisposition => $contentDisposition);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->modelLoad: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
data = data_example # String | model+attachments
dryRun = true # Boolean | verificaton only (optional)
contentType = contentType_example # String | model MIME type (optional)
contentDisposition = contentDisposition_example # String | pass model name (optional)

try: 
    api_response = api_instance.model_load(data, dryRun=dryRun, contentType=contentType, contentDisposition=contentDisposition)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->modelLoad: %s\n" % e)

Parameters

Header parameters
Name Description
Content-Type
String
model MIME type
Content-Disposition
String
pass model name
Body parameters
Name Description
data *
Query parameters
Name Description
dry-run
Boolean
verificaton only

Responses

Status: 200 - The model loaded successfully (dry run)

Status: 204 - The model successfully added to the engine

Status: 400 - See the error message - a lot can go wrong


modelUnload


/1/job/model

Usage and SDK Samples

curl -X DELETE "https://localhost/1/job/model"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            apiInstance.modelUnload();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#modelUnload");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            apiInstance.modelUnload();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#modelUnload");
            e.printStackTrace();
        }
    }
}

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance modelUnloadWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.modelUnload(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class modelUnloadExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                apiInstance.modelUnload();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.modelUnload: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $api_instance->modelUnload();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->modelUnload: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    $api_instance->modelUnload();
};
if ($@) {
    warn "Exception when calling DefaultApi->modelUnload: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    api_instance.model_unload()
except ApiException as e:
    print("Exception when calling DefaultApi->modelUnload: %s\n" % e)

Parameters

Responses

Status: 204 - The model unloaded successfully


outputStreamSet


/1/job/stream/out

Usage and SDK Samples

curl -X PUT "https://localhost/1/job/stream/out"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String stream = stream_example; // String | The output stream descriptor
        try {
            apiInstance.outputStreamSet(stream);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#outputStreamSet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String stream = stream_example; // String | The output stream descriptor
        try {
            apiInstance.outputStreamSet(stream);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#outputStreamSet");
            e.printStackTrace();
        }
    }
}
String *stream = stream_example; // The output stream descriptor

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance outputStreamSetWith:stream
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var stream = stream_example; // {String} The output stream descriptor


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.outputStreamSet(stream, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class outputStreamSetExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var stream = stream_example;  // String | The output stream descriptor

            try
            {
                apiInstance.outputStreamSet(stream);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.outputStreamSet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$stream = stream_example; // String | The output stream descriptor

try {
    $api_instance->outputStreamSet($stream);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->outputStreamSet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $stream = WWW::SwaggerClient::Object::String->new(); # String | The output stream descriptor

eval { 
    $api_instance->outputStreamSet(stream => $stream);
};
if ($@) {
    warn "Exception when calling DefaultApi->outputStreamSet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
stream = stream_example # String | The output stream descriptor

try: 
    api_instance.output_stream_set(stream)
except ApiException as e:
    print("Exception when calling DefaultApi->outputStreamSet: %s\n" % e)

Parameters

Body parameters
Name Description
stream *

Responses

Status: 204 - The output stream set successfully

Status: 400 - Invalid stream descriptor


policyGet


/1/policy

Usage and SDK Samples

curl -X GET "https://localhost/1/policy"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String accept = accept_example; // String | Force Accept header value
        try {
            byte[] result = apiInstance.policyGet(accept);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#policyGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String accept = accept_example; // String | Force Accept header value
        try {
            byte[] result = apiInstance.policyGet(accept);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#policyGet");
            e.printStackTrace();
        }
    }
}
String *accept = accept_example; // Force Accept header value (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance policyGetWith:accept
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var opts = { 
  'accept': accept_example // {String} Force Accept header value
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.policyGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class policyGetExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var accept = accept_example;  // String | Force Accept header value (optional) 

            try
            {
                byte[] result = apiInstance.policyGet(accept);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.policyGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$accept = accept_example; // String | Force Accept header value

try {
    $result = $api_instance->policyGet($accept);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->policyGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $accept = accept_example; # String | Force Accept header value

eval { 
    my $result = $api_instance->policyGet(accept => $accept);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->policyGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
accept = accept_example # String | Force Accept header value (optional)

try: 
    api_response = api_instance.policy_get(accept=accept)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->policyGet: %s\n" % e)

Parameters

Header parameters
Name Description
Accept
String
Force Accept header value

Responses

Status: 200 - Returns content of the requested policy


policyPut


/1/policy

Usage and SDK Samples

curl -X PUT "https://localhost/1/policy?preinstall="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        byte[] policy = BINARY_DATA_HERE; // byte[] | The policy content
        Boolean preinstall = true; // Boolean | preinstall all libs
        String contentType = contentType_example; // String | model MIME type
        try {
            apiInstance.policyPut(policy, preinstall, contentType);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#policyPut");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        byte[] policy = BINARY_DATA_HERE; // byte[] | The policy content
        Boolean preinstall = true; // Boolean | preinstall all libs
        String contentType = contentType_example; // String | model MIME type
        try {
            apiInstance.policyPut(policy, preinstall, contentType);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#policyPut");
            e.printStackTrace();
        }
    }
}
byte[] *policy = BINARY_DATA_HERE; // The policy content
Boolean *preinstall = true; // preinstall all libs (optional)
String *contentType = contentType_example; // model MIME type (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance policyPutWith:policy
    preinstall:preinstall
    contentType:contentType
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var policy = BINARY_DATA_HERE; // {byte[]} The policy content

var opts = { 
  'preinstall': true, // {Boolean} preinstall all libs
  'contentType': contentType_example // {String} model MIME type
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.policyPut(policy, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class policyPutExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var policy = BINARY_DATA_HERE;  // byte[] | The policy content
            var preinstall = true;  // Boolean | preinstall all libs (optional) 
            var contentType = contentType_example;  // String | model MIME type (optional) 

            try
            {
                apiInstance.policyPut(policy, preinstall, contentType);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.policyPut: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$policy = BINARY_DATA_HERE; // byte[] | The policy content
$preinstall = true; // Boolean | preinstall all libs
$contentType = contentType_example; // String | model MIME type

try {
    $api_instance->policyPut($policy, $preinstall, $contentType);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->policyPut: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $policy = WWW::SwaggerClient::Object::byte[]->new(); # byte[] | The policy content
my $preinstall = true; # Boolean | preinstall all libs
my $contentType = contentType_example; # String | model MIME type

eval { 
    $api_instance->policyPut(policy => $policy, preinstall => $preinstall, contentType => $contentType);
};
if ($@) {
    warn "Exception when calling DefaultApi->policyPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
policy = BINARY_DATA_HERE # byte[] | The policy content
preinstall = true # Boolean | preinstall all libs (optional)
contentType = contentType_example # String | model MIME type (optional)

try: 
    api_instance.policy_put(policy, preinstall=preinstall, contentType=contentType)
except ApiException as e:
    print("Exception when calling DefaultApi->policyPut: %s\n" % e)

Parameters

Header parameters
Name Description
Content-Type
String
model MIME type
Body parameters
Name Description
policy *
Query parameters
Name Description
preinstall
Boolean
preinstall all libs

Responses

Status: 201 - The policy successfully updated


scoopDebugOutput


/1/debug/output

Usage and SDK Samples

curl -X GET "https://localhost/1/debug/output"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            array['String'] result = apiInstance.scoopDebugOutput();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#scoopDebugOutput");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            array['String'] result = apiInstance.scoopDebugOutput();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#scoopDebugOutput");
            e.printStackTrace();
        }
    }
}

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance scoopDebugOutputWithCompletionHandler: 
              ^(array['String'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.scoopDebugOutput(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class scoopDebugOutputExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                array['String'] result = apiInstance.scoopDebugOutput();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.scoopDebugOutput: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->scoopDebugOutput();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->scoopDebugOutput: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->scoopDebugOutput();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->scoopDebugOutput: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    api_response = api_instance.scoop_debug_output()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->scoopDebugOutput: %s\n" % e)

Parameters

Responses

Status: 200 - Retrieves the output of the output debug transport


streamAttach


/1/job/stream/{slot}

Usage and SDK Samples

curl -X PUT "https://localhost/1/job/stream/{slot}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Integer slot = 56; // Integer | The stream slot
        String stream = stream_example; // String | The input/output stream descriptor
        try {
            apiInstance.streamAttach(slot, stream);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#streamAttach");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer slot = 56; // Integer | The stream slot
        String stream = stream_example; // String | The input/output stream descriptor
        try {
            apiInstance.streamAttach(slot, stream);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#streamAttach");
            e.printStackTrace();
        }
    }
}
Integer *slot = 56; // The stream slot
String *stream = stream_example; // The input/output stream descriptor

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance streamAttachWith:slot
    stream:stream
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var slot = 56; // {Integer} The stream slot

var stream = stream_example; // {String} The input/output stream descriptor


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.streamAttach(slotstream, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class streamAttachExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var slot = 56;  // Integer | The stream slot
            var stream = stream_example;  // String | The input/output stream descriptor

            try
            {
                apiInstance.streamAttach(slot, stream);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.streamAttach: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$slot = 56; // Integer | The stream slot
$stream = stream_example; // String | The input/output stream descriptor

try {
    $api_instance->streamAttach($slot, $stream);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->streamAttach: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $slot = 56; # Integer | The stream slot
my $stream = WWW::SwaggerClient::Object::String->new(); # String | The input/output stream descriptor

eval { 
    $api_instance->streamAttach(slot => $slot, stream => $stream);
};
if ($@) {
    warn "Exception when calling DefaultApi->streamAttach: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
slot = 56 # Integer | The stream slot
stream = stream_example # String | The input/output stream descriptor

try: 
    api_instance.stream_attach(slot, stream)
except ApiException as e:
    print("Exception when calling DefaultApi->streamAttach: %s\n" % e)

Parameters

Path parameters
Name Description
slot*
Integer
The stream slot
Required
Body parameters
Name Description
stream *

Responses

Status: 204 - The input/output stream attached successfully

Status: 400 - Invalid stream descriptor


streamRate


/1/stream/rate

Usage and SDK Samples

curl -X POST "https://localhost/1/stream/rate"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String stream = stream_example; // String | The stream descriptor to measure data rate
        try {
            array[inline_response_200_1] result = apiInstance.streamRate(stream);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#streamRate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String stream = stream_example; // String | The stream descriptor to measure data rate
        try {
            array[inline_response_200_1] result = apiInstance.streamRate(stream);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#streamRate");
            e.printStackTrace();
        }
    }
}
String *stream = stream_example; // The stream descriptor to measure data rate

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance streamRateWith:stream
              completionHandler: ^(array[inline_response_200_1] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var stream = stream_example; // {String} The stream descriptor to measure data rate


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.streamRate(stream, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class streamRateExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var stream = stream_example;  // String | The stream descriptor to measure data rate

            try
            {
                array[inline_response_200_1] result = apiInstance.streamRate(stream);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.streamRate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$stream = stream_example; // String | The stream descriptor to measure data rate

try {
    $result = $api_instance->streamRate($stream);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->streamRate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $stream = WWW::SwaggerClient::Object::String->new(); # String | The stream descriptor to measure data rate

eval { 
    my $result = $api_instance->streamRate(stream => $stream);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->streamRate: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
stream = stream_example # String | The stream descriptor to measure data rate

try: 
    api_response = api_instance.stream_rate(stream)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->streamRate: %s\n" % e)

Parameters

Body parameters
Name Description
stream *

Responses

Status: 200 - The data rates measured successfully

Status: 400 - Stream descriptor invalid or stream too short


streamSample


/1/stream/sample

Usage and SDK Samples

curl -X POST "https://localhost/1/stream/sample?n="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String desc = desc_example; // String | The stream descriptor to get sample data from
        Integer n = 56; // Integer | The number of data items to read from the stream
        try {
            array['String'] result = apiInstance.streamSample(desc, n);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#streamSample");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String desc = desc_example; // String | The stream descriptor to get sample data from
        Integer n = 56; // Integer | The number of data items to read from the stream
        try {
            array['String'] result = apiInstance.streamSample(desc, n);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#streamSample");
            e.printStackTrace();
        }
    }
}
String *desc = desc_example; // The stream descriptor to get sample data from
Integer *n = 56; // The number of data items to read from the stream (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance streamSampleWith:desc
    n:n
              completionHandler: ^(array['String'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var desc = desc_example; // {String} The stream descriptor to get sample data from

var opts = { 
  'n': 56 // {Integer} The number of data items to read from the stream
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.streamSample(desc, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class streamSampleExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var desc = desc_example;  // String | The stream descriptor to get sample data from
            var n = 56;  // Integer | The number of data items to read from the stream (optional) 

            try
            {
                array['String'] result = apiInstance.streamSample(desc, n);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.streamSample: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$desc = desc_example; // String | The stream descriptor to get sample data from
$n = 56; // Integer | The number of data items to read from the stream

try {
    $result = $api_instance->streamSample($desc, $n);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->streamSample: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $desc = WWW::SwaggerClient::Object::String->new(); # String | The stream descriptor to get sample data from
my $n = 56; # Integer | The number of data items to read from the stream

eval { 
    my $result = $api_instance->streamSample(desc => $desc, n => $n);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->streamSample: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
desc = desc_example # String | The stream descriptor to get sample data from
n = 56 # Integer | The number of data items to read from the stream (optional)

try: 
    api_response = api_instance.stream_sample(desc, n=n)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->streamSample: %s\n" % e)

Parameters

Body parameters
Name Description
desc *
Query parameters
Name Description
n
Integer
The number of data items to read from the stream

Responses

Status: 200 - Sample data successfully read

Status: 400 - The stream descriptor is invalid


swaggerGet


/1/swagger

Usage and SDK Samples

curl -X GET "https://localhost/1/swagger"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String accept = accept_example; // String | Force Accept header value
        try {
            Object result = apiInstance.swaggerGet(accept);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#swaggerGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String accept = accept_example; // String | Force Accept header value
        try {
            Object result = apiInstance.swaggerGet(accept);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#swaggerGet");
            e.printStackTrace();
        }
    }
}
String *accept = accept_example; // Force Accept header value (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance swaggerGetWith:accept
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var FastScoreEngineApi = require('fast_score_engine_api');

var api = new FastScoreEngineApi.DefaultApi()

var opts = { 
  'accept': accept_example // {String} Force Accept header value
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.swaggerGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class swaggerGetExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var accept = accept_example;  // String | Force Accept header value (optional) 

            try
            {
                Object result = apiInstance.swaggerGet(accept);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.swaggerGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$accept = accept_example; // String | Force Accept header value

try {
    $result = $api_instance->swaggerGet($accept);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->swaggerGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $accept = accept_example; # String | Force Accept header value

eval { 
    my $result = $api_instance->swaggerGet(accept => $accept);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->swaggerGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
accept = accept_example # String | Force Accept header value (optional)

try: 
    api_response = api_instance.swagger_get(accept=accept)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->swaggerGet: %s\n" % e)

Parameters

Header parameters
Name Description
Accept
String
Force Accept header value

Responses

Status: 200 - The service Swagger API specification


Generated 2018-03-08T10:25:41.934-06:00