uCentral Firmware Service API

ConnectedDevices

getConnectedDevice

Get status of a connected device.

/connectedDevice/{serialNumber}

Usage and SDK Samples

curl -X GET \
-H "X-API-KEY: [[apiKey]]" \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://localhost:16003/api/v1/connectedDevice/{serialNumber}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ConnectedDevicesApi;

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

public class ConnectedDevicesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        ConnectedDevicesApi apiInstance = new ConnectedDevicesApi();
        String serialNumber = serialNumber_example; // String | SerialNumber of the device

        try {
            DeviceConnectionInformation result = apiInstance.getConnectedDevice(serialNumber);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectedDevicesApi#getConnectedDevice");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ConnectedDevicesApi;

public class ConnectedDevicesApiExample {
    public static void main(String[] args) {
        ConnectedDevicesApi apiInstance = new ConnectedDevicesApi();
        String serialNumber = serialNumber_example; // String | SerialNumber of the device

        try {
            DeviceConnectionInformation result = apiInstance.getConnectedDevice(serialNumber);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectedDevicesApi#getConnectedDevice");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ConnectedDevicesApi *apiInstance = [[ConnectedDevicesApi alloc] init];
String *serialNumber = serialNumber_example; // SerialNumber of the device (default to null)

// Get status of a connected device.
[apiInstance getConnectedDeviceWith:serialNumber
              completionHandler: ^(DeviceConnectionInformation output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var UCentralFirmwareServiceApi = require('u_central_firmware_service_api');
var defaultClient = UCentralFirmwareServiceApi.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new UCentralFirmwareServiceApi.ConnectedDevicesApi()
var serialNumber = serialNumber_example; // {String} SerialNumber of the device

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getConnectedDeviceExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new ConnectedDevicesApi();
            var serialNumber = serialNumber_example;  // String | SerialNumber of the device (default to null)

            try {
                // Get status of a connected device.
                DeviceConnectionInformation result = apiInstance.getConnectedDevice(serialNumber);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectedDevicesApi.getConnectedDevice: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectedDevicesApi();
$serialNumber = serialNumber_example; // String | SerialNumber of the device

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ConnectedDevicesApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConnectedDevicesApi->new();
my $serialNumber = serialNumber_example; # String | SerialNumber of the device

eval {
    my $result = $api_instance->getConnectedDevice(serialNumber => $serialNumber);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ConnectedDevicesApi->getConnectedDevice: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ConnectedDevicesApi()
serialNumber = serialNumber_example # String | SerialNumber of the device (default to null)

try:
    # Get status of a connected device.
    api_response = api_instance.get_connected_device(serialNumber)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectedDevicesApi->getConnectedDevice: %s\n" % e)

extern crate ConnectedDevicesApi;

pub fn main() {
    let serialNumber = serialNumber_example; // String

    let mut context = ConnectedDevicesApi::Context::default();
    let result = client.getConnectedDevice(serialNumber, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
serialNumber*	String SerialNumber of the device Required

Responses

Schema

getConnectedDevices

Get a list of connected devices and some values.

/connectedDevices

Usage and SDK Samples

curl -X GET \
-H "X-API-KEY: [[apiKey]]" \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://localhost:16003/api/v1/connectedDevices?offset=56&limit=56&filter=filter_example"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ConnectedDevicesApi;

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

public class ConnectedDevicesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        ConnectedDevicesApi apiInstance = new ConnectedDevicesApi();
        Integer offset = 56; // Integer | Pagination start (starts at 1. If not specified, 1 is assumed)
        Integer limit = 56; // Integer | Maximum number of entries to return (if absent, no limit is assumed)
        String filter = filter_example; // String | Filter the results

        try {
            DeviceConnectionInformationList result = apiInstance.getConnectedDevices(offset, limit, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectedDevicesApi#getConnectedDevices");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ConnectedDevicesApi;

public class ConnectedDevicesApiExample {
    public static void main(String[] args) {
        ConnectedDevicesApi apiInstance = new ConnectedDevicesApi();
        Integer offset = 56; // Integer | Pagination start (starts at 1. If not specified, 1 is assumed)
        Integer limit = 56; // Integer | Maximum number of entries to return (if absent, no limit is assumed)
        String filter = filter_example; // String | Filter the results

        try {
            DeviceConnectionInformationList result = apiInstance.getConnectedDevices(offset, limit, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectedDevicesApi#getConnectedDevices");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ConnectedDevicesApi *apiInstance = [[ConnectedDevicesApi alloc] init];
Integer *offset = 56; // Pagination start (starts at 1. If not specified, 1 is assumed) (optional) (default to null)
Integer *limit = 56; // Maximum number of entries to return (if absent, no limit is assumed) (optional) (default to null)
String *filter = filter_example; // Filter the results (optional) (default to null)

// Get a list of connected devices and some values.
[apiInstance getConnectedDevicesWith:offset
    limit:limit
    filter:filter
              completionHandler: ^(DeviceConnectionInformationList output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var UCentralFirmwareServiceApi = require('u_central_firmware_service_api');
var defaultClient = UCentralFirmwareServiceApi.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new UCentralFirmwareServiceApi.ConnectedDevicesApi()
var opts = {
  'offset': 56, // {Integer} Pagination start (starts at 1. If not specified, 1 is assumed)
  'limit': 56, // {Integer} Maximum number of entries to return (if absent, no limit is assumed)
  'filter': filter_example // {String} Filter the results
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getConnectedDevicesExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new ConnectedDevicesApi();
            var offset = 56;  // Integer | Pagination start (starts at 1. If not specified, 1 is assumed) (optional)  (default to null)
            var limit = 56;  // Integer | Maximum number of entries to return (if absent, no limit is assumed) (optional)  (default to null)
            var filter = filter_example;  // String | Filter the results (optional)  (default to null)

            try {
                // Get a list of connected devices and some values.
                DeviceConnectionInformationList result = apiInstance.getConnectedDevices(offset, limit, filter);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectedDevicesApi.getConnectedDevices: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectedDevicesApi();
$offset = 56; // Integer | Pagination start (starts at 1. If not specified, 1 is assumed)
$limit = 56; // Integer | Maximum number of entries to return (if absent, no limit is assumed)
$filter = filter_example; // String | Filter the results

try {
    $result = $api_instance->getConnectedDevices($offset, $limit, $filter);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ConnectedDevicesApi->getConnectedDevices: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ConnectedDevicesApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConnectedDevicesApi->new();
my $offset = 56; # Integer | Pagination start (starts at 1. If not specified, 1 is assumed)
my $limit = 56; # Integer | Maximum number of entries to return (if absent, no limit is assumed)
my $filter = filter_example; # String | Filter the results

eval {
    my $result = $api_instance->getConnectedDevices(offset => $offset, limit => $limit, filter => $filter);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ConnectedDevicesApi->getConnectedDevices: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ConnectedDevicesApi()
offset = 56 # Integer | Pagination start (starts at 1. If not specified, 1 is assumed) (optional) (default to null)
limit = 56 # Integer | Maximum number of entries to return (if absent, no limit is assumed) (optional) (default to null)
filter = filter_example # String | Filter the results (optional) (default to null)

try:
    # Get a list of connected devices and some values.
    api_response = api_instance.get_connected_devices(offset=offset, limit=limit, filter=filter)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectedDevicesApi->getConnectedDevices: %s\n" % e)

extern crate ConnectedDevicesApi;

pub fn main() {
    let offset = 56; // Integer
    let limit = 56; // Integer
    let filter = filter_example; // String

    let mut context = ConnectedDevicesApi::Context::default();
    let result = client.getConnectedDevices(offset, limit, filter, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters

Name	Description
offset	Integer Pagination start (starts at 1. If not specified, 1 is assumed)
limit	Integer Maximum number of entries to return (if absent, no limit is assumed)
filter	String Filter the results

Responses

Schema

DeviceInfo

deviceReportGet

get an analysis of the existing devices we know about.

/deviceReport

Usage and SDK Samples

curl -X GET \
-H "X-API-KEY: [[apiKey]]" \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://localhost:16003/api/v1/deviceReport"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DeviceInfoApi;

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

public class DeviceInfoApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        DeviceInfoApi apiInstance = new DeviceInfoApi();

        try {
            DeviceReport result = apiInstance.deviceReportGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeviceInfoApi#deviceReportGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DeviceInfoApi;

public class DeviceInfoApiExample {
    public static void main(String[] args) {
        DeviceInfoApi apiInstance = new DeviceInfoApi();

        try {
            DeviceReport result = apiInstance.deviceReportGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeviceInfoApi#deviceReportGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
DeviceInfoApi *apiInstance = [[DeviceInfoApi alloc] init];

// get an analysis of the existing devices we know about.
[apiInstance deviceReportGetWithCompletionHandler: 
              ^(DeviceReport output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var UCentralFirmwareServiceApi = require('u_central_firmware_service_api');
var defaultClient = UCentralFirmwareServiceApi.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new UCentralFirmwareServiceApi.DeviceInfoApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deviceReportGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deviceReportGetExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DeviceInfoApi();

            try {
                // get an analysis of the existing devices we know about.
                DeviceReport result = apiInstance.deviceReportGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DeviceInfoApi.deviceReportGet: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DeviceInfoApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DeviceInfoApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DeviceInfoApi->new();

eval {
    my $result = $api_instance->deviceReportGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DeviceInfoApi->deviceReportGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DeviceInfoApi()

try:
    # get an analysis of the existing devices we know about.
    api_response = api_instance.device_report_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DeviceInfoApi->deviceReportGet: %s\n" % e)

extern crate DeviceInfoApi;

pub fn main() {

    let mut context = DeviceInfoApi::Context::default();
    let result = client.deviceReportGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Schema

DeviceInformation

deviceInformationSerialNumberGet

receive a repor on a single decide

/deviceInformation/{serialNumber}

Usage and SDK Samples

curl -X GET \
-H "X-API-KEY: [[apiKey]]" \
 -H "Authorization: Bearer [[accessToken]]" \
 "https://localhost:16003/api/v1/deviceInformation/{serialNumber}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DeviceInformationApi;

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

public class DeviceInformationApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        DeviceInformationApi apiInstance = new DeviceInformationApi();
        String serialNumber = aabbccdd1234; // String | 

        try {
            apiInstance.deviceInformationSerialNumberGet(serialNumber);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeviceInformationApi#deviceInformationSerialNumberGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DeviceInformationApi;

public class DeviceInformationApiExample {
    public static void main(String[] args) {
        DeviceInformationApi apiInstance = new DeviceInformationApi();
        String serialNumber = aabbccdd1234; // String | 

        try {
            apiInstance.deviceInformationSerialNumberGet(serialNumber);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeviceInformationApi#deviceInformationSerialNumberGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
DeviceInformationApi *apiInstance = [[DeviceInformationApi alloc] init];
String *serialNumber = aabbccdd1234; //  (default to null)

// receive a repor on a single decide
[apiInstance deviceInformationSerialNumberGetWith:serialNumber
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var UCentralFirmwareServiceApi = require('u_central_firmware_service_api');
var defaultClient = UCentralFirmwareServiceApi.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new UCentralFirmwareServiceApi.DeviceInformationApi()
var serialNumber = aabbccdd1234; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deviceInformationSerialNumberGet(serialNumber, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deviceInformationSerialNumberGetExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DeviceInformationApi();
            var serialNumber = aabbccdd1234;  // String |  (default to null)

            try {
                // receive a repor on a single decide
                apiInstance.deviceInformationSerialNumberGet(serialNumber);
            } catch (Exception e) {
                Debug.Print("Exception when calling DeviceInformationApi.deviceInformationSerialNumberGet: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DeviceInformationApi();
$serialNumber = aabbccdd1234; // String | 

try {
    $api_instance->deviceInformationSerialNumberGet($serialNumber);
} catch (Exception $e) {
    echo 'Exception when calling DeviceInformationApi->deviceInformationSerialNumberGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DeviceInformationApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DeviceInformationApi->new();
my $serialNumber = aabbccdd1234; # String | 

eval {
    $api_instance->deviceInformationSerialNumberGet(serialNumber => $serialNumber);
};
if ($@) {
    warn "Exception when calling DeviceInformationApi->deviceInformationSerialNumberGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DeviceInformationApi()
serialNumber = aabbccdd1234 # String |  (default to null)

try:
    # receive a repor on a single decide
    api_instance.device_information_serial_number_get(serialNumber)
except ApiException as e:
    print("Exception when calling DeviceInformationApi->deviceInformationSerialNumberGet: %s\n" % e)

extern crate DeviceInformationApi;

pub fn main() {
    let serialNumber = aabbccdd1234; // String

    let mut context = DeviceInformationApi::Context::default();
    let result = client.deviceInformationSerialNumberGet(serialNumber, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
serialNumber*	String Required

Responses

Firmware

createFirmware

Create A New firmware

/firmware/{id}

Usage and SDK Samples

curl -X POST \
-H "X-API-KEY: [[apiKey]]" \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://localhost:16003/api/v1/firmware/{id}" \
 -d '{
  "deviceType" : "deviceType",
  "owner" : "owner",
  "image" : "image",
  "notes" : [ {
    "note" : "note",
    "createdBy" : "createdBy",
    "created" : 5
  }, {
    "note" : "note",
    "createdBy" : "createdBy",
    "created" : 5
  } ],
  "firmwareHash" : "firmwareHash",
  "created" : 5,
  "description" : "description",
  "imageDate" : 0,
  "uri" : "https://openapi-generator.tech",
  "revision" : "revision",
  "size" : 6,
  "uploader" : "uploader",
  "digest" : "digest",
  "location" : "https://openapi-generator.tech",
  "id" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "downloadCount" : 1,
  "latest" : true
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.FirmwareApi;

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

public class FirmwareApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        FirmwareApi apiInstance = new FirmwareApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        FirmwareDetails firmwareDetails = ; // FirmwareDetails | 

        try {
            FirmwareDetails result = apiInstance.createFirmware(id, firmwareDetails);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareApi#createFirmware");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.FirmwareApi;

public class FirmwareApiExample {
    public static void main(String[] args) {
        FirmwareApi apiInstance = new FirmwareApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        FirmwareDetails firmwareDetails = ; // FirmwareDetails | 

        try {
            FirmwareDetails result = apiInstance.createFirmware(id, firmwareDetails);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareApi#createFirmware");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
FirmwareApi *apiInstance = [[FirmwareApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
FirmwareDetails *firmwareDetails = ; // 

// Create A New firmware
[apiInstance createFirmwareWith:id
    firmwareDetails:firmwareDetails
              completionHandler: ^(FirmwareDetails output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var UCentralFirmwareServiceApi = require('u_central_firmware_service_api');
var defaultClient = UCentralFirmwareServiceApi.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new UCentralFirmwareServiceApi.FirmwareApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var firmwareDetails = ; // {FirmwareDetails} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class createFirmwareExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new FirmwareApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var firmwareDetails = new FirmwareDetails(); // FirmwareDetails | 

            try {
                // Create A New firmware
                FirmwareDetails result = apiInstance.createFirmware(id, firmwareDetails);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FirmwareApi.createFirmware: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FirmwareApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$firmwareDetails = ; // FirmwareDetails | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::FirmwareApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FirmwareApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $firmwareDetails = WWW::OPenAPIClient::Object::FirmwareDetails->new(); # FirmwareDetails | 

eval {
    my $result = $api_instance->createFirmware(id => $id, firmwareDetails => $firmwareDetails);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FirmwareApi->createFirmware: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.FirmwareApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
firmwareDetails =  # FirmwareDetails | 

try:
    # Create A New firmware
    api_response = api_instance.create_firmware(id, firmwareDetails)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FirmwareApi->createFirmware: %s\n" % e)

extern crate FirmwareApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let firmwareDetails = ; // FirmwareDetails

    let mut context = FirmwareApi::Context::default();
    let result = client.createFirmware(id, firmwareDetails, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
id*	UUID (uuid) Required

Body parameters

Name	Description
firmwareDetails *

Responses

Schema

deleteFirmware

Delete some Firmware

/firmware/{id}

Usage and SDK Samples

curl -X DELETE \
-H "X-API-KEY: [[apiKey]]" \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://localhost:16003/api/v1/firmware/{id}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.FirmwareApi;

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

public class FirmwareApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        FirmwareApi apiInstance = new FirmwareApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            Success result = apiInstance.deleteFirmware(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareApi#deleteFirmware");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.FirmwareApi;

public class FirmwareApiExample {
    public static void main(String[] args) {
        FirmwareApi apiInstance = new FirmwareApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            Success result = apiInstance.deleteFirmware(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareApi#deleteFirmware");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
FirmwareApi *apiInstance = [[FirmwareApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Delete some Firmware
[apiInstance deleteFirmwareWith:id
              completionHandler: ^(Success output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var UCentralFirmwareServiceApi = require('u_central_firmware_service_api');
var defaultClient = UCentralFirmwareServiceApi.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new UCentralFirmwareServiceApi.FirmwareApi()
var id = 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.deleteFirmware(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deleteFirmwareExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new FirmwareApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Delete some Firmware
                Success result = apiInstance.deleteFirmware(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FirmwareApi.deleteFirmware: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FirmwareApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::FirmwareApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FirmwareApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->deleteFirmware(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FirmwareApi->deleteFirmware: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.FirmwareApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Delete some Firmware
    api_response = api_instance.delete_firmware(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FirmwareApi->deleteFirmware: %s\n" % e)

extern crate FirmwareApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = FirmwareApi::Context::default();
    let result = client.deleteFirmware(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
id*	UUID (uuid) Required

Responses

Schema

getFirmware

Returns a Firmware

Get a Firmware.

/firmware/{id}

Usage and SDK Samples

curl -X GET \
-H "X-API-KEY: [[apiKey]]" \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://localhost:16003/api/v1/firmware/{id}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.FirmwareApi;

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

public class FirmwareApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        FirmwareApi apiInstance = new FirmwareApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            FirmwareDetails result = apiInstance.getFirmware(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareApi#getFirmware");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.FirmwareApi;

public class FirmwareApiExample {
    public static void main(String[] args) {
        FirmwareApi apiInstance = new FirmwareApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            FirmwareDetails result = apiInstance.getFirmware(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareApi#getFirmware");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
FirmwareApi *apiInstance = [[FirmwareApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Returns a Firmware
[apiInstance getFirmwareWith:id
              completionHandler: ^(FirmwareDetails output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var UCentralFirmwareServiceApi = require('u_central_firmware_service_api');
var defaultClient = UCentralFirmwareServiceApi.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new UCentralFirmwareServiceApi.FirmwareApi()
var id = 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.getFirmware(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getFirmwareExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new FirmwareApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Returns a Firmware
                FirmwareDetails result = apiInstance.getFirmware(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FirmwareApi.getFirmware: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FirmwareApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::FirmwareApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FirmwareApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->getFirmware(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FirmwareApi->getFirmware: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.FirmwareApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Returns a Firmware
    api_response = api_instance.get_firmware(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FirmwareApi->getFirmware: %s\n" % e)

extern crate FirmwareApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = FirmwareApi::Context::default();
    let result = client.getFirmware(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
id*	UUID (uuid) Required

Responses

Schema

getFirmwareAge

Calculate how old a version of firmware is.

/firmwareAge

Usage and SDK Samples

curl -X GET \
-H "X-API-KEY: [[apiKey]]" \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://localhost:16003/api/v1/firmwareAge?revision=revision_example&deviceType=deviceType_example&select=select=serial1,serial2,serial4,serial5."

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.FirmwareApi;

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

public class FirmwareApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        FirmwareApi apiInstance = new FirmwareApi();
        String revision = revision_example; // String | The exact current version of the firmware on that device.
        String deviceType = deviceType_example; // String | The exact current version of the firmware on that device.
        String select = select=serial1,serial2,serial4,serial5.; // String | Specify list of serial  numbers to retrieve age for

        try {
            getFirmwareAge_200_response result = apiInstance.getFirmwareAge(revision, deviceType, select);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareApi#getFirmwareAge");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.FirmwareApi;

public class FirmwareApiExample {
    public static void main(String[] args) {
        FirmwareApi apiInstance = new FirmwareApi();
        String revision = revision_example; // String | The exact current version of the firmware on that device.
        String deviceType = deviceType_example; // String | The exact current version of the firmware on that device.
        String select = select=serial1,serial2,serial4,serial5.; // String | Specify list of serial  numbers to retrieve age for

        try {
            getFirmwareAge_200_response result = apiInstance.getFirmwareAge(revision, deviceType, select);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareApi#getFirmwareAge");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
FirmwareApi *apiInstance = [[FirmwareApi alloc] init];
String *revision = revision_example; // The exact current version of the firmware on that device. (default to null)
String *deviceType = deviceType_example; // The exact current version of the firmware on that device. (default to null)
String *select = select=serial1,serial2,serial4,serial5.; // Specify list of serial  numbers to retrieve age for (optional) (default to null)

// Calculate how old a version of firmware is.
[apiInstance getFirmwareAgeWith:revision
    deviceType:deviceType
    select:select
              completionHandler: ^(getFirmwareAge_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var UCentralFirmwareServiceApi = require('u_central_firmware_service_api');
var defaultClient = UCentralFirmwareServiceApi.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new UCentralFirmwareServiceApi.FirmwareApi()
var revision = revision_example; // {String} The exact current version of the firmware on that device.
var deviceType = deviceType_example; // {String} The exact current version of the firmware on that device.
var opts = {
  'select': select=serial1,serial2,serial4,serial5. // {String} Specify list of serial  numbers to retrieve age for
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getFirmwareAgeExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new FirmwareApi();
            var revision = revision_example;  // String | The exact current version of the firmware on that device. (default to null)
            var deviceType = deviceType_example;  // String | The exact current version of the firmware on that device. (default to null)
            var select = select=serial1,serial2,serial4,serial5.;  // String | Specify list of serial  numbers to retrieve age for (optional)  (default to null)

            try {
                // Calculate how old a version of firmware is.
                getFirmwareAge_200_response result = apiInstance.getFirmwareAge(revision, deviceType, select);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FirmwareApi.getFirmwareAge: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FirmwareApi();
$revision = revision_example; // String | The exact current version of the firmware on that device.
$deviceType = deviceType_example; // String | The exact current version of the firmware on that device.
$select = select=serial1,serial2,serial4,serial5.; // String | Specify list of serial  numbers to retrieve age for

try {
    $result = $api_instance->getFirmwareAge($revision, $deviceType, $select);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FirmwareApi->getFirmwareAge: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::FirmwareApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FirmwareApi->new();
my $revision = revision_example; # String | The exact current version of the firmware on that device.
my $deviceType = deviceType_example; # String | The exact current version of the firmware on that device.
my $select = select=serial1,serial2,serial4,serial5.; # String | Specify list of serial  numbers to retrieve age for

eval {
    my $result = $api_instance->getFirmwareAge(revision => $revision, deviceType => $deviceType, select => $select);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FirmwareApi->getFirmwareAge: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.FirmwareApi()
revision = revision_example # String | The exact current version of the firmware on that device. (default to null)
deviceType = deviceType_example # String | The exact current version of the firmware on that device. (default to null)
select = select=serial1,serial2,serial4,serial5. # String | Specify list of serial  numbers to retrieve age for (optional) (default to null)

try:
    # Calculate how old a version of firmware is.
    api_response = api_instance.get_firmware_age(revision, deviceType, select=select)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FirmwareApi->getFirmwareAge: %s\n" % e)

extern crate FirmwareApi;

pub fn main() {
    let revision = revision_example; // String
    let deviceType = deviceType_example; // String
    let select = select=serial1,serial2,serial4,serial5.; // String

    let mut context = FirmwareApi::Context::default();
    let result = client.getFirmwareAge(revision, deviceType, select, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters

Name	Description
revision*	String The exact current version of the firmware on that device. Required
deviceType*	String The exact current version of the firmware on that device. Required
select	String Specify list of serial numbers to retrieve age for

Responses

Schema

getFirmwareList

Returns a list of firmwares.

Get a list of firmwares.

/firmwares

Usage and SDK Samples

curl -X GET \
-H "X-API-KEY: [[apiKey]]" \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://localhost:16003/api/v1/firmwares?offset=56&limit=56&filter=filter_example&latestOnly=true&deviceType=deviceType_example&revisionSet=true&deviceSet=true&rcOnly=true&updateTimeOnly=true"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.FirmwareApi;

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

public class FirmwareApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        FirmwareApi apiInstance = new FirmwareApi();
        Integer offset = 56; // Integer | Pagination start (starts at 1. If not specified, 1 is assumed)
        Integer limit = 56; // Integer | Maximum number of entries to return (if absent, no limit is assumed)
        String filter = filter_example; // String | Filter the results
        Boolean latestOnly = true; // Boolean | Return only the latest firmware
        String deviceType = deviceType_example; // String | 
        Boolean revisionSet = true; // Boolean | 
        Boolean deviceSet = true; // Boolean | 
        Boolean rcOnly = true; // Boolean | 
        Boolean updateTimeOnly = true; // Boolean | 

        try {
            getFirmwareList_200_response result = apiInstance.getFirmwareList(offset, limit, filter, latestOnly, deviceType, revisionSet, deviceSet, rcOnly, updateTimeOnly);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareApi#getFirmwareList");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.FirmwareApi;

public class FirmwareApiExample {
    public static void main(String[] args) {
        FirmwareApi apiInstance = new FirmwareApi();
        Integer offset = 56; // Integer | Pagination start (starts at 1. If not specified, 1 is assumed)
        Integer limit = 56; // Integer | Maximum number of entries to return (if absent, no limit is assumed)
        String filter = filter_example; // String | Filter the results
        Boolean latestOnly = true; // Boolean | Return only the latest firmware
        String deviceType = deviceType_example; // String | 
        Boolean revisionSet = true; // Boolean | 
        Boolean deviceSet = true; // Boolean | 
        Boolean rcOnly = true; // Boolean | 
        Boolean updateTimeOnly = true; // Boolean | 

        try {
            getFirmwareList_200_response result = apiInstance.getFirmwareList(offset, limit, filter, latestOnly, deviceType, revisionSet, deviceSet, rcOnly, updateTimeOnly);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareApi#getFirmwareList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
FirmwareApi *apiInstance = [[FirmwareApi alloc] init];
Integer *offset = 56; // Pagination start (starts at 1. If not specified, 1 is assumed) (optional) (default to null)
Integer *limit = 56; // Maximum number of entries to return (if absent, no limit is assumed) (optional) (default to null)
String *filter = filter_example; // Filter the results (optional) (default to null)
Boolean *latestOnly = true; // Return only the latest firmware (optional) (default to false)
String *deviceType = deviceType_example; //  (optional) (default to null)
Boolean *revisionSet = true; //  (optional) (default to false)
Boolean *deviceSet = true; //  (optional) (default to null)
Boolean *rcOnly = true; //  (optional) (default to false)
Boolean *updateTimeOnly = true; //  (optional) (default to null)

// Returns a list of firmwares.
[apiInstance getFirmwareListWith:offset
    limit:limit
    filter:filter
    latestOnly:latestOnly
    deviceType:deviceType
    revisionSet:revisionSet
    deviceSet:deviceSet
    rcOnly:rcOnly
    updateTimeOnly:updateTimeOnly
              completionHandler: ^(getFirmwareList_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var UCentralFirmwareServiceApi = require('u_central_firmware_service_api');
var defaultClient = UCentralFirmwareServiceApi.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new UCentralFirmwareServiceApi.FirmwareApi()
var opts = {
  'offset': 56, // {Integer} Pagination start (starts at 1. If not specified, 1 is assumed)
  'limit': 56, // {Integer} Maximum number of entries to return (if absent, no limit is assumed)
  'filter': filter_example, // {String} Filter the results
  'latestOnly': true, // {Boolean} Return only the latest firmware
  'deviceType': deviceType_example, // {String} 
  'revisionSet': true, // {Boolean} 
  'deviceSet': true, // {Boolean} 
  'rcOnly': true, // {Boolean} 
  'updateTimeOnly': true // {Boolean} 
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getFirmwareListExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new FirmwareApi();
            var offset = 56;  // Integer | Pagination start (starts at 1. If not specified, 1 is assumed) (optional)  (default to null)
            var limit = 56;  // Integer | Maximum number of entries to return (if absent, no limit is assumed) (optional)  (default to null)
            var filter = filter_example;  // String | Filter the results (optional)  (default to null)
            var latestOnly = true;  // Boolean | Return only the latest firmware (optional)  (default to false)
            var deviceType = deviceType_example;  // String |  (optional)  (default to null)
            var revisionSet = true;  // Boolean |  (optional)  (default to false)
            var deviceSet = true;  // Boolean |  (optional)  (default to null)
            var rcOnly = true;  // Boolean |  (optional)  (default to false)
            var updateTimeOnly = true;  // Boolean |  (optional)  (default to null)

            try {
                // Returns a list of firmwares.
                getFirmwareList_200_response result = apiInstance.getFirmwareList(offset, limit, filter, latestOnly, deviceType, revisionSet, deviceSet, rcOnly, updateTimeOnly);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FirmwareApi.getFirmwareList: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FirmwareApi();
$offset = 56; // Integer | Pagination start (starts at 1. If not specified, 1 is assumed)
$limit = 56; // Integer | Maximum number of entries to return (if absent, no limit is assumed)
$filter = filter_example; // String | Filter the results
$latestOnly = true; // Boolean | Return only the latest firmware
$deviceType = deviceType_example; // String | 
$revisionSet = true; // Boolean | 
$deviceSet = true; // Boolean | 
$rcOnly = true; // Boolean | 
$updateTimeOnly = true; // Boolean | 

try {
    $result = $api_instance->getFirmwareList($offset, $limit, $filter, $latestOnly, $deviceType, $revisionSet, $deviceSet, $rcOnly, $updateTimeOnly);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FirmwareApi->getFirmwareList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::FirmwareApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FirmwareApi->new();
my $offset = 56; # Integer | Pagination start (starts at 1. If not specified, 1 is assumed)
my $limit = 56; # Integer | Maximum number of entries to return (if absent, no limit is assumed)
my $filter = filter_example; # String | Filter the results
my $latestOnly = true; # Boolean | Return only the latest firmware
my $deviceType = deviceType_example; # String | 
my $revisionSet = true; # Boolean | 
my $deviceSet = true; # Boolean | 
my $rcOnly = true; # Boolean | 
my $updateTimeOnly = true; # Boolean | 

eval {
    my $result = $api_instance->getFirmwareList(offset => $offset, limit => $limit, filter => $filter, latestOnly => $latestOnly, deviceType => $deviceType, revisionSet => $revisionSet, deviceSet => $deviceSet, rcOnly => $rcOnly, updateTimeOnly => $updateTimeOnly);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FirmwareApi->getFirmwareList: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.FirmwareApi()
offset = 56 # Integer | Pagination start (starts at 1. If not specified, 1 is assumed) (optional) (default to null)
limit = 56 # Integer | Maximum number of entries to return (if absent, no limit is assumed) (optional) (default to null)
filter = filter_example # String | Filter the results (optional) (default to null)
latestOnly = true # Boolean | Return only the latest firmware (optional) (default to false)
deviceType = deviceType_example # String |  (optional) (default to null)
revisionSet = true # Boolean |  (optional) (default to false)
deviceSet = true # Boolean |  (optional) (default to null)
rcOnly = true # Boolean |  (optional) (default to false)
updateTimeOnly = true # Boolean |  (optional) (default to null)

try:
    # Returns a list of firmwares.
    api_response = api_instance.get_firmware_list(offset=offset, limit=limit, filter=filter, latestOnly=latestOnly, deviceType=deviceType, revisionSet=revisionSet, deviceSet=deviceSet, rcOnly=rcOnly, updateTimeOnly=updateTimeOnly)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FirmwareApi->getFirmwareList: %s\n" % e)

extern crate FirmwareApi;

pub fn main() {
    let offset = 56; // Integer
    let limit = 56; // Integer
    let filter = filter_example; // String
    let latestOnly = true; // Boolean
    let deviceType = deviceType_example; // String
    let revisionSet = true; // Boolean
    let deviceSet = true; // Boolean
    let rcOnly = true; // Boolean
    let updateTimeOnly = true; // Boolean

    let mut context = FirmwareApi::Context::default();
    let result = client.getFirmwareList(offset, limit, filter, latestOnly, deviceType, revisionSet, deviceSet, rcOnly, updateTimeOnly, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters

Name	Description
offset	Integer Pagination start (starts at 1. If not specified, 1 is assumed)
limit	Integer Maximum number of entries to return (if absent, no limit is assumed)
filter	String Filter the results
latestOnly	Boolean Return only the latest firmware
deviceType	String
revisionSet	Boolean
deviceSet	Boolean
rcOnly	Boolean
updateTimeOnly	Boolean

Responses

Schema

updateFirmwareList

Force a DB refresh.

/firmwares

Usage and SDK Samples

curl -X PUT \
-H "X-API-KEY: [[apiKey]]" \
 -H "Authorization: Bearer [[accessToken]]" \
 "https://localhost:16003/api/v1/firmwares?update=true"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.FirmwareApi;

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

public class FirmwareApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        FirmwareApi apiInstance = new FirmwareApi();
        Boolean update = true; // Boolean | Force the firmware DB update

        try {
            apiInstance.updateFirmwareList(update);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareApi#updateFirmwareList");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.FirmwareApi;

public class FirmwareApiExample {
    public static void main(String[] args) {
        FirmwareApi apiInstance = new FirmwareApi();
        Boolean update = true; // Boolean | Force the firmware DB update

        try {
            apiInstance.updateFirmwareList(update);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareApi#updateFirmwareList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
FirmwareApi *apiInstance = [[FirmwareApi alloc] init];
Boolean *update = true; // Force the firmware DB update (optional) (default to null)

// Force a DB refresh.
[apiInstance updateFirmwareListWith:update
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var UCentralFirmwareServiceApi = require('u_central_firmware_service_api');
var defaultClient = UCentralFirmwareServiceApi.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new UCentralFirmwareServiceApi.FirmwareApi()
var opts = {
  'update': true // {Boolean} Force the firmware DB update
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateFirmwareList(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateFirmwareListExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new FirmwareApi();
            var update = true;  // Boolean | Force the firmware DB update (optional)  (default to null)

            try {
                // Force a DB refresh.
                apiInstance.updateFirmwareList(update);
            } catch (Exception e) {
                Debug.Print("Exception when calling FirmwareApi.updateFirmwareList: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FirmwareApi();
$update = true; // Boolean | Force the firmware DB update

try {
    $api_instance->updateFirmwareList($update);
} catch (Exception $e) {
    echo 'Exception when calling FirmwareApi->updateFirmwareList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::FirmwareApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FirmwareApi->new();
my $update = true; # Boolean | Force the firmware DB update

eval {
    $api_instance->updateFirmwareList(update => $update);
};
if ($@) {
    warn "Exception when calling FirmwareApi->updateFirmwareList: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.FirmwareApi()
update = true # Boolean | Force the firmware DB update (optional) (default to null)

try:
    # Force a DB refresh.
    api_instance.update_firmware_list(update=update)
except ApiException as e:
    print("Exception when calling FirmwareApi->updateFirmwareList: %s\n" % e)

extern crate FirmwareApi;

pub fn main() {
    let update = true; // Boolean

    let mut context = FirmwareApi::Context::default();
    let result = client.updateFirmwareList(update, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters

Name	Description
update	Boolean Force the firmware DB update

Responses

upodateFirmware

Update A New firmware

/firmware/{id}

Usage and SDK Samples

curl -X PUT \
-H "X-API-KEY: [[apiKey]]" \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://localhost:16003/api/v1/firmware/{id}" \
 -d '{
  "deviceType" : "deviceType",
  "owner" : "owner",
  "image" : "image",
  "notes" : [ {
    "note" : "note",
    "createdBy" : "createdBy",
    "created" : 5
  }, {
    "note" : "note",
    "createdBy" : "createdBy",
    "created" : 5
  } ],
  "firmwareHash" : "firmwareHash",
  "created" : 5,
  "description" : "description",
  "imageDate" : 0,
  "uri" : "https://openapi-generator.tech",
  "revision" : "revision",
  "size" : 6,
  "uploader" : "uploader",
  "digest" : "digest",
  "location" : "https://openapi-generator.tech",
  "id" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "downloadCount" : 1,
  "latest" : true
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.FirmwareApi;

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

public class FirmwareApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        FirmwareApi apiInstance = new FirmwareApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        FirmwareDetails firmwareDetails = ; // FirmwareDetails | 

        try {
            FirmwareDetails result = apiInstance.upodateFirmware(id, firmwareDetails);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareApi#upodateFirmware");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.FirmwareApi;

public class FirmwareApiExample {
    public static void main(String[] args) {
        FirmwareApi apiInstance = new FirmwareApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        FirmwareDetails firmwareDetails = ; // FirmwareDetails | 

        try {
            FirmwareDetails result = apiInstance.upodateFirmware(id, firmwareDetails);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareApi#upodateFirmware");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
FirmwareApi *apiInstance = [[FirmwareApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
FirmwareDetails *firmwareDetails = ; // 

// Update A New firmware
[apiInstance upodateFirmwareWith:id
    firmwareDetails:firmwareDetails
              completionHandler: ^(FirmwareDetails output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var UCentralFirmwareServiceApi = require('u_central_firmware_service_api');
var defaultClient = UCentralFirmwareServiceApi.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new UCentralFirmwareServiceApi.FirmwareApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var firmwareDetails = ; // {FirmwareDetails} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class upodateFirmwareExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new FirmwareApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var firmwareDetails = new FirmwareDetails(); // FirmwareDetails | 

            try {
                // Update A New firmware
                FirmwareDetails result = apiInstance.upodateFirmware(id, firmwareDetails);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FirmwareApi.upodateFirmware: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FirmwareApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$firmwareDetails = ; // FirmwareDetails | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::FirmwareApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FirmwareApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $firmwareDetails = WWW::OPenAPIClient::Object::FirmwareDetails->new(); # FirmwareDetails | 

eval {
    my $result = $api_instance->upodateFirmware(id => $id, firmwareDetails => $firmwareDetails);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FirmwareApi->upodateFirmware: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.FirmwareApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
firmwareDetails =  # FirmwareDetails | 

try:
    # Update A New firmware
    api_response = api_instance.upodate_firmware(id, firmwareDetails)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FirmwareApi->upodateFirmware: %s\n" % e)

extern crate FirmwareApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let firmwareDetails = ; // FirmwareDetails

    let mut context = FirmwareApi::Context::default();
    let result = client.upodateFirmware(id, firmwareDetails, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
id*	UUID (uuid) Required

Body parameters

Name	Description
firmwareDetails *	Firmware details

Responses

Schema

RevisionHistory

deleteRevisionHistory

Delete specific hostory elements for a device

/revisionHistory/{serialNumber}

Usage and SDK Samples

curl -X DELETE \
-H "X-API-KEY: [[apiKey]]" \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://localhost:16003/api/v1/revisionHistory/{serialNumber}?id=38400000-8cf0-11bd-b23e-10b96e4ef00d"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RevisionHistoryApi;

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

public class RevisionHistoryApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RevisionHistoryApi apiInstance = new RevisionHistoryApi();
        String serialNumber = serialNumber_example; // String | 
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Pagination start (starts at 1. If not specified, 1 is assumed)

        try {
            Success result = apiInstance.deleteRevisionHistory(serialNumber, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RevisionHistoryApi#deleteRevisionHistory");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.RevisionHistoryApi;

public class RevisionHistoryApiExample {
    public static void main(String[] args) {
        RevisionHistoryApi apiInstance = new RevisionHistoryApi();
        String serialNumber = serialNumber_example; // String | 
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Pagination start (starts at 1. If not specified, 1 is assumed)

        try {
            Success result = apiInstance.deleteRevisionHistory(serialNumber, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RevisionHistoryApi#deleteRevisionHistory");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RevisionHistoryApi *apiInstance = [[RevisionHistoryApi alloc] init];
String *serialNumber = serialNumber_example; //  (default to null)
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Pagination start (starts at 1. If not specified, 1 is assumed) (default to null)

// Delete specific hostory elements for a device
[apiInstance deleteRevisionHistoryWith:serialNumber
    id:id
              completionHandler: ^(Success output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var UCentralFirmwareServiceApi = require('u_central_firmware_service_api');
var defaultClient = UCentralFirmwareServiceApi.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new UCentralFirmwareServiceApi.RevisionHistoryApi()
var serialNumber = serialNumber_example; // {String} 
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} Pagination start (starts at 1. If not specified, 1 is assumed)

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deleteRevisionHistoryExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RevisionHistoryApi();
            var serialNumber = serialNumber_example;  // String |  (default to null)
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | Pagination start (starts at 1. If not specified, 1 is assumed) (default to null)

            try {
                // Delete specific hostory elements for a device
                Success result = apiInstance.deleteRevisionHistory(serialNumber, id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RevisionHistoryApi.deleteRevisionHistory: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RevisionHistoryApi();
$serialNumber = serialNumber_example; // String | 
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Pagination start (starts at 1. If not specified, 1 is assumed)

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::RevisionHistoryApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RevisionHistoryApi->new();
my $serialNumber = serialNumber_example; # String | 
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Pagination start (starts at 1. If not specified, 1 is assumed)

eval {
    my $result = $api_instance->deleteRevisionHistory(serialNumber => $serialNumber, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RevisionHistoryApi->deleteRevisionHistory: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RevisionHistoryApi()
serialNumber = serialNumber_example # String |  (default to null)
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Pagination start (starts at 1. If not specified, 1 is assumed) (default to null)

try:
    # Delete specific hostory elements for a device
    api_response = api_instance.delete_revision_history(serialNumber, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RevisionHistoryApi->deleteRevisionHistory: %s\n" % e)

extern crate RevisionHistoryApi;

pub fn main() {
    let serialNumber = serialNumber_example; // String
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = RevisionHistoryApi::Context::default();
    let result = client.deleteRevisionHistory(serialNumber, id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
serialNumber*	String Required

Query parameters

Name	Description
id*	UUID (uuid) Pagination start (starts at 1. If not specified, 1 is assumed) Required

Responses

Schema

getRevisionHistory

List all the defined device revision history

/revisionHistory/{serialNumber}

Usage and SDK Samples

curl -X GET \
-H "X-API-KEY: [[apiKey]]" \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://localhost:16003/api/v1/revisionHistory/{serialNumber}?offset=56&limit=56&filter=filter_example¤tList=You must set {serialNumber} to 000000000000&unknownList=You must set {serialNumber} to 000000000000"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RevisionHistoryApi;

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

public class RevisionHistoryApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RevisionHistoryApi apiInstance = new RevisionHistoryApi();
        String serialNumber = serialNumber_example; // String | 
        Integer offset = 56; // Integer | Pagination start (starts at 1. If not specified, 1 is assumed)
        Integer limit = 56; // Integer | Maximum number of entries to return (if absent, no limit is assumed)
        String filter = filter_example; // String | Filter the results
        Boolean currentList = You must set {serialNumber} to 000000000000; // Boolean | Return current device list and current firmware
        Boolean unknownList = You must set {serialNumber} to 000000000000; // Boolean | Return current device list and current firmware

        try {
            getRevisionHistory_200_response result = apiInstance.getRevisionHistory(serialNumber, offset, limit, filter, currentList, unknownList);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RevisionHistoryApi#getRevisionHistory");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.RevisionHistoryApi;

public class RevisionHistoryApiExample {
    public static void main(String[] args) {
        RevisionHistoryApi apiInstance = new RevisionHistoryApi();
        String serialNumber = serialNumber_example; // String | 
        Integer offset = 56; // Integer | Pagination start (starts at 1. If not specified, 1 is assumed)
        Integer limit = 56; // Integer | Maximum number of entries to return (if absent, no limit is assumed)
        String filter = filter_example; // String | Filter the results
        Boolean currentList = You must set {serialNumber} to 000000000000; // Boolean | Return current device list and current firmware
        Boolean unknownList = You must set {serialNumber} to 000000000000; // Boolean | Return current device list and current firmware

        try {
            getRevisionHistory_200_response result = apiInstance.getRevisionHistory(serialNumber, offset, limit, filter, currentList, unknownList);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RevisionHistoryApi#getRevisionHistory");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RevisionHistoryApi *apiInstance = [[RevisionHistoryApi alloc] init];
String *serialNumber = serialNumber_example; //  (default to null)
Integer *offset = 56; // Pagination start (starts at 1. If not specified, 1 is assumed) (optional) (default to null)
Integer *limit = 56; // Maximum number of entries to return (if absent, no limit is assumed) (optional) (default to null)
String *filter = filter_example; // Filter the results (optional) (default to null)
Boolean *currentList = You must set {serialNumber} to 000000000000; // Return current device list and current firmware (optional) (default to false)
Boolean *unknownList = You must set {serialNumber} to 000000000000; // Return current device list and current firmware (optional) (default to false)

// List all the defined device revision history
[apiInstance getRevisionHistoryWith:serialNumber
    offset:offset
    limit:limit
    filter:filter
    currentList:currentList
    unknownList:unknownList
              completionHandler: ^(getRevisionHistory_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var UCentralFirmwareServiceApi = require('u_central_firmware_service_api');
var defaultClient = UCentralFirmwareServiceApi.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new UCentralFirmwareServiceApi.RevisionHistoryApi()
var serialNumber = serialNumber_example; // {String} 
var opts = {
  'offset': 56, // {Integer} Pagination start (starts at 1. If not specified, 1 is assumed)
  'limit': 56, // {Integer} Maximum number of entries to return (if absent, no limit is assumed)
  'filter': filter_example, // {String} Filter the results
  'currentList': You must set {serialNumber} to 000000000000, // {Boolean} Return current device list and current firmware
  'unknownList': You must set {serialNumber} to 000000000000 // {Boolean} Return current device list and current firmware
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getRevisionHistoryExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RevisionHistoryApi();
            var serialNumber = serialNumber_example;  // String |  (default to null)
            var offset = 56;  // Integer | Pagination start (starts at 1. If not specified, 1 is assumed) (optional)  (default to null)
            var limit = 56;  // Integer | Maximum number of entries to return (if absent, no limit is assumed) (optional)  (default to null)
            var filter = filter_example;  // String | Filter the results (optional)  (default to null)
            var currentList = You must set {serialNumber} to 000000000000;  // Boolean | Return current device list and current firmware (optional)  (default to false)
            var unknownList = You must set {serialNumber} to 000000000000;  // Boolean | Return current device list and current firmware (optional)  (default to false)

            try {
                // List all the defined device revision history
                getRevisionHistory_200_response result = apiInstance.getRevisionHistory(serialNumber, offset, limit, filter, currentList, unknownList);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RevisionHistoryApi.getRevisionHistory: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RevisionHistoryApi();
$serialNumber = serialNumber_example; // String | 
$offset = 56; // Integer | Pagination start (starts at 1. If not specified, 1 is assumed)
$limit = 56; // Integer | Maximum number of entries to return (if absent, no limit is assumed)
$filter = filter_example; // String | Filter the results
$currentList = You must set {serialNumber} to 000000000000; // Boolean | Return current device list and current firmware
$unknownList = You must set {serialNumber} to 000000000000; // Boolean | Return current device list and current firmware

try {
    $result = $api_instance->getRevisionHistory($serialNumber, $offset, $limit, $filter, $currentList, $unknownList);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RevisionHistoryApi->getRevisionHistory: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::RevisionHistoryApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RevisionHistoryApi->new();
my $serialNumber = serialNumber_example; # String | 
my $offset = 56; # Integer | Pagination start (starts at 1. If not specified, 1 is assumed)
my $limit = 56; # Integer | Maximum number of entries to return (if absent, no limit is assumed)
my $filter = filter_example; # String | Filter the results
my $currentList = You must set {serialNumber} to 000000000000; # Boolean | Return current device list and current firmware
my $unknownList = You must set {serialNumber} to 000000000000; # Boolean | Return current device list and current firmware

eval {
    my $result = $api_instance->getRevisionHistory(serialNumber => $serialNumber, offset => $offset, limit => $limit, filter => $filter, currentList => $currentList, unknownList => $unknownList);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RevisionHistoryApi->getRevisionHistory: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RevisionHistoryApi()
serialNumber = serialNumber_example # String |  (default to null)
offset = 56 # Integer | Pagination start (starts at 1. If not specified, 1 is assumed) (optional) (default to null)
limit = 56 # Integer | Maximum number of entries to return (if absent, no limit is assumed) (optional) (default to null)
filter = filter_example # String | Filter the results (optional) (default to null)
currentList = You must set {serialNumber} to 000000000000 # Boolean | Return current device list and current firmware (optional) (default to false)
unknownList = You must set {serialNumber} to 000000000000 # Boolean | Return current device list and current firmware (optional) (default to false)

try:
    # List all the defined device revision history
    api_response = api_instance.get_revision_history(serialNumber, offset=offset, limit=limit, filter=filter, currentList=currentList, unknownList=unknownList)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RevisionHistoryApi->getRevisionHistory: %s\n" % e)

extern crate RevisionHistoryApi;

pub fn main() {
    let serialNumber = serialNumber_example; // String
    let offset = 56; // Integer
    let limit = 56; // Integer
    let filter = filter_example; // String
    let currentList = You must set {serialNumber} to 000000000000; // Boolean
    let unknownList = You must set {serialNumber} to 000000000000; // Boolean

    let mut context = RevisionHistoryApi::Context::default();
    let result = client.getRevisionHistory(serialNumber, offset, limit, filter, currentList, unknownList, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
serialNumber*	String Required

Query parameters

Name	Description
offset	Integer Pagination start (starts at 1. If not specified, 1 is assumed)
limit	Integer Maximum number of entries to return (if absent, no limit is assumed)
filter	String Filter the results
currentList	Boolean Return current device list and current firmware
unknownList	Boolean Return current device list and current firmware

Responses

Schema

SystemCommands

getSystemCommand

Retrieve different values from the running service.

/system

Usage and SDK Samples

curl -X GET \
-H "X-API-KEY: [[apiKey]]" \
 -H "Authorization: Bearer [[accessToken]]" \
 "https://localhost:16003/api/v1/system?command=command_example"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SystemCommandsApi;

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

public class SystemCommandsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        SystemCommandsApi apiInstance = new SystemCommandsApi();
        String command = command_example; // String | Get a value

        try {
            apiInstance.getSystemCommand(command);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemCommandsApi#getSystemCommand");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.SystemCommandsApi;

public class SystemCommandsApiExample {
    public static void main(String[] args) {
        SystemCommandsApi apiInstance = new SystemCommandsApi();
        String command = command_example; // String | Get a value

        try {
            apiInstance.getSystemCommand(command);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemCommandsApi#getSystemCommand");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
SystemCommandsApi *apiInstance = [[SystemCommandsApi alloc] init];
String *command = command_example; // Get a value (default to null)

// Retrieve different values from the running service.
[apiInstance getSystemCommandWith:command
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var UCentralFirmwareServiceApi = require('u_central_firmware_service_api');
var defaultClient = UCentralFirmwareServiceApi.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new UCentralFirmwareServiceApi.SystemCommandsApi()
var command = command_example; // {String} Get a value

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getSystemCommand(command, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getSystemCommandExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new SystemCommandsApi();
            var command = command_example;  // String | Get a value (default to null)

            try {
                // Retrieve different values from the running service.
                apiInstance.getSystemCommand(command);
            } catch (Exception e) {
                Debug.Print("Exception when calling SystemCommandsApi.getSystemCommand: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SystemCommandsApi();
$command = command_example; // String | Get a value

try {
    $api_instance->getSystemCommand($command);
} catch (Exception $e) {
    echo 'Exception when calling SystemCommandsApi->getSystemCommand: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SystemCommandsApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SystemCommandsApi->new();
my $command = command_example; # String | Get a value

eval {
    $api_instance->getSystemCommand(command => $command);
};
if ($@) {
    warn "Exception when calling SystemCommandsApi->getSystemCommand: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.SystemCommandsApi()
command = command_example # String | Get a value (default to null)

try:
    # Retrieve different values from the running service.
    api_instance.get_system_command(command)
except ApiException as e:
    print("Exception when calling SystemCommandsApi->getSystemCommand: %s\n" % e)

extern crate SystemCommandsApi;

pub fn main() {
    let command = command_example; // String

    let mut context = SystemCommandsApi::Context::default();
    let result = client.getSystemCommand(command, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters

Name	Description
command*	String Get a value Required

Responses

systemCommand

Perform some system wide commands

/system

Usage and SDK Samples

curl -X POST \
-H "X-API-KEY: [[apiKey]]" \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://localhost:16003/api/v1/system" \
 -d ''

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SystemCommandsApi;

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

public class SystemCommandsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        SystemCommandsApi apiInstance = new SystemCommandsApi();
        SystemCommandRequest systemCommandRequest = ; // SystemCommandRequest | 

        try {
            systemCommand_200_response result = apiInstance.systemCommand(systemCommandRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemCommandsApi#systemCommand");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.SystemCommandsApi;

public class SystemCommandsApiExample {
    public static void main(String[] args) {
        SystemCommandsApi apiInstance = new SystemCommandsApi();
        SystemCommandRequest systemCommandRequest = ; // SystemCommandRequest | 

        try {
            systemCommand_200_response result = apiInstance.systemCommand(systemCommandRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemCommandsApi#systemCommand");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
SystemCommandsApi *apiInstance = [[SystemCommandsApi alloc] init];
SystemCommandRequest *systemCommandRequest = ; //  (optional)

// Perform some system wide commands
[apiInstance systemCommandWith:systemCommandRequest
              completionHandler: ^(systemCommand_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var UCentralFirmwareServiceApi = require('u_central_firmware_service_api');
var defaultClient = UCentralFirmwareServiceApi.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new UCentralFirmwareServiceApi.SystemCommandsApi()
var opts = {
  'systemCommandRequest':  // {SystemCommandRequest} 
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class systemCommandExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new SystemCommandsApi();
            var systemCommandRequest = new SystemCommandRequest(); // SystemCommandRequest |  (optional) 

            try {
                // Perform some system wide commands
                systemCommand_200_response result = apiInstance.systemCommand(systemCommandRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SystemCommandsApi.systemCommand: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SystemCommandsApi();
$systemCommandRequest = ; // SystemCommandRequest | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SystemCommandsApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SystemCommandsApi->new();
my $systemCommandRequest = WWW::OPenAPIClient::Object::SystemCommandRequest->new(); # SystemCommandRequest | 

eval {
    my $result = $api_instance->systemCommand(systemCommandRequest => $systemCommandRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SystemCommandsApi->systemCommand: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.SystemCommandsApi()
systemCommandRequest =  # SystemCommandRequest |  (optional)

try:
    # Perform some system wide commands
    api_response = api_instance.system_command(systemCommandRequest=systemCommandRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SystemCommandsApi->systemCommand: %s\n" % e)

extern crate SystemCommandsApi;

pub fn main() {
    let systemCommandRequest = ; // SystemCommandRequest

    let mut context = SystemCommandsApi::Context::default();
    let result = client.systemCommand(systemCommandRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters

Name	Description
systemCommandRequest	Command details

Responses

Schema

SystemConfiguration

deleteSystemConfiguration

Delete all additional system configuration

/systemConfiguration

Usage and SDK Samples

curl -X DELETE \
-H "X-API-KEY: [[apiKey]]" \
 -H "Authorization: Bearer [[accessToken]]" \
 "https://localhost:16003/api/v1/systemConfiguration"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SystemConfigurationApi;

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

public class SystemConfigurationApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        SystemConfigurationApi apiInstance = new SystemConfigurationApi();

        try {
            apiInstance.deleteSystemConfiguration();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemConfigurationApi#deleteSystemConfiguration");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.SystemConfigurationApi;

public class SystemConfigurationApiExample {
    public static void main(String[] args) {
        SystemConfigurationApi apiInstance = new SystemConfigurationApi();

        try {
            apiInstance.deleteSystemConfiguration();
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemConfigurationApi#deleteSystemConfiguration");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
SystemConfigurationApi *apiInstance = [[SystemConfigurationApi alloc] init];

// Delete all additional system configuration
[apiInstance deleteSystemConfigurationWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var UCentralFirmwareServiceApi = require('u_central_firmware_service_api');
var defaultClient = UCentralFirmwareServiceApi.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new UCentralFirmwareServiceApi.SystemConfigurationApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteSystemConfiguration(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deleteSystemConfigurationExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new SystemConfigurationApi();

            try {
                // Delete all additional system configuration
                apiInstance.deleteSystemConfiguration();
            } catch (Exception e) {
                Debug.Print("Exception when calling SystemConfigurationApi.deleteSystemConfiguration: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SystemConfigurationApi();

try {
    $api_instance->deleteSystemConfiguration();
} catch (Exception $e) {
    echo 'Exception when calling SystemConfigurationApi->deleteSystemConfiguration: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SystemConfigurationApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SystemConfigurationApi->new();

eval {
    $api_instance->deleteSystemConfiguration();
};
if ($@) {
    warn "Exception when calling SystemConfigurationApi->deleteSystemConfiguration: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.SystemConfigurationApi()

try:
    # Delete all additional system configuration
    api_instance.delete_system_configuration()
except ApiException as e:
    print("Exception when calling SystemConfigurationApi->deleteSystemConfiguration: %s\n" % e)

extern crate SystemConfigurationApi;

pub fn main() {

    let mut context = SystemConfigurationApi::Context::default();
    let result = client.deleteSystemConfiguration(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

getSystemConfiguration

Retrieve system configuration items

/systemConfiguration

Usage and SDK Samples

curl -X GET \
-H "X-API-KEY: [[apiKey]]" \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://localhost:16003/api/v1/systemConfiguration?entries=["element1","element1,element2,element3"]"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SystemConfigurationApi;

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

public class SystemConfigurationApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        SystemConfigurationApi apiInstance = new SystemConfigurationApi();
        String entries = ["element1","element1,element2,element3"]; // String | Which parameters you want to retrieve

        try {
            array[List] result = apiInstance.getSystemConfiguration(entries);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemConfigurationApi#getSystemConfiguration");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.SystemConfigurationApi;

public class SystemConfigurationApiExample {
    public static void main(String[] args) {
        SystemConfigurationApi apiInstance = new SystemConfigurationApi();
        String entries = ["element1","element1,element2,element3"]; // String | Which parameters you want to retrieve

        try {
            array[List] result = apiInstance.getSystemConfiguration(entries);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemConfigurationApi#getSystemConfiguration");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
SystemConfigurationApi *apiInstance = [[SystemConfigurationApi alloc] init];
String *entries = ["element1","element1,element2,element3"]; // Which parameters you want to retrieve (optional) (default to null)

// Retrieve system configuration items
[apiInstance getSystemConfigurationWith:entries
              completionHandler: ^(array[List] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var UCentralFirmwareServiceApi = require('u_central_firmware_service_api');
var defaultClient = UCentralFirmwareServiceApi.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new UCentralFirmwareServiceApi.SystemConfigurationApi()
var opts = {
  'entries': ["element1","element1,element2,element3"] // {String} Which parameters you want to retrieve
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getSystemConfigurationExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new SystemConfigurationApi();
            var entries = ["element1","element1,element2,element3"];  // String | Which parameters you want to retrieve (optional)  (default to null)

            try {
                // Retrieve system configuration items
                array[List] result = apiInstance.getSystemConfiguration(entries);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SystemConfigurationApi.getSystemConfiguration: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SystemConfigurationApi();
$entries = ["element1","element1,element2,element3"]; // String | Which parameters you want to retrieve

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SystemConfigurationApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SystemConfigurationApi->new();
my $entries = ["element1","element1,element2,element3"]; # String | Which parameters you want to retrieve

eval {
    my $result = $api_instance->getSystemConfiguration(entries => $entries);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SystemConfigurationApi->getSystemConfiguration: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.SystemConfigurationApi()
entries = ["element1","element1,element2,element3"] # String | Which parameters you want to retrieve (optional) (default to null)

try:
    # Retrieve system configuration items
    api_response = api_instance.get_system_configuration(entries=entries)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SystemConfigurationApi->getSystemConfiguration: %s\n" % e)

extern crate SystemConfigurationApi;

pub fn main() {
    let entries = ["element1","element1,element2,element3"]; // String

    let mut context = SystemConfigurationApi::Context::default();
    let result = client.getSystemConfiguration(entries, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters

Name	Description
entries	String Which parameters you want to retrieve

Responses

Schema

setSystemConfiguration

Set some or all system configuration

/systemConfiguration

Usage and SDK Samples

curl -X PUT \
-H "X-API-KEY: [[apiKey]]" \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Content-Type: application/json" \
 "https://localhost:16003/api/v1/systemConfiguration" \
 -d '{
  "parameterName" : "parameterName",
  "parameterValue" : "parameterValue"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SystemConfigurationApi;

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

public class SystemConfigurationApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        SystemConfigurationApi apiInstance = new SystemConfigurationApi();
        array[ExtraSystemConfiguration_inner] extraSystemConfigurationInner = ; // array[ExtraSystemConfiguration_inner] | 

        try {
            apiInstance.setSystemConfiguration(extraSystemConfigurationInner);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemConfigurationApi#setSystemConfiguration");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.SystemConfigurationApi;

public class SystemConfigurationApiExample {
    public static void main(String[] args) {
        SystemConfigurationApi apiInstance = new SystemConfigurationApi();
        array[ExtraSystemConfiguration_inner] extraSystemConfigurationInner = ; // array[ExtraSystemConfiguration_inner] | 

        try {
            apiInstance.setSystemConfiguration(extraSystemConfigurationInner);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemConfigurationApi#setSystemConfiguration");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
SystemConfigurationApi *apiInstance = [[SystemConfigurationApi alloc] init];
array[ExtraSystemConfiguration_inner] *extraSystemConfigurationInner = ; //  (optional)

// Set some or all system configuration
[apiInstance setSystemConfigurationWith:extraSystemConfigurationInner
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var UCentralFirmwareServiceApi = require('u_central_firmware_service_api');
var defaultClient = UCentralFirmwareServiceApi.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new UCentralFirmwareServiceApi.SystemConfigurationApi()
var opts = {
  'extraSystemConfigurationInner':  // {array[ExtraSystemConfiguration_inner]} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.setSystemConfiguration(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class setSystemConfigurationExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new SystemConfigurationApi();
            var extraSystemConfigurationInner = new array[ExtraSystemConfiguration_inner](); // array[ExtraSystemConfiguration_inner] |  (optional) 

            try {
                // Set some or all system configuration
                apiInstance.setSystemConfiguration(extraSystemConfigurationInner);
            } catch (Exception e) {
                Debug.Print("Exception when calling SystemConfigurationApi.setSystemConfiguration: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SystemConfigurationApi();
$extraSystemConfigurationInner = ; // array[ExtraSystemConfiguration_inner] | 

try {
    $api_instance->setSystemConfiguration($extraSystemConfigurationInner);
} catch (Exception $e) {
    echo 'Exception when calling SystemConfigurationApi->setSystemConfiguration: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SystemConfigurationApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SystemConfigurationApi->new();
my $extraSystemConfigurationInner = [WWW::OPenAPIClient::Object::array[ExtraSystemConfiguration_inner]->new()]; # array[ExtraSystemConfiguration_inner] | 

eval {
    $api_instance->setSystemConfiguration(extraSystemConfigurationInner => $extraSystemConfigurationInner);
};
if ($@) {
    warn "Exception when calling SystemConfigurationApi->setSystemConfiguration: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.SystemConfigurationApi()
extraSystemConfigurationInner =  # array[ExtraSystemConfiguration_inner] |  (optional)

try:
    # Set some or all system configuration
    api_instance.set_system_configuration(extraSystemConfigurationInner=extraSystemConfigurationInner)
except ApiException as e:
    print("Exception when calling SystemConfigurationApi->setSystemConfiguration: %s\n" % e)

extern crate SystemConfigurationApi;

pub fn main() {
    let extraSystemConfigurationInner = ; // array[ExtraSystemConfiguration_inner]

    let mut context = SystemConfigurationApi::Context::default();
    let result = client.setSystemConfiguration(extraSystemConfigurationInner, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters

Name	Description
extraSystemConfigurationInner

uCentral Firmware Service API

API and SDK Documentation

ConnectedDevices

getConnectedDevice

Usage and SDK Samples

Scopes

Parameters

Responses

getConnectedDevices

Usage and SDK Samples

Scopes

Parameters

Responses

DeviceInfo

deviceReportGet

Usage and SDK Samples

Scopes

Parameters

Responses

DeviceInformation

deviceInformationSerialNumberGet

Usage and SDK Samples

Scopes

Parameters

Responses

Firmware

createFirmware

Usage and SDK Samples

Scopes

Parameters

Responses

deleteFirmware

Usage and SDK Samples

Scopes

Parameters

Responses

getFirmware

Usage and SDK Samples

Scopes

Parameters

Responses

getFirmwareAge

Usage and SDK Samples

Scopes

Parameters

Responses

getFirmwareList

Usage and SDK Samples

Scopes

Parameters

Responses

updateFirmwareList

Usage and SDK Samples

Scopes

Parameters

Responses

upodateFirmware

Usage and SDK Samples

Scopes

Parameters

Responses

RevisionHistory

deleteRevisionHistory

Usage and SDK Samples

Scopes

Parameters

Responses

getRevisionHistory

Usage and SDK Samples

Scopes

Parameters

Responses

SystemCommands

getSystemCommand

Usage and SDK Samples

Scopes

Parameters

Responses

systemCommand

Usage and SDK Samples