import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DataFormatsApi;

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

public class DataFormatsApiExample {

    public static void main(String[] args) {
        
        DataFormatsApi apiInstance = new DataFormatsApi();
        String datasetUuid = datasetUuid_example; // String | dataset uuid or name
        String dataFormat = dataFormat_example; // String | data format
        try {
            inline_response_200 result = apiInstance.deleteDatasetFormat(datasetUuid, dataFormat);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatsApi#deleteDatasetFormat");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataFormatsApi;

public class DataFormatsApiExample {

    public static void main(String[] args) {
        DataFormatsApi apiInstance = new DataFormatsApi();
        String datasetUuid = datasetUuid_example; // String | dataset uuid or name
        String dataFormat = dataFormat_example; // String | data format
        try {
            inline_response_200 result = apiInstance.deleteDatasetFormat(datasetUuid, dataFormat);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatsApi#deleteDatasetFormat");
            e.printStackTrace();
        }
    }
}

String *datasetUuid = datasetUuid_example; // dataset uuid or name
String *dataFormat = dataFormat_example; // data format

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

// get info for a specific dataset format
[apiInstance deleteDatasetFormatWith:datasetUuid
    dataFormat:dataFormat
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DataFormatsApi()
var datasetUuid = datasetUuid_example; // {{String}} dataset uuid or name
var dataFormat = dataFormat_example; // {{String}} data format

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteDatasetFormat(datasetUuid, dataFormat, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteDatasetFormatExample
    {
        public void main()
        {

            var apiInstance = new DataFormatsApi();
            var datasetUuid = datasetUuid_example;  // String | dataset uuid or name
            var dataFormat = dataFormat_example;  // String | data format

            try
            {
                // get info for a specific dataset format
                inline_response_200 result = apiInstance.deleteDatasetFormat(datasetUuid, dataFormat);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataFormatsApi.deleteDatasetFormat: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDataFormatsApi();
$datasetUuid = datasetUuid_example; // String | dataset uuid or name
$dataFormat = dataFormat_example; // String | data format

try {
    $result = $api_instance->deleteDatasetFormat($datasetUuid, $dataFormat);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DataFormatsApi->deleteDatasetFormat: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DataFormatsApi;

my $api_instance = WWW::SwaggerClient::DataFormatsApi->new();
my $datasetUuid = datasetUuid_example; # String | dataset uuid or name
my $dataFormat = dataFormat_example; # String | data format

eval { 
    my $result = $api_instance->deleteDatasetFormat(datasetUuid => $datasetUuid, dataFormat => $dataFormat);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataFormatsApi->deleteDatasetFormat: $@\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.DataFormatsApi()
datasetUuid = datasetUuid_example # String | dataset uuid or name
dataFormat = dataFormat_example # String | data format

try: 
    # get info for a specific dataset format
    api_response = api_instance.delete_dataset_format(datasetUuid, dataFormat)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataFormatsApi->deleteDatasetFormat: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DataFormatsApi;

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

public class DataFormatsApiExample {

    public static void main(String[] args) {
        
        DataFormatsApi apiInstance = new DataFormatsApi();
        String datasetUuid = datasetUuid_example; // String | dataset uuid or name
        String dataFormat = dataFormat_example; // String | data format
        try {
            Format result = apiInstance.getDatasetFormat(datasetUuid, dataFormat);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatsApi#getDatasetFormat");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataFormatsApi;

public class DataFormatsApiExample {

    public static void main(String[] args) {
        DataFormatsApi apiInstance = new DataFormatsApi();
        String datasetUuid = datasetUuid_example; // String | dataset uuid or name
        String dataFormat = dataFormat_example; // String | data format
        try {
            Format result = apiInstance.getDatasetFormat(datasetUuid, dataFormat);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatsApi#getDatasetFormat");
            e.printStackTrace();
        }
    }
}

String *datasetUuid = datasetUuid_example; // dataset uuid or name
String *dataFormat = dataFormat_example; // data format

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

// get info for a specific dataset format
[apiInstance getDatasetFormatWith:datasetUuid
    dataFormat:dataFormat
              completionHandler: ^(Format output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DataFormatsApi()
var datasetUuid = datasetUuid_example; // {{String}} dataset uuid or name
var dataFormat = dataFormat_example; // {{String}} data format

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDatasetFormat(datasetUuid, dataFormat, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getDatasetFormatExample
    {
        public void main()
        {

            var apiInstance = new DataFormatsApi();
            var datasetUuid = datasetUuid_example;  // String | dataset uuid or name
            var dataFormat = dataFormat_example;  // String | data format

            try
            {
                // get info for a specific dataset format
                Format result = apiInstance.getDatasetFormat(datasetUuid, dataFormat);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataFormatsApi.getDatasetFormat: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDataFormatsApi();
$datasetUuid = datasetUuid_example; // String | dataset uuid or name
$dataFormat = dataFormat_example; // String | data format

try {
    $result = $api_instance->getDatasetFormat($datasetUuid, $dataFormat);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DataFormatsApi->getDatasetFormat: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DataFormatsApi;

my $api_instance = WWW::SwaggerClient::DataFormatsApi->new();
my $datasetUuid = datasetUuid_example; # String | dataset uuid or name
my $dataFormat = dataFormat_example; # String | data format

eval { 
    my $result = $api_instance->getDatasetFormat(datasetUuid => $datasetUuid, dataFormat => $dataFormat);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataFormatsApi->getDatasetFormat: $@\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.DataFormatsApi()
datasetUuid = datasetUuid_example # String | dataset uuid or name
dataFormat = dataFormat_example # String | data format

try: 
    # get info for a specific dataset format
    api_response = api_instance.get_dataset_format(datasetUuid, dataFormat)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataFormatsApi->getDatasetFormat: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DataFormatsApi;

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

public class DataFormatsApiExample {

    public static void main(String[] args) {
        
        DataFormatsApi apiInstance = new DataFormatsApi();
        String datasetUuid = datasetUuid_example; // String | dataset uuid or name
        try {
            array[Format] result = apiInstance.listDatasetFormats(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatsApi#listDatasetFormats");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataFormatsApi;

public class DataFormatsApiExample {

    public static void main(String[] args) {
        DataFormatsApi apiInstance = new DataFormatsApi();
        String datasetUuid = datasetUuid_example; // String | dataset uuid or name
        try {
            array[Format] result = apiInstance.listDatasetFormats(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatsApi#listDatasetFormats");
            e.printStackTrace();
        }
    }
}

String *datasetUuid = datasetUuid_example; // dataset uuid or name

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

// List dataset formats
[apiInstance listDatasetFormatsWith:datasetUuid
              completionHandler: ^(array[Format] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DataFormatsApi()
var datasetUuid = datasetUuid_example; // {{String}} dataset uuid or name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listDatasetFormats(datasetUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listDatasetFormatsExample
    {
        public void main()
        {

            var apiInstance = new DataFormatsApi();
            var datasetUuid = datasetUuid_example;  // String | dataset uuid or name

            try
            {
                // List dataset formats
                array[Format] result = apiInstance.listDatasetFormats(datasetUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataFormatsApi.listDatasetFormats: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDataFormatsApi();
$datasetUuid = datasetUuid_example; // String | dataset uuid or name

try {
    $result = $api_instance->listDatasetFormats($datasetUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DataFormatsApi->listDatasetFormats: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DataFormatsApi;

my $api_instance = WWW::SwaggerClient::DataFormatsApi->new();
my $datasetUuid = datasetUuid_example; # String | dataset uuid or name

eval { 
    my $result = $api_instance->listDatasetFormats(datasetUuid => $datasetUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataFormatsApi->listDatasetFormats: $@\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.DataFormatsApi()
datasetUuid = datasetUuid_example # String | dataset uuid or name

try: 
    # List dataset formats
    api_response = api_instance.list_dataset_formats(datasetUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataFormatsApi->listDatasetFormats: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DatasetApi;

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

public class DatasetApiExample {

    public static void main(String[] args) {
        
        DatasetApi apiInstance = new DatasetApi();
        Dataset body = ; // Dataset | Dataset object that needs to be added.
        try {
            Dataset result = apiInstance.addDataset(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#addDataset");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DatasetApi;

public class DatasetApiExample {

    public static void main(String[] args) {
        DatasetApi apiInstance = new DatasetApi();
        Dataset body = ; // Dataset | Dataset object that needs to be added.
        try {
            Dataset result = apiInstance.addDataset(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#addDataset");
            e.printStackTrace();
        }
    }
}

Dataset *body = ; // Dataset object that needs to be added.

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

// Add a dataset
[apiInstance addDatasetWith:body
              completionHandler: ^(Dataset output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DatasetApi()
var body = ; // {{Dataset}} Dataset object that needs to be added.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addDataset(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addDatasetExample
    {
        public void main()
        {

            var apiInstance = new DatasetApi();
            var body = new Dataset(); // Dataset | Dataset object that needs to be added.

            try
            {
                // Add a dataset
                Dataset result = apiInstance.addDataset(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatasetApi.addDataset: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDatasetApi();
$body = ; // Dataset | Dataset object that needs to be added.

try {
    $result = $api_instance->addDataset($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatasetApi->addDataset: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatasetApi;

my $api_instance = WWW::SwaggerClient::DatasetApi->new();
my $body = WWW::SwaggerClient::Object::Dataset->new(); # Dataset | Dataset object that needs to be added.

eval { 
    my $result = $api_instance->addDataset(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatasetApi->addDataset: $@\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.DatasetApi()
body =  # Dataset | Dataset object that needs to be added.

try: 
    # Add a dataset
    api_response = api_instance.add_dataset(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatasetApi->addDataset: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DatasetApi;

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

public class DatasetApiExample {

    public static void main(String[] args) {
        
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        array[byte[]] filename = ; // array[byte[]] | 
        try {
            Dataset result = apiInstance.addFilesToDataset(datasetUuid, filename);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#addFilesToDataset");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DatasetApi;

public class DatasetApiExample {

    public static void main(String[] args) {
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        array[byte[]] filename = ; // array[byte[]] | 
        try {
            Dataset result = apiInstance.addFilesToDataset(datasetUuid, filename);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#addFilesToDataset");
            e.printStackTrace();
        }
    }
}

UUID *datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 
array[byte[]] *filename = ; //  (optional)

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

// Add files to dataset
[apiInstance addFilesToDatasetWith:datasetUuid
    filename:filename
              completionHandler: ^(Dataset output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DatasetApi()
var datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addFilesToDataset(datasetUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addFilesToDatasetExample
    {
        public void main()
        {

            var apiInstance = new DatasetApi();
            var datasetUuid = new UUID(); // UUID | 
            var filename = new array[byte[]](); // array[byte[]] |  (optional) 

            try
            {
                // Add files to dataset
                Dataset result = apiInstance.addFilesToDataset(datasetUuid, filename);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatasetApi.addFilesToDataset: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDatasetApi();
$datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$filename = ; // array[byte[]] | 

try {
    $result = $api_instance->addFilesToDataset($datasetUuid, $filename);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatasetApi->addFilesToDataset: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatasetApi;

my $api_instance = WWW::SwaggerClient::DatasetApi->new();
my $datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $filename = []; # array[byte[]] | 

eval { 
    my $result = $api_instance->addFilesToDataset(datasetUuid => $datasetUuid, filename => $filename);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatasetApi->addFilesToDataset: $@\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.DatasetApi()
datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 
filename =  # array[byte[]] |  (optional)

try: 
    # Add files to dataset
    api_response = api_instance.add_files_to_dataset(datasetUuid, filename=filename)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatasetApi->addFilesToDataset: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DatasetApi;

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

public class DatasetApiExample {

    public static void main(String[] args) {
        
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Conversion result = apiInstance.convertDataset(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#convertDataset");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DatasetApi;

public class DatasetApiExample {

    public static void main(String[] args) {
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Conversion result = apiInstance.convertDataset(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#convertDataset");
            e.printStackTrace();
        }
    }
}

UUID *datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// Convert a dataset
[apiInstance convertDatasetWith:datasetUuid
              completionHandler: ^(Conversion output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DatasetApi()
var datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.convertDataset(datasetUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class convertDatasetExample
    {
        public void main()
        {

            var apiInstance = new DatasetApi();
            var datasetUuid = new UUID(); // UUID | 

            try
            {
                // Convert a dataset
                Conversion result = apiInstance.convertDataset(datasetUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatasetApi.convertDataset: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDatasetApi();
$datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->convertDataset($datasetUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatasetApi->convertDataset: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatasetApi;

my $api_instance = WWW::SwaggerClient::DatasetApi->new();
my $datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->convertDataset(datasetUuid => $datasetUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatasetApi->convertDataset: $@\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.DatasetApi()
datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # Convert a dataset
    api_response = api_instance.convert_dataset(datasetUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatasetApi->convertDataset: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DatasetApi;

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

public class DatasetApiExample {

    public static void main(String[] args) {
        
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            inline_response_200 result = apiInstance.deleteDataset(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#deleteDataset");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DatasetApi;

public class DatasetApiExample {

    public static void main(String[] args) {
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            inline_response_200 result = apiInstance.deleteDataset(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#deleteDataset");
            e.printStackTrace();
        }
    }
}

UUID *datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// Delete dataset
[apiInstance deleteDatasetWith:datasetUuid
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DatasetApi()
var datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteDataset(datasetUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteDatasetExample
    {
        public void main()
        {

            var apiInstance = new DatasetApi();
            var datasetUuid = new UUID(); // UUID | 

            try
            {
                // Delete dataset
                inline_response_200 result = apiInstance.deleteDataset(datasetUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatasetApi.deleteDataset: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDatasetApi();
$datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->deleteDataset($datasetUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatasetApi->deleteDataset: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatasetApi;

my $api_instance = WWW::SwaggerClient::DatasetApi->new();
my $datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->deleteDataset(datasetUuid => $datasetUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatasetApi->deleteDataset: $@\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.DatasetApi()
datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # Delete dataset
    api_response = api_instance.delete_dataset(datasetUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatasetApi->deleteDataset: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DatasetApi;

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

public class DatasetApiExample {

    public static void main(String[] args) {
        
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Dataset result = apiInstance.getDataset(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#getDataset");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DatasetApi;

public class DatasetApiExample {

    public static void main(String[] args) {
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Dataset result = apiInstance.getDataset(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#getDataset");
            e.printStackTrace();
        }
    }
}

UUID *datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// Get dataset by id or name.
[apiInstance getDatasetWith:datasetUuid
              completionHandler: ^(Dataset output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DatasetApi()
var datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDataset(datasetUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getDatasetExample
    {
        public void main()
        {

            var apiInstance = new DatasetApi();
            var datasetUuid = new UUID(); // UUID | 

            try
            {
                // Get dataset by id or name.
                Dataset result = apiInstance.getDataset(datasetUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatasetApi.getDataset: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDatasetApi();
$datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getDataset($datasetUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatasetApi->getDataset: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatasetApi;

my $api_instance = WWW::SwaggerClient::DatasetApi->new();
my $datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->getDataset(datasetUuid => $datasetUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatasetApi->getDataset: $@\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.DatasetApi()
datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # Get dataset by id or name.
    api_response = api_instance.get_dataset(datasetUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatasetApi->getDataset: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DatasetApi;

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

public class DatasetApiExample {

    public static void main(String[] args) {
        
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String sampleId = sampleId_example; // String | 
        try {
            Sample result = apiInstance.getDatasetSample(datasetUuid, sampleId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#getDatasetSample");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DatasetApi;

public class DatasetApiExample {

    public static void main(String[] args) {
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String sampleId = sampleId_example; // String | 
        try {
            Sample result = apiInstance.getDatasetSample(datasetUuid, sampleId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#getDatasetSample");
            e.printStackTrace();
        }
    }
}

UUID *datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 
String *sampleId = sampleId_example; // 

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

// get a sample in the dataset
[apiInstance getDatasetSampleWith:datasetUuid
    sampleId:sampleId
              completionHandler: ^(Sample output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DatasetApi()
var datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 
var sampleId = sampleId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDatasetSample(datasetUuid, sampleId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getDatasetSampleExample
    {
        public void main()
        {

            var apiInstance = new DatasetApi();
            var datasetUuid = new UUID(); // UUID | 
            var sampleId = sampleId_example;  // String | 

            try
            {
                // get a sample in the dataset
                Sample result = apiInstance.getDatasetSample(datasetUuid, sampleId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatasetApi.getDatasetSample: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDatasetApi();
$datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$sampleId = sampleId_example; // String | 

try {
    $result = $api_instance->getDatasetSample($datasetUuid, $sampleId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatasetApi->getDatasetSample: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatasetApi;

my $api_instance = WWW::SwaggerClient::DatasetApi->new();
my $datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $sampleId = sampleId_example; # String | 

eval { 
    my $result = $api_instance->getDatasetSample(datasetUuid => $datasetUuid, sampleId => $sampleId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatasetApi->getDatasetSample: $@\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.DatasetApi()
datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 
sampleId = sampleId_example # String | 

try: 
    # get a sample in the dataset
    api_response = api_instance.get_dataset_sample(datasetUuid, sampleId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatasetApi->getDatasetSample: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DatasetApi;

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

public class DatasetApiExample {

    public static void main(String[] args) {
        
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            DataSchema result = apiInstance.getDatasetSchema(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#getDatasetSchema");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DatasetApi;

public class DatasetApiExample {

    public static void main(String[] args) {
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            DataSchema result = apiInstance.getDatasetSchema(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#getDatasetSchema");
            e.printStackTrace();
        }
    }
}

UUID *datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// get a specific dataset's data schema
[apiInstance getDatasetSchemaWith:datasetUuid
              completionHandler: ^(DataSchema output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DatasetApi()
var datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDatasetSchema(datasetUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getDatasetSchemaExample
    {
        public void main()
        {

            var apiInstance = new DatasetApi();
            var datasetUuid = new UUID(); // UUID | 

            try
            {
                // get a specific dataset's data schema
                DataSchema result = apiInstance.getDatasetSchema(datasetUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatasetApi.getDatasetSchema: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDatasetApi();
$datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getDatasetSchema($datasetUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatasetApi->getDatasetSchema: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatasetApi;

my $api_instance = WWW::SwaggerClient::DatasetApi->new();
my $datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->getDatasetSchema(datasetUuid => $datasetUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatasetApi->getDatasetSchema: $@\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.DatasetApi()
datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # get a specific dataset's data schema
    api_response = api_instance.get_dataset_schema(datasetUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatasetApi->getDatasetSchema: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DatasetApi;

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

public class DatasetApiExample {

    public static void main(String[] args) {
        
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Split result = apiInstance.getDatasetSplit(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#getDatasetSplit");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DatasetApi;

public class DatasetApiExample {

    public static void main(String[] args) {
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Split result = apiInstance.getDatasetSplit(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#getDatasetSplit");
            e.printStackTrace();
        }
    }
}

UUID *datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// Get the split of a dataset
[apiInstance getDatasetSplitWith:datasetUuid
              completionHandler: ^(Split output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DatasetApi()
var datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDatasetSplit(datasetUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getDatasetSplitExample
    {
        public void main()
        {

            var apiInstance = new DatasetApi();
            var datasetUuid = new UUID(); // UUID | 

            try
            {
                // Get the split of a dataset
                Split result = apiInstance.getDatasetSplit(datasetUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatasetApi.getDatasetSplit: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDatasetApi();
$datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getDatasetSplit($datasetUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatasetApi->getDatasetSplit: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatasetApi;

my $api_instance = WWW::SwaggerClient::DatasetApi->new();
my $datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->getDatasetSplit(datasetUuid => $datasetUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatasetApi->getDatasetSplit: $@\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.DatasetApi()
datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # Get the split of a dataset
    api_response = api_instance.get_dataset_split(datasetUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatasetApi->getDatasetSplit: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DatasetApi;

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

public class DatasetApiExample {

    public static void main(String[] args) {
        
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            array[Sample] result = apiInstance.listDatasetSamples(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#listDatasetSamples");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DatasetApi;

public class DatasetApiExample {

    public static void main(String[] args) {
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            array[Sample] result = apiInstance.listDatasetSamples(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#listDatasetSamples");
            e.printStackTrace();
        }
    }
}

UUID *datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// get the list of samples in the dataset
[apiInstance listDatasetSamplesWith:datasetUuid
              completionHandler: ^(array[Sample] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DatasetApi()
var datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listDatasetSamples(datasetUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listDatasetSamplesExample
    {
        public void main()
        {

            var apiInstance = new DatasetApi();
            var datasetUuid = new UUID(); // UUID | 

            try
            {
                // get the list of samples in the dataset
                array[Sample] result = apiInstance.listDatasetSamples(datasetUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatasetApi.listDatasetSamples: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDatasetApi();
$datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->listDatasetSamples($datasetUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatasetApi->listDatasetSamples: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatasetApi;

my $api_instance = WWW::SwaggerClient::DatasetApi->new();
my $datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->listDatasetSamples(datasetUuid => $datasetUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatasetApi->listDatasetSamples: $@\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.DatasetApi()
datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # get the list of samples in the dataset
    api_response = api_instance.list_dataset_samples(datasetUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatasetApi->listDatasetSamples: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DatasetApi;

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

public class DatasetApiExample {

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

import io.swagger.client.api.DatasetApi;

public class DatasetApiExample {

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

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

// List datasets
[apiInstance listDatasetsWithCompletionHandler: 
              ^(array[Dataset] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DatasetApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listDatasets(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listDatasetsExample
    {
        public void main()
        {

            var apiInstance = new DatasetApi();

            try
            {
                // List datasets
                array[Dataset] result = apiInstance.listDatasets();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatasetApi.listDatasets: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDatasetApi();

try {
    $result = $api_instance->listDatasets();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatasetApi->listDatasets: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatasetApi;

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

eval { 
    my $result = $api_instance->listDatasets();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatasetApi->listDatasets: $@\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.DatasetApi()

try: 
    # List datasets
    api_response = api_instance.list_datasets()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatasetApi->listDatasets: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DatasetApi;

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

public class DatasetApiExample {

    public static void main(String[] args) {
        
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Conversion result = apiInstance.restartDatasetConversion(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#restartDatasetConversion");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DatasetApi;

public class DatasetApiExample {

    public static void main(String[] args) {
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Conversion result = apiInstance.restartDatasetConversion(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#restartDatasetConversion");
            e.printStackTrace();
        }
    }
}

UUID *datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// Restart a conversion.
[apiInstance restartDatasetConversionWith:datasetUuid
              completionHandler: ^(Conversion output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DatasetApi()
var datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.restartDatasetConversion(datasetUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class restartDatasetConversionExample
    {
        public void main()
        {

            var apiInstance = new DatasetApi();
            var datasetUuid = new UUID(); // UUID | 

            try
            {
                // Restart a conversion.
                Conversion result = apiInstance.restartDatasetConversion(datasetUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatasetApi.restartDatasetConversion: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDatasetApi();
$datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->restartDatasetConversion($datasetUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatasetApi->restartDatasetConversion: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatasetApi;

my $api_instance = WWW::SwaggerClient::DatasetApi->new();
my $datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->restartDatasetConversion(datasetUuid => $datasetUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatasetApi->restartDatasetConversion: $@\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.DatasetApi()
datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # Restart a conversion.
    api_response = api_instance.restart_dataset_conversion(datasetUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatasetApi->restartDatasetConversion: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JobApi;

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

public class JobApiExample {

    public static void main(String[] args) {
        
        JobApi apiInstance = new JobApi();
        String jobUuid = jobUuid_example; // String | uuid or job name
        try {
            inline_response_200 result = apiInstance.deleteJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#deleteJob");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JobApi;

public class JobApiExample {

    public static void main(String[] args) {
        JobApi apiInstance = new JobApi();
        String jobUuid = jobUuid_example; // String | uuid or job name
        try {
            inline_response_200 result = apiInstance.deleteJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#deleteJob");
            e.printStackTrace();
        }
    }
}

String *jobUuid = jobUuid_example; // uuid or job name

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

// get a specific job
[apiInstance deleteJobWith:jobUuid
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.JobApi()
var jobUuid = jobUuid_example; // {{String}} uuid or job name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteJob(jobUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteJobExample
    {
        public void main()
        {

            var apiInstance = new JobApi();
            var jobUuid = jobUuid_example;  // String | uuid or job name

            try
            {
                // get a specific job
                inline_response_200 result = apiInstance.deleteJob(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobApi.deleteJob: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJobApi();
$jobUuid = jobUuid_example; // String | uuid or job name

try {
    $result = $api_instance->deleteJob($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JobApi->deleteJob: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobApi;

my $api_instance = WWW::SwaggerClient::JobApi->new();
my $jobUuid = jobUuid_example; # String | uuid or job name

eval { 
    my $result = $api_instance->deleteJob(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JobApi->deleteJob: $@\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.JobApi()
jobUuid = jobUuid_example # String | uuid or job name

try: 
    # get a specific job
    api_response = api_instance.delete_job(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JobApi->deleteJob: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JobApi;

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

public class JobApiExample {

    public static void main(String[] args) {
        
        JobApi apiInstance = new JobApi();
        String jobUuid = jobUuid_example; // String | uuid or job name
        try {
            byte[] result = apiInstance.downloadJobErrorLogs(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#downloadJobErrorLogs");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JobApi;

public class JobApiExample {

    public static void main(String[] args) {
        JobApi apiInstance = new JobApi();
        String jobUuid = jobUuid_example; // String | uuid or job name
        try {
            byte[] result = apiInstance.downloadJobErrorLogs(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#downloadJobErrorLogs");
            e.printStackTrace();
        }
    }
}

String *jobUuid = jobUuid_example; // uuid or job name

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

// download job error logs
[apiInstance downloadJobErrorLogsWith:jobUuid
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.JobApi()
var jobUuid = jobUuid_example; // {{String}} uuid or job name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.downloadJobErrorLogs(jobUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class downloadJobErrorLogsExample
    {
        public void main()
        {

            var apiInstance = new JobApi();
            var jobUuid = jobUuid_example;  // String | uuid or job name

            try
            {
                // download job error logs
                byte[] result = apiInstance.downloadJobErrorLogs(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobApi.downloadJobErrorLogs: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJobApi();
$jobUuid = jobUuid_example; // String | uuid or job name

try {
    $result = $api_instance->downloadJobErrorLogs($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JobApi->downloadJobErrorLogs: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobApi;

my $api_instance = WWW::SwaggerClient::JobApi->new();
my $jobUuid = jobUuid_example; # String | uuid or job name

eval { 
    my $result = $api_instance->downloadJobErrorLogs(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JobApi->downloadJobErrorLogs: $@\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.JobApi()
jobUuid = jobUuid_example # String | uuid or job name

try: 
    # download job error logs
    api_response = api_instance.download_job_error_logs(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JobApi->downloadJobErrorLogs: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JobApi;

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

public class JobApiExample {

    public static void main(String[] args) {
        
        JobApi apiInstance = new JobApi();
        String jobUuid = jobUuid_example; // String | uuid or job name
        try {
            Job result = apiInstance.getJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#getJob");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JobApi;

public class JobApiExample {

    public static void main(String[] args) {
        JobApi apiInstance = new JobApi();
        String jobUuid = jobUuid_example; // String | uuid or job name
        try {
            Job result = apiInstance.getJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#getJob");
            e.printStackTrace();
        }
    }
}

String *jobUuid = jobUuid_example; // uuid or job name

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

// get a specific job
[apiInstance getJobWith:jobUuid
              completionHandler: ^(Job output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.JobApi()
var jobUuid = jobUuid_example; // {{String}} uuid or job name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getJob(jobUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getJobExample
    {
        public void main()
        {

            var apiInstance = new JobApi();
            var jobUuid = jobUuid_example;  // String | uuid or job name

            try
            {
                // get a specific job
                Job result = apiInstance.getJob(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobApi.getJob: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJobApi();
$jobUuid = jobUuid_example; // String | uuid or job name

try {
    $result = $api_instance->getJob($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JobApi->getJob: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobApi;

my $api_instance = WWW::SwaggerClient::JobApi->new();
my $jobUuid = jobUuid_example; # String | uuid or job name

eval { 
    my $result = $api_instance->getJob(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JobApi->getJob: $@\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.JobApi()
jobUuid = jobUuid_example # String | uuid or job name

try: 
    # get a specific job
    api_response = api_instance.get_job(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JobApi->getJob: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JobApi;

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

public class JobApiExample {

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

import io.swagger.client.api.JobApi;

public class JobApiExample {

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

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

// List jobs
[apiInstance listJobsWithCompletionHandler: 
              ^(array[Job] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.JobApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listJobs(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listJobsExample
    {
        public void main()
        {

            var apiInstance = new JobApi();

            try
            {
                // List jobs
                array[Job] result = apiInstance.listJobs();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobApi.listJobs: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJobApi();

try {
    $result = $api_instance->listJobs();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JobApi->listJobs: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobApi;

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

eval { 
    my $result = $api_instance->listJobs();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JobApi->listJobs: $@\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.JobApi()

try: 
    # List jobs
    api_response = api_instance.list_jobs()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JobApi->listJobs: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JobApi;

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

public class JobApiExample {

    public static void main(String[] args) {
        
        JobApi apiInstance = new JobApi();
        String jobUuid = jobUuid_example; // String | uuid or job name
        try {
            Job result = apiInstance.restartJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#restartJob");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JobApi;

public class JobApiExample {

    public static void main(String[] args) {
        JobApi apiInstance = new JobApi();
        String jobUuid = jobUuid_example; // String | uuid or job name
        try {
            Job result = apiInstance.restartJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#restartJob");
            e.printStackTrace();
        }
    }
}

String *jobUuid = jobUuid_example; // uuid or job name

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

// restart a specific job
[apiInstance restartJobWith:jobUuid
              completionHandler: ^(Job output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.JobApi()
var jobUuid = jobUuid_example; // {{String}} uuid or job name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.restartJob(jobUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class restartJobExample
    {
        public void main()
        {

            var apiInstance = new JobApi();
            var jobUuid = jobUuid_example;  // String | uuid or job name

            try
            {
                // restart a specific job
                Job result = apiInstance.restartJob(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobApi.restartJob: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJobApi();
$jobUuid = jobUuid_example; // String | uuid or job name

try {
    $result = $api_instance->restartJob($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JobApi->restartJob: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobApi;

my $api_instance = WWW::SwaggerClient::JobApi->new();
my $jobUuid = jobUuid_example; # String | uuid or job name

eval { 
    my $result = $api_instance->restartJob(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JobApi->restartJob: $@\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.JobApi()
jobUuid = jobUuid_example # String | uuid or job name

try: 
    # restart a specific job
    api_response = api_instance.restart_job(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JobApi->restartJob: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JobApi;

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

public class JobApiExample {

    public static void main(String[] args) {
        
        JobApi apiInstance = new JobApi();
        String jobUuid = jobUuid_example; // String | uuid or job name
        try {
            Job result = apiInstance.stopJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#stopJob");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JobApi;

public class JobApiExample {

    public static void main(String[] args) {
        JobApi apiInstance = new JobApi();
        String jobUuid = jobUuid_example; // String | uuid or job name
        try {
            Job result = apiInstance.stopJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#stopJob");
            e.printStackTrace();
        }
    }
}

String *jobUuid = jobUuid_example; // uuid or job name

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

// stop a specific job
[apiInstance stopJobWith:jobUuid
              completionHandler: ^(Job output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.JobApi()
var jobUuid = jobUuid_example; // {{String}} uuid or job name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.stopJob(jobUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class stopJobExample
    {
        public void main()
        {

            var apiInstance = new JobApi();
            var jobUuid = jobUuid_example;  // String | uuid or job name

            try
            {
                // stop a specific job
                Job result = apiInstance.stopJob(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobApi.stopJob: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJobApi();
$jobUuid = jobUuid_example; // String | uuid or job name

try {
    $result = $api_instance->stopJob($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JobApi->stopJob: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobApi;

my $api_instance = WWW::SwaggerClient::JobApi->new();
my $jobUuid = jobUuid_example; # String | uuid or job name

eval { 
    my $result = $api_instance->stopJob(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JobApi->stopJob: $@\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.JobApi()
jobUuid = jobUuid_example # String | uuid or job name

try: 
    # stop a specific job
    api_response = api_instance.stop_job(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JobApi->stopJob: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PredictionApi;

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

public class PredictionApiExample {

    public static void main(String[] args) {
        
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            inline_response_200 result = apiInstance.deletePredictionJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#deletePredictionJob");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PredictionApi;

public class PredictionApiExample {

    public static void main(String[] args) {
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            inline_response_200 result = apiInstance.deletePredictionJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#deletePredictionJob");
            e.printStackTrace();
        }
    }
}

UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// delete a specific prediction job
[apiInstance deletePredictionJobWith:jobUuid
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.PredictionApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deletePredictionJob(jobUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deletePredictionJobExample
    {
        public void main()
        {

            var apiInstance = new PredictionApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // delete a specific prediction job
                inline_response_200 result = apiInstance.deletePredictionJob(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PredictionApi.deletePredictionJob: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPredictionApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->deletePredictionJob($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PredictionApi->deletePredictionJob: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PredictionApi;

my $api_instance = WWW::SwaggerClient::PredictionApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->deletePredictionJob(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PredictionApi->deletePredictionJob: $@\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.PredictionApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # delete a specific prediction job
    api_response = api_instance.delete_prediction_job(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PredictionApi->deletePredictionJob: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PredictionApi;

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

public class PredictionApiExample {

    public static void main(String[] args) {
        
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            byte[] result = apiInstance.downloadPrediction(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#downloadPrediction");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PredictionApi;

public class PredictionApiExample {

    public static void main(String[] args) {
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            byte[] result = apiInstance.downloadPrediction(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#downloadPrediction");
            e.printStackTrace();
        }
    }
}

UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// download the predictions of the batch prediction job.
[apiInstance downloadPredictionWith:jobUuid
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.PredictionApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.downloadPrediction(jobUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class downloadPredictionExample
    {
        public void main()
        {

            var apiInstance = new PredictionApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // download the predictions of the batch prediction job.
                byte[] result = apiInstance.downloadPrediction(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PredictionApi.downloadPrediction: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPredictionApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->downloadPrediction($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PredictionApi->downloadPrediction: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PredictionApi;

my $api_instance = WWW::SwaggerClient::PredictionApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->downloadPrediction(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PredictionApi->downloadPrediction: $@\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.PredictionApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # download the predictions of the batch prediction job.
    api_response = api_instance.download_prediction(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PredictionApi->downloadPrediction: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PredictionApi;

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

public class PredictionApiExample {

    public static void main(String[] args) {
        
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Prediction result = apiInstance.getPredictionJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#getPredictionJob");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PredictionApi;

public class PredictionApiExample {

    public static void main(String[] args) {
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Prediction result = apiInstance.getPredictionJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#getPredictionJob");
            e.printStackTrace();
        }
    }
}

UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// Get details of prediction job
[apiInstance getPredictionJobWith:jobUuid
              completionHandler: ^(Prediction output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.PredictionApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getPredictionJob(jobUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getPredictionJobExample
    {
        public void main()
        {

            var apiInstance = new PredictionApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // Get details of prediction job
                Prediction result = apiInstance.getPredictionJob(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PredictionApi.getPredictionJob: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPredictionApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getPredictionJob($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PredictionApi->getPredictionJob: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PredictionApi;

my $api_instance = WWW::SwaggerClient::PredictionApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->getPredictionJob(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PredictionApi->getPredictionJob: $@\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.PredictionApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # Get details of prediction job
    api_response = api_instance.get_prediction_job(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PredictionApi->getPredictionJob: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PredictionApi;

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

public class PredictionApiExample {

    public static void main(String[] args) {
        
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID sampleId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            inline_response_200_1 result = apiInstance.getPredictionResultForSample(jobUuid, sampleId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#getPredictionResultForSample");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PredictionApi;

public class PredictionApiExample {

    public static void main(String[] args) {
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID sampleId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            inline_response_200_1 result = apiInstance.getPredictionResultForSample(jobUuid, sampleId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#getPredictionResultForSample");
            e.printStackTrace();
        }
    }
}

UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 
UUID *sampleId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// get prediction result for a sample
[apiInstance getPredictionResultForSampleWith:jobUuid
    sampleId:sampleId
              completionHandler: ^(inline_response_200_1 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.PredictionApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 
var sampleId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getPredictionResultForSample(jobUuid, sampleId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getPredictionResultForSampleExample
    {
        public void main()
        {

            var apiInstance = new PredictionApi();
            var jobUuid = new UUID(); // UUID | 
            var sampleId = new UUID(); // UUID | 

            try
            {
                // get prediction result for a sample
                inline_response_200_1 result = apiInstance.getPredictionResultForSample(jobUuid, sampleId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PredictionApi.getPredictionResultForSample: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPredictionApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$sampleId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getPredictionResultForSample($jobUuid, $sampleId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PredictionApi->getPredictionResultForSample: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PredictionApi;

my $api_instance = WWW::SwaggerClient::PredictionApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $sampleId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->getPredictionResultForSample(jobUuid => $jobUuid, sampleId => $sampleId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PredictionApi->getPredictionResultForSample: $@\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.PredictionApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 
sampleId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # get prediction result for a sample
    api_response = api_instance.get_prediction_result_for_sample(jobUuid, sampleId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PredictionApi->getPredictionResultForSample: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PredictionApi;

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

public class PredictionApiExample {

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

import io.swagger.client.api.PredictionApi;

public class PredictionApiExample {

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

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

[apiInstance listPredictionJobsWithCompletionHandler: 
              ^(array[Prediction] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.PredictionApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listPredictionJobs(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listPredictionJobsExample
    {
        public void main()
        {

            var apiInstance = new PredictionApi();

            try
            {
                array[Prediction] result = apiInstance.listPredictionJobs();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PredictionApi.listPredictionJobs: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPredictionApi();

try {
    $result = $api_instance->listPredictionJobs();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PredictionApi->listPredictionJobs: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PredictionApi;

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

eval { 
    my $result = $api_instance->listPredictionJobs();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PredictionApi->listPredictionJobs: $@\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.PredictionApi()

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

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PredictionApi;

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

public class PredictionApiExample {

    public static void main(String[] args) {
        
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Object result = apiInstance.listPredictionResultIds(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#listPredictionResultIds");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PredictionApi;

public class PredictionApiExample {

    public static void main(String[] args) {
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Object result = apiInstance.listPredictionResultIds(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#listPredictionResultIds");
            e.printStackTrace();
        }
    }
}

UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// list sample Ids of prediction results
[apiInstance listPredictionResultIdsWith:jobUuid
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.PredictionApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listPredictionResultIds(jobUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listPredictionResultIdsExample
    {
        public void main()
        {

            var apiInstance = new PredictionApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // list sample Ids of prediction results
                Object result = apiInstance.listPredictionResultIds(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PredictionApi.listPredictionResultIds: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPredictionApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->listPredictionResultIds($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PredictionApi->listPredictionResultIds: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PredictionApi;

my $api_instance = WWW::SwaggerClient::PredictionApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->listPredictionResultIds(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PredictionApi->listPredictionResultIds: $@\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.PredictionApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # list sample Ids of prediction results
    api_response = api_instance.list_prediction_result_ids(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PredictionApi->listPredictionResultIds: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PredictionApi;

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

public class PredictionApiExample {

    public static void main(String[] args) {
        
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Prediction result = apiInstance.restartPredictionJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#restartPredictionJob");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PredictionApi;

public class PredictionApiExample {

    public static void main(String[] args) {
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Prediction result = apiInstance.restartPredictionJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#restartPredictionJob");
            e.printStackTrace();
        }
    }
}

UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// restart a specific prediction
[apiInstance restartPredictionJobWith:jobUuid
              completionHandler: ^(Prediction output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.PredictionApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.restartPredictionJob(jobUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class restartPredictionJobExample
    {
        public void main()
        {

            var apiInstance = new PredictionApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // restart a specific prediction
                Prediction result = apiInstance.restartPredictionJob(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PredictionApi.restartPredictionJob: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPredictionApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->restartPredictionJob($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PredictionApi->restartPredictionJob: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PredictionApi;

my $api_instance = WWW::SwaggerClient::PredictionApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->restartPredictionJob(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PredictionApi->restartPredictionJob: $@\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.PredictionApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # restart a specific prediction
    api_response = api_instance.restart_prediction_job(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PredictionApi->restartPredictionJob: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PredictionApi;

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

public class PredictionApiExample {

    public static void main(String[] args) {
        
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Prediction result = apiInstance.stopPredictionJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#stopPredictionJob");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PredictionApi;

public class PredictionApiExample {

    public static void main(String[] args) {
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Prediction result = apiInstance.stopPredictionJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#stopPredictionJob");
            e.printStackTrace();
        }
    }
}

UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// stop a specific prediction
[apiInstance stopPredictionJobWith:jobUuid
              completionHandler: ^(Prediction output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.PredictionApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.stopPredictionJob(jobUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class stopPredictionJobExample
    {
        public void main()
        {

            var apiInstance = new PredictionApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // stop a specific prediction
                Prediction result = apiInstance.stopPredictionJob(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PredictionApi.stopPredictionJob: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPredictionApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->stopPredictionJob($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PredictionApi->stopPredictionJob: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PredictionApi;

my $api_instance = WWW::SwaggerClient::PredictionApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->stopPredictionJob(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PredictionApi->stopPredictionJob: $@\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.PredictionApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # stop a specific prediction
    api_response = api_instance.stop_prediction_job(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PredictionApi->stopPredictionJob: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PredictionApi;

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

public class PredictionApiExample {

    public static void main(String[] args) {
        
        PredictionApi apiInstance = new PredictionApi();
        Prediction body = ; // Prediction | 
        try {
            Prediction result = apiInstance.submitPredictionJob(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#submitPredictionJob");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PredictionApi;

public class PredictionApiExample {

    public static void main(String[] args) {
        PredictionApi apiInstance = new PredictionApi();
        Prediction body = ; // Prediction | 
        try {
            Prediction result = apiInstance.submitPredictionJob(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#submitPredictionJob");
            e.printStackTrace();
        }
    }
}

Prediction *body = ; //  (optional)

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

// submit a batch prediction job
[apiInstance submitPredictionJobWith:body
              completionHandler: ^(Prediction output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.PredictionApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.submitPredictionJob(, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class submitPredictionJobExample
    {
        public void main()
        {

            var apiInstance = new PredictionApi();
            var body = new Prediction(); // Prediction |  (optional) 

            try
            {
                // submit a batch prediction job
                Prediction result = apiInstance.submitPredictionJob(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PredictionApi.submitPredictionJob: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPredictionApi();
$body = ; // Prediction | 

try {
    $result = $api_instance->submitPredictionJob($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PredictionApi->submitPredictionJob: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PredictionApi;

my $api_instance = WWW::SwaggerClient::PredictionApi->new();
my $body = WWW::SwaggerClient::Object::Prediction->new(); # Prediction | 

eval { 
    my $result = $api_instance->submitPredictionJob(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PredictionApi->submitPredictionJob: $@\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.PredictionApi()
body =  # Prediction |  (optional)

try: 
    # submit a batch prediction job
    api_response = api_instance.submit_prediction_job(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PredictionApi->submitPredictionJob: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SessionApi;

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

public class SessionApiExample {

    public static void main(String[] args) {
        
        SessionApi apiInstance = new SessionApi();
        String sessionId = sessionId_example; // String | 
        try {
            inline_response_200 result = apiInstance.deleteSession(sessionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SessionApi#deleteSession");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SessionApi;

public class SessionApiExample {

    public static void main(String[] args) {
        SessionApi apiInstance = new SessionApi();
        String sessionId = sessionId_example; // String | 
        try {
            inline_response_200 result = apiInstance.deleteSession(sessionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SessionApi#deleteSession");
            e.printStackTrace();
        }
    }
}

String *sessionId = sessionId_example; // 

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

// Delete a session
[apiInstance deleteSessionWith:sessionId
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.SessionApi()
var sessionId = sessionId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteSession(sessionId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteSessionExample
    {
        public void main()
        {

            var apiInstance = new SessionApi();
            var sessionId = sessionId_example;  // String | 

            try
            {
                // Delete a session
                inline_response_200 result = apiInstance.deleteSession(sessionId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SessionApi.deleteSession: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSessionApi();
$sessionId = sessionId_example; // String | 

try {
    $result = $api_instance->deleteSession($sessionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SessionApi->deleteSession: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SessionApi;

my $api_instance = WWW::SwaggerClient::SessionApi->new();
my $sessionId = sessionId_example; # String | 

eval { 
    my $result = $api_instance->deleteSession(sessionId => $sessionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SessionApi->deleteSession: $@\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.SessionApi()
sessionId = sessionId_example # String | 

try: 
    # Delete a session
    api_response = api_instance.delete_session(sessionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SessionApi->deleteSession: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SessionApi;

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

public class SessionApiExample {

    public static void main(String[] args) {
        
        SessionApi apiInstance = new SessionApi();
        String sessionId = sessionId_example; // String | 
        try {
            SessionInfo result = apiInstance.getSessionInfo(sessionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SessionApi#getSessionInfo");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SessionApi;

public class SessionApiExample {

    public static void main(String[] args) {
        SessionApi apiInstance = new SessionApi();
        String sessionId = sessionId_example; // String | 
        try {
            SessionInfo result = apiInstance.getSessionInfo(sessionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SessionApi#getSessionInfo");
            e.printStackTrace();
        }
    }
}

String *sessionId = sessionId_example; // 

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

// Get session information
[apiInstance getSessionInfoWith:sessionId
              completionHandler: ^(SessionInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.SessionApi()
var sessionId = sessionId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSessionInfo(sessionId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getSessionInfoExample
    {
        public void main()
        {

            var apiInstance = new SessionApi();
            var sessionId = sessionId_example;  // String | 

            try
            {
                // Get session information
                SessionInfo result = apiInstance.getSessionInfo(sessionId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SessionApi.getSessionInfo: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSessionApi();
$sessionId = sessionId_example; // String | 

try {
    $result = $api_instance->getSessionInfo($sessionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SessionApi->getSessionInfo: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SessionApi;

my $api_instance = WWW::SwaggerClient::SessionApi->new();
my $sessionId = sessionId_example; # String | 

eval { 
    my $result = $api_instance->getSessionInfo(sessionId => $sessionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SessionApi->getSessionInfo: $@\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.SessionApi()
sessionId = sessionId_example # String | 

try: 
    # Get session information
    api_response = api_instance.get_session_info(sessionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SessionApi->getSessionInfo: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SessionApi;

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

public class SessionApiExample {

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

import io.swagger.client.api.SessionApi;

public class SessionApiExample {

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

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

// List sessions
[apiInstance listSessionsWithCompletionHandler: 
              ^(array[SessionInfo] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.SessionApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listSessions(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listSessionsExample
    {
        public void main()
        {

            var apiInstance = new SessionApi();

            try
            {
                // List sessions
                array[SessionInfo] result = apiInstance.listSessions();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SessionApi.listSessions: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSessionApi();

try {
    $result = $api_instance->listSessions();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SessionApi->listSessions: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SessionApi;

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

eval { 
    my $result = $api_instance->listSessions();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SessionApi->listSessions: $@\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.SessionApi()

try: 
    # List sessions
    api_response = api_instance.list_sessions()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SessionApi->listSessions: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SessionApi;

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

public class SessionApiExample {

    public static void main(String[] args) {
        
        SessionApi apiInstance = new SessionApi();
        String sessionId = sessionId_example; // String | 
        try {
            SessionInfo result = apiInstance.restartSession(sessionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SessionApi#restartSession");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SessionApi;

public class SessionApiExample {

    public static void main(String[] args) {
        SessionApi apiInstance = new SessionApi();
        String sessionId = sessionId_example; // String | 
        try {
            SessionInfo result = apiInstance.restartSession(sessionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SessionApi#restartSession");
            e.printStackTrace();
        }
    }
}

String *sessionId = sessionId_example; // 

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

// Restart an interactive session
[apiInstance restartSessionWith:sessionId
              completionHandler: ^(SessionInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.SessionApi()
var sessionId = sessionId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.restartSession(sessionId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class restartSessionExample
    {
        public void main()
        {

            var apiInstance = new SessionApi();
            var sessionId = sessionId_example;  // String | 

            try
            {
                // Restart an interactive session
                SessionInfo result = apiInstance.restartSession(sessionId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SessionApi.restartSession: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSessionApi();
$sessionId = sessionId_example; // String | 

try {
    $result = $api_instance->restartSession($sessionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SessionApi->restartSession: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SessionApi;

my $api_instance = WWW::SwaggerClient::SessionApi->new();
my $sessionId = sessionId_example; # String | 

eval { 
    my $result = $api_instance->restartSession(sessionId => $sessionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SessionApi->restartSession: $@\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.SessionApi()
sessionId = sessionId_example # String | 

try: 
    # Restart an interactive session
    api_response = api_instance.restart_session(sessionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SessionApi->restartSession: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SessionApi;

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

public class SessionApiExample {

    public static void main(String[] args) {
        
        SessionApi apiInstance = new SessionApi();
        SessionRequest body = ; // SessionRequest | 
        try {
            SessionInfo result = apiInstance.startSession(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SessionApi#startSession");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SessionApi;

public class SessionApiExample {

    public static void main(String[] args) {
        SessionApi apiInstance = new SessionApi();
        SessionRequest body = ; // SessionRequest | 
        try {
            SessionInfo result = apiInstance.startSession(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SessionApi#startSession");
            e.printStackTrace();
        }
    }
}

SessionRequest *body = ; //  (optional)

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

// Start an interactive session
[apiInstance startSessionWith:body
              completionHandler: ^(SessionInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.SessionApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.startSession(, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class startSessionExample
    {
        public void main()
        {

            var apiInstance = new SessionApi();
            var body = new SessionRequest(); // SessionRequest |  (optional) 

            try
            {
                // Start an interactive session
                SessionInfo result = apiInstance.startSession(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SessionApi.startSession: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSessionApi();
$body = ; // SessionRequest | 

try {
    $result = $api_instance->startSession($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SessionApi->startSession: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SessionApi;

my $api_instance = WWW::SwaggerClient::SessionApi->new();
my $body = WWW::SwaggerClient::Object::SessionRequest->new(); # SessionRequest | 

eval { 
    my $result = $api_instance->startSession(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SessionApi->startSession: $@\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.SessionApi()
body =  # SessionRequest |  (optional)

try: 
    # Start an interactive session
    api_response = api_instance.start_session(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SessionApi->startSession: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SessionApi;

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

public class SessionApiExample {

    public static void main(String[] args) {
        
        SessionApi apiInstance = new SessionApi();
        String sessionId = sessionId_example; // String | 
        try {
            SessionInfo result = apiInstance.stopSession(sessionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SessionApi#stopSession");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SessionApi;

public class SessionApiExample {

    public static void main(String[] args) {
        SessionApi apiInstance = new SessionApi();
        String sessionId = sessionId_example; // String | 
        try {
            SessionInfo result = apiInstance.stopSession(sessionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SessionApi#stopSession");
            e.printStackTrace();
        }
    }
}

String *sessionId = sessionId_example; // 

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

// Stop an interactive session
[apiInstance stopSessionWith:sessionId
              completionHandler: ^(SessionInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.SessionApi()
var sessionId = sessionId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.stopSession(sessionId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class stopSessionExample
    {
        public void main()
        {

            var apiInstance = new SessionApi();
            var sessionId = sessionId_example;  // String | 

            try
            {
                // Stop an interactive session
                SessionInfo result = apiInstance.stopSession(sessionId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SessionApi.stopSession: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSessionApi();
$sessionId = sessionId_example; // String | 

try {
    $result = $api_instance->stopSession($sessionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SessionApi->stopSession: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SessionApi;

my $api_instance = WWW::SwaggerClient::SessionApi->new();
my $sessionId = sessionId_example; # String | 

eval { 
    my $result = $api_instance->stopSession(sessionId => $sessionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SessionApi->stopSession: $@\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.SessionApi()
sessionId = sessionId_example # String | 

try: 
    # Stop an interactive session
    api_response = api_instance.stop_session(sessionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SessionApi->stopSession: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TensorboardApi;

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

public class TensorboardApiExample {

    public static void main(String[] args) {
        
        TensorboardApi apiInstance = new TensorboardApi();
        String sessionId = sessionId_example; // String | 
        try {
            inline_response_200 result = apiInstance.deleteTensorboardSession(sessionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TensorboardApi#deleteTensorboardSession");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TensorboardApi;

public class TensorboardApiExample {

    public static void main(String[] args) {
        TensorboardApi apiInstance = new TensorboardApi();
        String sessionId = sessionId_example; // String | 
        try {
            inline_response_200 result = apiInstance.deleteTensorboardSession(sessionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TensorboardApi#deleteTensorboardSession");
            e.printStackTrace();
        }
    }
}

String *sessionId = sessionId_example; // 

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

// Delete a tensorboard session
[apiInstance deleteTensorboardSessionWith:sessionId
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TensorboardApi()
var sessionId = sessionId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteTensorboardSession(sessionId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteTensorboardSessionExample
    {
        public void main()
        {

            var apiInstance = new TensorboardApi();
            var sessionId = sessionId_example;  // String | 

            try
            {
                // Delete a tensorboard session
                inline_response_200 result = apiInstance.deleteTensorboardSession(sessionId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TensorboardApi.deleteTensorboardSession: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTensorboardApi();
$sessionId = sessionId_example; // String | 

try {
    $result = $api_instance->deleteTensorboardSession($sessionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TensorboardApi->deleteTensorboardSession: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TensorboardApi;

my $api_instance = WWW::SwaggerClient::TensorboardApi->new();
my $sessionId = sessionId_example; # String | 

eval { 
    my $result = $api_instance->deleteTensorboardSession(sessionId => $sessionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TensorboardApi->deleteTensorboardSession: $@\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.TensorboardApi()
sessionId = sessionId_example # String | 

try: 
    # Delete a tensorboard session
    api_response = api_instance.delete_tensorboard_session(sessionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TensorboardApi->deleteTensorboardSession: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TensorboardApi;

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

public class TensorboardApiExample {

    public static void main(String[] args) {
        
        TensorboardApi apiInstance = new TensorboardApi();
        String sessionId = sessionId_example; // String | 
        try {
            TensorboardInfo result = apiInstance.getTensorboardSessionInfo(sessionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TensorboardApi#getTensorboardSessionInfo");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TensorboardApi;

public class TensorboardApiExample {

    public static void main(String[] args) {
        TensorboardApi apiInstance = new TensorboardApi();
        String sessionId = sessionId_example; // String | 
        try {
            TensorboardInfo result = apiInstance.getTensorboardSessionInfo(sessionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TensorboardApi#getTensorboardSessionInfo");
            e.printStackTrace();
        }
    }
}

String *sessionId = sessionId_example; // 

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

// Get tensorboard session information
[apiInstance getTensorboardSessionInfoWith:sessionId
              completionHandler: ^(TensorboardInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TensorboardApi()
var sessionId = sessionId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTensorboardSessionInfo(sessionId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTensorboardSessionInfoExample
    {
        public void main()
        {

            var apiInstance = new TensorboardApi();
            var sessionId = sessionId_example;  // String | 

            try
            {
                // Get tensorboard session information
                TensorboardInfo result = apiInstance.getTensorboardSessionInfo(sessionId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TensorboardApi.getTensorboardSessionInfo: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTensorboardApi();
$sessionId = sessionId_example; // String | 

try {
    $result = $api_instance->getTensorboardSessionInfo($sessionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TensorboardApi->getTensorboardSessionInfo: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TensorboardApi;

my $api_instance = WWW::SwaggerClient::TensorboardApi->new();
my $sessionId = sessionId_example; # String | 

eval { 
    my $result = $api_instance->getTensorboardSessionInfo(sessionId => $sessionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TensorboardApi->getTensorboardSessionInfo: $@\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.TensorboardApi()
sessionId = sessionId_example # String | 

try: 
    # Get tensorboard session information
    api_response = api_instance.get_tensorboard_session_info(sessionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TensorboardApi->getTensorboardSessionInfo: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TensorboardApi;

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

public class TensorboardApiExample {

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

import io.swagger.client.api.TensorboardApi;

public class TensorboardApiExample {

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

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

// List sessions
[apiInstance listTensorboardSessionsWithCompletionHandler: 
              ^(array[TensorboardInfo] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TensorboardApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listTensorboardSessions(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listTensorboardSessionsExample
    {
        public void main()
        {

            var apiInstance = new TensorboardApi();

            try
            {
                // List sessions
                array[TensorboardInfo] result = apiInstance.listTensorboardSessions();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TensorboardApi.listTensorboardSessions: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTensorboardApi();

try {
    $result = $api_instance->listTensorboardSessions();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TensorboardApi->listTensorboardSessions: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TensorboardApi;

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

eval { 
    my $result = $api_instance->listTensorboardSessions();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TensorboardApi->listTensorboardSessions: $@\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.TensorboardApi()

try: 
    # List sessions
    api_response = api_instance.list_tensorboard_sessions()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TensorboardApi->listTensorboardSessions: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TensorboardApi;

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

public class TensorboardApiExample {

    public static void main(String[] args) {
        
        TensorboardApi apiInstance = new TensorboardApi();
        String sessionId = sessionId_example; // String | 
        try {
            TensorboardInfo result = apiInstance.restartTensorboardSession(sessionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TensorboardApi#restartTensorboardSession");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TensorboardApi;

public class TensorboardApiExample {

    public static void main(String[] args) {
        TensorboardApi apiInstance = new TensorboardApi();
        String sessionId = sessionId_example; // String | 
        try {
            TensorboardInfo result = apiInstance.restartTensorboardSession(sessionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TensorboardApi#restartTensorboardSession");
            e.printStackTrace();
        }
    }
}

String *sessionId = sessionId_example; // 

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

// Restart a tensorboard session
[apiInstance restartTensorboardSessionWith:sessionId
              completionHandler: ^(TensorboardInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TensorboardApi()
var sessionId = sessionId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.restartTensorboardSession(sessionId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class restartTensorboardSessionExample
    {
        public void main()
        {

            var apiInstance = new TensorboardApi();
            var sessionId = sessionId_example;  // String | 

            try
            {
                // Restart a tensorboard session
                TensorboardInfo result = apiInstance.restartTensorboardSession(sessionId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TensorboardApi.restartTensorboardSession: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTensorboardApi();
$sessionId = sessionId_example; // String | 

try {
    $result = $api_instance->restartTensorboardSession($sessionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TensorboardApi->restartTensorboardSession: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TensorboardApi;

my $api_instance = WWW::SwaggerClient::TensorboardApi->new();
my $sessionId = sessionId_example; # String | 

eval { 
    my $result = $api_instance->restartTensorboardSession(sessionId => $sessionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TensorboardApi->restartTensorboardSession: $@\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.TensorboardApi()
sessionId = sessionId_example # String | 

try: 
    # Restart a tensorboard session
    api_response = api_instance.restart_tensorboard_session(sessionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TensorboardApi->restartTensorboardSession: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TensorboardApi;

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

public class TensorboardApiExample {

    public static void main(String[] args) {
        
        TensorboardApi apiInstance = new TensorboardApi();
        TensorboardRequest body = ; // TensorboardRequest | 
        try {
            TensorboardInfo result = apiInstance.startTensorboardSession(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TensorboardApi#startTensorboardSession");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TensorboardApi;

public class TensorboardApiExample {

    public static void main(String[] args) {
        TensorboardApi apiInstance = new TensorboardApi();
        TensorboardRequest body = ; // TensorboardRequest | 
        try {
            TensorboardInfo result = apiInstance.startTensorboardSession(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TensorboardApi#startTensorboardSession");
            e.printStackTrace();
        }
    }
}

TensorboardRequest *body = ; //  (optional)

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

// Start an tensorboard session
[apiInstance startTensorboardSessionWith:body
              completionHandler: ^(TensorboardInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TensorboardApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.startTensorboardSession(, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class startTensorboardSessionExample
    {
        public void main()
        {

            var apiInstance = new TensorboardApi();
            var body = new TensorboardRequest(); // TensorboardRequest |  (optional) 

            try
            {
                // Start an tensorboard session
                TensorboardInfo result = apiInstance.startTensorboardSession(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TensorboardApi.startTensorboardSession: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTensorboardApi();
$body = ; // TensorboardRequest | 

try {
    $result = $api_instance->startTensorboardSession($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TensorboardApi->startTensorboardSession: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TensorboardApi;

my $api_instance = WWW::SwaggerClient::TensorboardApi->new();
my $body = WWW::SwaggerClient::Object::TensorboardRequest->new(); # TensorboardRequest | 

eval { 
    my $result = $api_instance->startTensorboardSession(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TensorboardApi->startTensorboardSession: $@\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.TensorboardApi()
body =  # TensorboardRequest |  (optional)

try: 
    # Start an tensorboard session
    api_response = api_instance.start_tensorboard_session(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TensorboardApi->startTensorboardSession: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TensorboardApi;

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

public class TensorboardApiExample {

    public static void main(String[] args) {
        
        TensorboardApi apiInstance = new TensorboardApi();
        String sessionId = sessionId_example; // String | 
        try {
            TensorboardInfo result = apiInstance.stopTensorboardSession(sessionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TensorboardApi#stopTensorboardSession");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TensorboardApi;

public class TensorboardApiExample {

    public static void main(String[] args) {
        TensorboardApi apiInstance = new TensorboardApi();
        String sessionId = sessionId_example; // String | 
        try {
            TensorboardInfo result = apiInstance.stopTensorboardSession(sessionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TensorboardApi#stopTensorboardSession");
            e.printStackTrace();
        }
    }
}

String *sessionId = sessionId_example; // 

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

// Stop a tensorboard session
[apiInstance stopTensorboardSessionWith:sessionId
              completionHandler: ^(TensorboardInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TensorboardApi()
var sessionId = sessionId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.stopTensorboardSession(sessionId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class stopTensorboardSessionExample
    {
        public void main()
        {

            var apiInstance = new TensorboardApi();
            var sessionId = sessionId_example;  // String | 

            try
            {
                // Stop a tensorboard session
                TensorboardInfo result = apiInstance.stopTensorboardSession(sessionId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TensorboardApi.stopTensorboardSession: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTensorboardApi();
$sessionId = sessionId_example; // String | 

try {
    $result = $api_instance->stopTensorboardSession($sessionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TensorboardApi->stopTensorboardSession: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TensorboardApi;

my $api_instance = WWW::SwaggerClient::TensorboardApi->new();
my $sessionId = sessionId_example; # String | 

eval { 
    my $result = $api_instance->stopTensorboardSession(sessionId => $sessionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TensorboardApi->stopTensorboardSession: $@\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.TensorboardApi()
sessionId = sessionId_example # String | 

try: 
    # Stop a tensorboard session
    api_response = api_instance.stop_tensorboard_session(sessionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TensorboardApi->stopTensorboardSession: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainedModelApi;

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

public class TrainedModelApiExample {

    public static void main(String[] args) {
        
        TrainedModelApi apiInstance = new TrainedModelApi();
        array[byte[]] filename = ; // array[byte[]] | 
        try {
            TrainedModel result = apiInstance.addTrainedModel(filename);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainedModelApi#addTrainedModel");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TrainedModelApi;

public class TrainedModelApiExample {

    public static void main(String[] args) {
        TrainedModelApi apiInstance = new TrainedModelApi();
        array[byte[]] filename = ; // array[byte[]] | 
        try {
            TrainedModel result = apiInstance.addTrainedModel(filename);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainedModelApi#addTrainedModel");
            e.printStackTrace();
        }
    }
}

array[byte[]] *filename = ; //  (optional)

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

// Add a trained model
[apiInstance addTrainedModelWith:filename
              completionHandler: ^(TrainedModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainedModelApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addTrainedModel(, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addTrainedModelExample
    {
        public void main()
        {

            var apiInstance = new TrainedModelApi();
            var filename = new array[byte[]](); // array[byte[]] |  (optional) 

            try
            {
                // Add a trained model
                TrainedModel result = apiInstance.addTrainedModel(filename);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainedModelApi.addTrainedModel: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainedModelApi();
$filename = ; // array[byte[]] | 

try {
    $result = $api_instance->addTrainedModel($filename);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainedModelApi->addTrainedModel: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainedModelApi;

my $api_instance = WWW::SwaggerClient::TrainedModelApi->new();
my $filename = []; # array[byte[]] | 

eval { 
    my $result = $api_instance->addTrainedModel(filename => $filename);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainedModelApi->addTrainedModel: $@\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.TrainedModelApi()
filename =  # array[byte[]] |  (optional)

try: 
    # Add a trained model
    api_response = api_instance.add_trained_model(filename=filename)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainedModelApi->addTrainedModel: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainedModelApi;

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

public class TrainedModelApiExample {

    public static void main(String[] args) {
        
        TrainedModelApi apiInstance = new TrainedModelApi();
        UUID modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid
        try {
            inline_response_200 result = apiInstance.deleteTrainedModel(modelUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainedModelApi#deleteTrainedModel");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TrainedModelApi;

public class TrainedModelApiExample {

    public static void main(String[] args) {
        TrainedModelApi apiInstance = new TrainedModelApi();
        UUID modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid
        try {
            inline_response_200 result = apiInstance.deleteTrainedModel(modelUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainedModelApi#deleteTrainedModel");
            e.printStackTrace();
        }
    }
}

UUID *modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // model name or uuid

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

// Delete trained model
[apiInstance deleteTrainedModelWith:modelUuid
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainedModelApi()
var modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} model name or uuid

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteTrainedModel(modelUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteTrainedModelExample
    {
        public void main()
        {

            var apiInstance = new TrainedModelApi();
            var modelUuid = new UUID(); // UUID | model name or uuid

            try
            {
                // Delete trained model
                inline_response_200 result = apiInstance.deleteTrainedModel(modelUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainedModelApi.deleteTrainedModel: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainedModelApi();
$modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid

try {
    $result = $api_instance->deleteTrainedModel($modelUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainedModelApi->deleteTrainedModel: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainedModelApi;

my $api_instance = WWW::SwaggerClient::TrainedModelApi->new();
my $modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | model name or uuid

eval { 
    my $result = $api_instance->deleteTrainedModel(modelUuid => $modelUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainedModelApi->deleteTrainedModel: $@\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.TrainedModelApi()
modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | model name or uuid

try: 
    # Delete trained model
    api_response = api_instance.delete_trained_model(modelUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainedModelApi->deleteTrainedModel: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainedModelApi;

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

public class TrainedModelApiExample {

    public static void main(String[] args) {
        
        TrainedModelApi apiInstance = new TrainedModelApi();
        UUID modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid
        try {
            byte[] result = apiInstance.downloadTrainedModel(modelUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainedModelApi#downloadTrainedModel");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TrainedModelApi;

public class TrainedModelApiExample {

    public static void main(String[] args) {
        TrainedModelApi apiInstance = new TrainedModelApi();
        UUID modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid
        try {
            byte[] result = apiInstance.downloadTrainedModel(modelUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainedModelApi#downloadTrainedModel");
            e.printStackTrace();
        }
    }
}

UUID *modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // model name or uuid

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

// Download trained model
[apiInstance downloadTrainedModelWith:modelUuid
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainedModelApi()
var modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} model name or uuid

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.downloadTrainedModel(modelUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class downloadTrainedModelExample
    {
        public void main()
        {

            var apiInstance = new TrainedModelApi();
            var modelUuid = new UUID(); // UUID | model name or uuid

            try
            {
                // Download trained model
                byte[] result = apiInstance.downloadTrainedModel(modelUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainedModelApi.downloadTrainedModel: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainedModelApi();
$modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid

try {
    $result = $api_instance->downloadTrainedModel($modelUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainedModelApi->downloadTrainedModel: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainedModelApi;

my $api_instance = WWW::SwaggerClient::TrainedModelApi->new();
my $modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | model name or uuid

eval { 
    my $result = $api_instance->downloadTrainedModel(modelUuid => $modelUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainedModelApi->downloadTrainedModel: $@\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.TrainedModelApi()
modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | model name or uuid

try: 
    # Download trained model
    api_response = api_instance.download_trained_model(modelUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainedModelApi->downloadTrainedModel: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainedModelApi;

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

public class TrainedModelApiExample {

    public static void main(String[] args) {
        
        TrainedModelApi apiInstance = new TrainedModelApi();
        UUID modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid
        try {
            TrainedModel result = apiInstance.getTrainedModel(modelUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainedModelApi#getTrainedModel");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TrainedModelApi;

public class TrainedModelApiExample {

    public static void main(String[] args) {
        TrainedModelApi apiInstance = new TrainedModelApi();
        UUID modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid
        try {
            TrainedModel result = apiInstance.getTrainedModel(modelUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainedModelApi#getTrainedModel");
            e.printStackTrace();
        }
    }
}

UUID *modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // model name or uuid

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

// Get trained model description
[apiInstance getTrainedModelWith:modelUuid
              completionHandler: ^(TrainedModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainedModelApi()
var modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} model name or uuid

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTrainedModel(modelUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTrainedModelExample
    {
        public void main()
        {

            var apiInstance = new TrainedModelApi();
            var modelUuid = new UUID(); // UUID | model name or uuid

            try
            {
                // Get trained model description
                TrainedModel result = apiInstance.getTrainedModel(modelUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainedModelApi.getTrainedModel: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainedModelApi();
$modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid

try {
    $result = $api_instance->getTrainedModel($modelUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainedModelApi->getTrainedModel: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainedModelApi;

my $api_instance = WWW::SwaggerClient::TrainedModelApi->new();
my $modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | model name or uuid

eval { 
    my $result = $api_instance->getTrainedModel(modelUuid => $modelUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainedModelApi->getTrainedModel: $@\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.TrainedModelApi()
modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | model name or uuid

try: 
    # Get trained model description
    api_response = api_instance.get_trained_model(modelUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainedModelApi->getTrainedModel: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainedModelApi;

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

public class TrainedModelApiExample {

    public static void main(String[] args) {
        
        TrainedModelApi apiInstance = new TrainedModelApi();
        UUID modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid
        try {
            TrainedModelConfig result = apiInstance.getTrainedModelConfig(modelUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainedModelApi#getTrainedModelConfig");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TrainedModelApi;

public class TrainedModelApiExample {

    public static void main(String[] args) {
        TrainedModelApi apiInstance = new TrainedModelApi();
        UUID modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid
        try {
            TrainedModelConfig result = apiInstance.getTrainedModelConfig(modelUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainedModelApi#getTrainedModelConfig");
            e.printStackTrace();
        }
    }
}

UUID *modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // model name or uuid

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

// Get the config for a trained model
[apiInstance getTrainedModelConfigWith:modelUuid
              completionHandler: ^(TrainedModelConfig output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainedModelApi()
var modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} model name or uuid

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTrainedModelConfig(modelUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTrainedModelConfigExample
    {
        public void main()
        {

            var apiInstance = new TrainedModelApi();
            var modelUuid = new UUID(); // UUID | model name or uuid

            try
            {
                // Get the config for a trained model
                TrainedModelConfig result = apiInstance.getTrainedModelConfig(modelUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainedModelApi.getTrainedModelConfig: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainedModelApi();
$modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid

try {
    $result = $api_instance->getTrainedModelConfig($modelUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainedModelApi->getTrainedModelConfig: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainedModelApi;

my $api_instance = WWW::SwaggerClient::TrainedModelApi->new();
my $modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | model name or uuid

eval { 
    my $result = $api_instance->getTrainedModelConfig(modelUuid => $modelUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainedModelApi->getTrainedModelConfig: $@\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.TrainedModelApi()
modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | model name or uuid

try: 
    # Get the config for a trained model
    api_response = api_instance.get_trained_model_config(modelUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainedModelApi->getTrainedModelConfig: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainedModelApi;

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

public class TrainedModelApiExample {

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

import io.swagger.client.api.TrainedModelApi;

public class TrainedModelApiExample {

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

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

// List models
[apiInstance listTrainedModelsWithCompletionHandler: 
              ^(array[TrainedModel] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainedModelApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listTrainedModels(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listTrainedModelsExample
    {
        public void main()
        {

            var apiInstance = new TrainedModelApi();

            try
            {
                // List models
                array[TrainedModel] result = apiInstance.listTrainedModels();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainedModelApi.listTrainedModels: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainedModelApi();

try {
    $result = $api_instance->listTrainedModels();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainedModelApi->listTrainedModels: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainedModelApi;

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

eval { 
    my $result = $api_instance->listTrainedModels();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainedModelApi->listTrainedModels: $@\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.TrainedModelApi()

try: 
    # List models
    api_response = api_instance.list_trained_models()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainedModelApi->listTrainedModels: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainingApi;

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

public class TrainingApiExample {

    public static void main(String[] args) {
        
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            inline_response_200 result = apiInstance.apiTrainingJobUuidDelete(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#apiTrainingJobUuidDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TrainingApi;

public class TrainingApiExample {

    public static void main(String[] args) {
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            inline_response_200 result = apiInstance.apiTrainingJobUuidDelete(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#apiTrainingJobUuidDelete");
            e.printStackTrace();
        }
    }
}

UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// Delete a training job
[apiInstance apiTrainingJobUuidDeleteWith:jobUuid
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainingApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiTrainingJobUuidDelete(jobUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiTrainingJobUuidDeleteExample
    {
        public void main()
        {

            var apiInstance = new TrainingApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // Delete a training job
                inline_response_200 result = apiInstance.apiTrainingJobUuidDelete(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainingApi.apiTrainingJobUuidDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainingApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->apiTrainingJobUuidDelete($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainingApi->apiTrainingJobUuidDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainingApi;

my $api_instance = WWW::SwaggerClient::TrainingApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->apiTrainingJobUuidDelete(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainingApi->apiTrainingJobUuidDelete: $@\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.TrainingApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # Delete a training job
    api_response = api_instance.api_training_job_uuid_delete(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainingApi->apiTrainingJobUuidDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainingApi;

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

public class TrainingApiExample {

    public static void main(String[] args) {
        
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Checkpoints result = apiInstance.getTrainingCheckpoints(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#getTrainingCheckpoints");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TrainingApi;

public class TrainingApiExample {

    public static void main(String[] args) {
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Checkpoints result = apiInstance.getTrainingCheckpoints(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#getTrainingCheckpoints");
            e.printStackTrace();
        }
    }
}

UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// Get training checkpoints
[apiInstance getTrainingCheckpointsWith:jobUuid
              completionHandler: ^(Checkpoints output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainingApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTrainingCheckpoints(jobUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTrainingCheckpointsExample
    {
        public void main()
        {

            var apiInstance = new TrainingApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // Get training checkpoints
                Checkpoints result = apiInstance.getTrainingCheckpoints(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainingApi.getTrainingCheckpoints: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainingApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getTrainingCheckpoints($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainingApi->getTrainingCheckpoints: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainingApi;

my $api_instance = WWW::SwaggerClient::TrainingApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->getTrainingCheckpoints(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainingApi->getTrainingCheckpoints: $@\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.TrainingApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # Get training checkpoints
    api_response = api_instance.get_training_checkpoints(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainingApi->getTrainingCheckpoints: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainingApi;

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

public class TrainingApiExample {

    public static void main(String[] args) {
        
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            obj result = apiInstance.getTrainingConfig(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#getTrainingConfig");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TrainingApi;

public class TrainingApiExample {

    public static void main(String[] args) {
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            obj result = apiInstance.getTrainingConfig(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#getTrainingConfig");
            e.printStackTrace();
        }
    }
}

UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// Get training config
[apiInstance getTrainingConfigWith:jobUuid
              completionHandler: ^(obj output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainingApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTrainingConfig(jobUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTrainingConfigExample
    {
        public void main()
        {

            var apiInstance = new TrainingApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // Get training config
                obj result = apiInstance.getTrainingConfig(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainingApi.getTrainingConfig: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainingApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getTrainingConfig($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainingApi->getTrainingConfig: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainingApi;

my $api_instance = WWW::SwaggerClient::TrainingApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->getTrainingConfig(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainingApi->getTrainingConfig: $@\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.TrainingApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # Get training config
    api_response = api_instance.get_training_config(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainingApi->getTrainingConfig: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainingApi;

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

public class TrainingApiExample {

    public static void main(String[] args) {
        
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Training result = apiInstance.getTrainingJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#getTrainingJob");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TrainingApi;

public class TrainingApiExample {

    public static void main(String[] args) {
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Training result = apiInstance.getTrainingJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#getTrainingJob");
            e.printStackTrace();
        }
    }
}

UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// Get training job info
[apiInstance getTrainingJobWith:jobUuid
              completionHandler: ^(Training output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainingApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTrainingJob(jobUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTrainingJobExample
    {
        public void main()
        {

            var apiInstance = new TrainingApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // Get training job info
                Training result = apiInstance.getTrainingJob(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainingApi.getTrainingJob: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainingApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getTrainingJob($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainingApi->getTrainingJob: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainingApi;

my $api_instance = WWW::SwaggerClient::TrainingApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->getTrainingJob(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainingApi->getTrainingJob: $@\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.TrainingApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # Get training job info
    api_response = api_instance.get_training_job(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainingApi->getTrainingJob: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainingApi;

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

public class TrainingApiExample {

    public static void main(String[] args) {
        
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Logs result = apiInstance.getTrainingLog(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#getTrainingLog");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TrainingApi;

public class TrainingApiExample {

    public static void main(String[] args) {
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Logs result = apiInstance.getTrainingLog(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#getTrainingLog");
            e.printStackTrace();
        }
    }
}

UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// Get training logs
[apiInstance getTrainingLogWith:jobUuid
              completionHandler: ^(Logs output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainingApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTrainingLog(jobUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTrainingLogExample
    {
        public void main()
        {

            var apiInstance = new TrainingApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // Get training logs
                Logs result = apiInstance.getTrainingLog(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainingApi.getTrainingLog: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainingApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getTrainingLog($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainingApi->getTrainingLog: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainingApi;

my $api_instance = WWW::SwaggerClient::TrainingApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->getTrainingLog(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainingApi->getTrainingLog: $@\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.TrainingApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # Get training logs
    api_response = api_instance.get_training_log(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainingApi->getTrainingLog: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainingApi;

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

public class TrainingApiExample {

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

import io.swagger.client.api.TrainingApi;

public class TrainingApiExample {

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

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

// List training jobs
[apiInstance listTrainingJobsWithCompletionHandler: 
              ^(array[Training] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainingApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listTrainingJobs(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listTrainingJobsExample
    {
        public void main()
        {

            var apiInstance = new TrainingApi();

            try
            {
                // List training jobs
                array[Training] result = apiInstance.listTrainingJobs();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainingApi.listTrainingJobs: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainingApi();

try {
    $result = $api_instance->listTrainingJobs();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainingApi->listTrainingJobs: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainingApi;

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

eval { 
    my $result = $api_instance->listTrainingJobs();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainingApi->listTrainingJobs: $@\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.TrainingApi()

try: 
    # List training jobs
    api_response = api_instance.list_training_jobs()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainingApi->listTrainingJobs: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainingApi;

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

public class TrainingApiExample {

    public static void main(String[] args) {
        
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Training result = apiInstance.restartTrainingJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#restartTrainingJob");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TrainingApi;

public class TrainingApiExample {

    public static void main(String[] args) {
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Training result = apiInstance.restartTrainingJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#restartTrainingJob");
            e.printStackTrace();
        }
    }
}

UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// restart a training job
[apiInstance restartTrainingJobWith:jobUuid
              completionHandler: ^(Training output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainingApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.restartTrainingJob(jobUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class restartTrainingJobExample
    {
        public void main()
        {

            var apiInstance = new TrainingApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // restart a training job
                Training result = apiInstance.restartTrainingJob(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainingApi.restartTrainingJob: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainingApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->restartTrainingJob($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainingApi->restartTrainingJob: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainingApi;

my $api_instance = WWW::SwaggerClient::TrainingApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->restartTrainingJob(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainingApi->restartTrainingJob: $@\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.TrainingApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # restart a training job
    api_response = api_instance.restart_training_job(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainingApi->restartTrainingJob: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainingApi;

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

public class TrainingApiExample {

    public static void main(String[] args) {
        
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            TrainedModel result = apiInstance.saveTrainedModelFromTraining(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#saveTrainedModelFromTraining");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TrainingApi;

public class TrainingApiExample {

    public static void main(String[] args) {
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            TrainedModel result = apiInstance.saveTrainedModelFromTraining(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#saveTrainedModelFromTraining");
            e.printStackTrace();
        }
    }
}

UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// Create a trained model from latest checkpoint.
[apiInstance saveTrainedModelFromTrainingWith:jobUuid
              completionHandler: ^(TrainedModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainingApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.saveTrainedModelFromTraining(jobUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class saveTrainedModelFromTrainingExample
    {
        public void main()
        {

            var apiInstance = new TrainingApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // Create a trained model from latest checkpoint.
                TrainedModel result = apiInstance.saveTrainedModelFromTraining(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainingApi.saveTrainedModelFromTraining: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainingApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->saveTrainedModelFromTraining($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainingApi->saveTrainedModelFromTraining: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainingApi;

my $api_instance = WWW::SwaggerClient::TrainingApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->saveTrainedModelFromTraining(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainingApi->saveTrainedModelFromTraining: $@\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.TrainingApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # Create a trained model from latest checkpoint.
    api_response = api_instance.save_trained_model_from_training(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainingApi->saveTrainedModelFromTraining: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainingApi;

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

public class TrainingApiExample {

    public static void main(String[] args) {
        
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Training result = apiInstance.stopTrainingJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#stopTrainingJob");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TrainingApi;

public class TrainingApiExample {

    public static void main(String[] args) {
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Training result = apiInstance.stopTrainingJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#stopTrainingJob");
            e.printStackTrace();
        }
    }
}

UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// stop a training job
[apiInstance stopTrainingJobWith:jobUuid
              completionHandler: ^(Training output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainingApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.stopTrainingJob(jobUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class stopTrainingJobExample
    {
        public void main()
        {

            var apiInstance = new TrainingApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // stop a training job
                Training result = apiInstance.stopTrainingJob(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainingApi.stopTrainingJob: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainingApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->stopTrainingJob($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainingApi->stopTrainingJob: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainingApi;

my $api_instance = WWW::SwaggerClient::TrainingApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->stopTrainingJob(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainingApi->stopTrainingJob: $@\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.TrainingApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # stop a training job
    api_response = api_instance.stop_training_job(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainingApi->stopTrainingJob: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainingApi;

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

public class TrainingApiExample {

    public static void main(String[] args) {
        
        TrainingApi apiInstance = new TrainingApi();
        Training body = ; // Training | 
        try {
            Training result = apiInstance.submitTrainingJob(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#submitTrainingJob");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TrainingApi;

public class TrainingApiExample {

    public static void main(String[] args) {
        TrainingApi apiInstance = new TrainingApi();
        Training body = ; // Training | 
        try {
            Training result = apiInstance.submitTrainingJob(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#submitTrainingJob");
            e.printStackTrace();
        }
    }
}

Training *body = ; // 

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

// Submit a training Job
[apiInstance submitTrainingJobWith:body
              completionHandler: ^(Training output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainingApi()
var body = ; // {{Training}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.submitTrainingJob(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class submitTrainingJobExample
    {
        public void main()
        {

            var apiInstance = new TrainingApi();
            var body = new Training(); // Training | 

            try
            {
                // Submit a training Job
                Training result = apiInstance.submitTrainingJob(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainingApi.submitTrainingJob: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainingApi();
$body = ; // Training | 

try {
    $result = $api_instance->submitTrainingJob($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainingApi->submitTrainingJob: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainingApi;

my $api_instance = WWW::SwaggerClient::TrainingApi->new();
my $body = WWW::SwaggerClient::Object::Training->new(); # Training | 

eval { 
    my $result = $api_instance->submitTrainingJob(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainingApi->submitTrainingJob: $@\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.TrainingApi()
body =  # Training | 

try: 
    # Submit a training Job
    api_response = api_instance.submit_training_job(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainingApi->submitTrainingJob: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

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

public class UserApiExample {

    public static void main(String[] args) {
        
        UserApi apiInstance = new UserApi();
        UUID userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            inline_response_200_4 result = apiInstance.deleteUser(userUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#deleteUser");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UserApi;

public class UserApiExample {

    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        UUID userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            inline_response_200_4 result = apiInstance.deleteUser(userUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#deleteUser");
            e.printStackTrace();
        }
    }
}

UUID *userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// delete a user
[apiInstance deleteUserWith:userUuid
              completionHandler: ^(inline_response_200_4 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.UserApi()
var userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteUser(userUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteUserExample
    {
        public void main()
        {

            var apiInstance = new UserApi();
            var userUuid = new UUID(); // UUID | 

            try
            {
                // delete a user
                inline_response_200_4 result = apiInstance.deleteUser(userUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.deleteUser: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiUserApi();
$userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->deleteUser($userUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserApi->deleteUser: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->deleteUser(userUuid => $userUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->deleteUser: $@\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.UserApi()
userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # delete a user
    api_response = api_instance.delete_user(userUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->deleteUser: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

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

public class UserApiExample {

    public static void main(String[] args) {
        
        UserApi apiInstance = new UserApi();
        UUID userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            User result = apiInstance.getUser(userUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#getUser");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UserApi;

public class UserApiExample {

    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        UUID userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            User result = apiInstance.getUser(userUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#getUser");
            e.printStackTrace();
        }
    }
}

UUID *userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// get info about a user
[apiInstance getUserWith:userUuid
              completionHandler: ^(User output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.UserApi()
var userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUser(userUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getUserExample
    {
        public void main()
        {

            var apiInstance = new UserApi();
            var userUuid = new UUID(); // UUID | 

            try
            {
                // get info about a user
                User result = apiInstance.getUser(userUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.getUser: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiUserApi();
$userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getUser($userUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserApi->getUser: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->getUser(userUuid => $userUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->getUser: $@\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.UserApi()
userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # get info about a user
    api_response = api_instance.get_user(userUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->getUser: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

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

public class UserApiExample {

    public static void main(String[] args) {
        
        UserApi apiInstance = new UserApi();
        UUID userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Role result = apiInstance.getUserRole(userUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#getUserRole");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UserApi;

public class UserApiExample {

    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        UUID userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Role result = apiInstance.getUserRole(userUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#getUserRole");
            e.printStackTrace();
        }
    }
}

UUID *userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// get info about a user role
[apiInstance getUserRoleWith:userUuid
              completionHandler: ^(Role output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.UserApi()
var userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUserRole(userUuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getUserRoleExample
    {
        public void main()
        {

            var apiInstance = new UserApi();
            var userUuid = new UUID(); // UUID | 

            try
            {
                // get info about a user role
                Role result = apiInstance.getUserRole(userUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.getUserRole: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiUserApi();
$userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getUserRole($userUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserApi->getUserRole: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->getUserRole(userUuid => $userUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->getUserRole: $@\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.UserApi()
userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # get info about a user role
    api_response = api_instance.get_user_role(userUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->getUserRole: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

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

public class UserApiExample {

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

import io.swagger.client.api.UserApi;

public class UserApiExample {

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

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

// get usage info about authenticated user
[apiInstance getUserUsageWithCompletionHandler: 
              ^(Usage output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.UserApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUserUsage(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getUserUsageExample
    {
        public void main()
        {

            var apiInstance = new UserApi();

            try
            {
                // get usage info about authenticated user
                Usage result = apiInstance.getUserUsage();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.getUserUsage: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiUserApi();

try {
    $result = $api_instance->getUserUsage();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserApi->getUserUsage: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

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

eval { 
    my $result = $api_instance->getUserUsage();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->getUserUsage: $@\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.UserApi()

try: 
    # get usage info about authenticated user
    api_response = api_instance.get_user_usage()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->getUserUsage: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

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

public class UserApiExample {

    public static void main(String[] args) {
        
        UserApi apiInstance = new UserApi();
        User body = ; // User | 
        try {
            User result = apiInstance.login(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#login");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UserApi;

public class UserApiExample {

    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        User body = ; // User | 
        try {
            User result = apiInstance.login(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#login");
            e.printStackTrace();
        }
    }
}

User *body = ; // 

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

// user login
[apiInstance loginWith:body
              completionHandler: ^(User output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.UserApi()
var body = ; // {{User}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.login(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class loginExample
    {
        public void main()
        {

            var apiInstance = new UserApi();
            var body = new User(); // User | 

            try
            {
                // user login
                User result = apiInstance.login(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.login: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiUserApi();
$body = ; // User | 

try {
    $result = $api_instance->login($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserApi->login: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $body = WWW::SwaggerClient::Object::User->new(); # User | 

eval { 
    my $result = $api_instance->login(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->login: $@\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.UserApi()
body =  # User | 

try: 
    # user login
    api_response = api_instance.login(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->login: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

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

public class UserApiExample {

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

import io.swagger.client.api.UserApi;

public class UserApiExample {

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

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

// logout user
[apiInstance logoutWithCompletionHandler: 
              ^(inline_response_200_2 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.UserApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.logout(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class logoutExample
    {
        public void main()
        {

            var apiInstance = new UserApi();

            try
            {
                // logout user
                inline_response_200_2 result = apiInstance.logout();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.logout: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiUserApi();

try {
    $result = $api_instance->logout();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserApi->logout: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

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

eval { 
    my $result = $api_instance->logout();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->logout: $@\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.UserApi()

try: 
    # logout user
    api_response = api_instance.logout()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->logout: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

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

public class UserApiExample {

    public static void main(String[] args) {
        
        UserApi apiInstance = new UserApi();
        Body_4 body = ; // Body_4 | 
        String token = token_example; // String | 
        try {
            inline_response_200_3 result = apiInstance.passwordReset(body, token);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#passwordReset");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UserApi;

public class UserApiExample {

    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        Body_4 body = ; // Body_4 | 
        String token = token_example; // String | 
        try {
            inline_response_200_3 result = apiInstance.passwordReset(body, token);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#passwordReset");
            e.printStackTrace();
        }
    }
}

Body_4 *body = ; // 
String *token = token_example; // 

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

// send password reset email
[apiInstance passwordResetWith:body
    token:token
              completionHandler: ^(inline_response_200_3 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.UserApi()
var body = ; // {{Body_4}} 
var token = token_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.passwordReset(bodytoken, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class passwordResetExample
    {
        public void main()
        {

            var apiInstance = new UserApi();
            var body = new Body_4(); // Body_4 | 
            var token = token_example;  // String | 

            try
            {
                // send password reset email
                inline_response_200_3 result = apiInstance.passwordReset(body, token);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.passwordReset: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiUserApi();
$body = ; // Body_4 | 
$token = token_example; // String | 

try {
    $result = $api_instance->passwordReset($body, $token);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserApi->passwordReset: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $body = WWW::SwaggerClient::Object::Body_4->new(); # Body_4 | 
my $token = token_example; # String | 

eval { 
    my $result = $api_instance->passwordReset(body => $body, token => $token);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->passwordReset: $@\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.UserApi()
body =  # Body_4 | 
token = token_example # String | 

try: 
    # send password reset email
    api_response = api_instance.password_reset(body, token)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->passwordReset: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

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

public class UserApiExample {

    public static void main(String[] args) {
        
        UserApi apiInstance = new UserApi();
        User body = ; // User | 
        try {
            inline_response_200_3 result = apiInstance.register(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#register");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UserApi;

public class UserApiExample {

    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        User body = ; // User | 
        try {
            inline_response_200_3 result = apiInstance.register(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#register");
            e.printStackTrace();
        }
    }
}

User *body = ; // 

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

// user registration
[apiInstance registerWith:body
              completionHandler: ^(inline_response_200_3 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.UserApi()
var body = ; // {{User}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.register(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class registerExample
    {
        public void main()
        {

            var apiInstance = new UserApi();
            var body = new User(); // User | 

            try
            {
                // user registration
                inline_response_200_3 result = apiInstance.register(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.register: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiUserApi();
$body = ; // User | 

try {
    $result = $api_instance->register($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserApi->register: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $body = WWW::SwaggerClient::Object::User->new(); # User | 

eval { 
    my $result = $api_instance->register(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->register: $@\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.UserApi()
body =  # User | 

try: 
    # user registration
    api_response = api_instance.register(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->register: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

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

public class UserApiExample {

    public static void main(String[] args) {
        
        UserApi apiInstance = new UserApi();
        Body_5 body = ; // Body_5 | 
        try {
            inline_response_200_3 result = apiInstance.requestUpgrade(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#requestUpgrade");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UserApi;

public class UserApiExample {

    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        Body_5 body = ; // Body_5 | 
        try {
            inline_response_200_3 result = apiInstance.requestUpgrade(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#requestUpgrade");
            e.printStackTrace();
        }
    }
}

Body_5 *body = ; // 

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

// request for upgrade of user account
[apiInstance requestUpgradeWith:body
              completionHandler: ^(inline_response_200_3 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.UserApi()
var body = ; // {{Body_5}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.requestUpgrade(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class requestUpgradeExample
    {
        public void main()
        {

            var apiInstance = new UserApi();
            var body = new Body_5(); // Body_5 | 

            try
            {
                // request for upgrade of user account
                inline_response_200_3 result = apiInstance.requestUpgrade(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.requestUpgrade: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiUserApi();
$body = ; // Body_5 | 

try {
    $result = $api_instance->requestUpgrade($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserApi->requestUpgrade: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $body = WWW::SwaggerClient::Object::Body_5->new(); # Body_5 | 

eval { 
    my $result = $api_instance->requestUpgrade(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->requestUpgrade: $@\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.UserApi()
body =  # Body_5 | 

try: 
    # request for upgrade of user account
    api_response = api_instance.request_upgrade(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->requestUpgrade: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

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

public class UserApiExample {

    public static void main(String[] args) {
        
        UserApi apiInstance = new UserApi();
        Body_2 body = ; // Body_2 | 
        try {
            inline_response_200_3 result = apiInstance.resendActivation(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#resendActivation");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UserApi;

public class UserApiExample {

    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        Body_2 body = ; // Body_2 | 
        try {
            inline_response_200_3 result = apiInstance.resendActivation(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#resendActivation");
            e.printStackTrace();
        }
    }
}

Body_2 *body = ; // 

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

// resend activation email
[apiInstance resendActivationWith:body
              completionHandler: ^(inline_response_200_3 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.UserApi()
var body = ; // {{Body_2}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.resendActivation(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class resendActivationExample
    {
        public void main()
        {

            var apiInstance = new UserApi();
            var body = new Body_2(); // Body_2 | 

            try
            {
                // resend activation email
                inline_response_200_3 result = apiInstance.resendActivation(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.resendActivation: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiUserApi();
$body = ; // Body_2 | 

try {
    $result = $api_instance->resendActivation($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserApi->resendActivation: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $body = WWW::SwaggerClient::Object::Body_2->new(); # Body_2 | 

eval { 
    my $result = $api_instance->resendActivation(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->resendActivation: $@\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.UserApi()
body =  # Body_2 | 

try: 
    # resend activation email
    api_response = api_instance.resend_activation(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->resendActivation: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

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

public class UserApiExample {

    public static void main(String[] args) {
        
        UserApi apiInstance = new UserApi();
        Body_3 body = ; // Body_3 | 
        try {
            inline_response_200_3 result = apiInstance.sendPasswordReset(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#sendPasswordReset");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UserApi;

public class UserApiExample {

    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        Body_3 body = ; // Body_3 | 
        try {
            inline_response_200_3 result = apiInstance.sendPasswordReset(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#sendPasswordReset");
            e.printStackTrace();
        }
    }
}

Body_3 *body = ; // 

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

// send password reset email
[apiInstance sendPasswordResetWith:body
              completionHandler: ^(inline_response_200_3 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.UserApi()
var body = ; // {{Body_3}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.sendPasswordReset(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class sendPasswordResetExample
    {
        public void main()
        {

            var apiInstance = new UserApi();
            var body = new Body_3(); // Body_3 | 

            try
            {
                // send password reset email
                inline_response_200_3 result = apiInstance.sendPasswordReset(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.sendPasswordReset: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiUserApi();
$body = ; // Body_3 | 

try {
    $result = $api_instance->sendPasswordReset($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserApi->sendPasswordReset: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $body = WWW::SwaggerClient::Object::Body_3->new(); # Body_3 | 

eval { 
    my $result = $api_instance->sendPasswordReset(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->sendPasswordReset: $@\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.UserApi()
body =  # Body_3 | 

try: 
    # send password reset email
    api_response = api_instance.send_password_reset(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->sendPasswordReset: %s\n" % e)