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

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

public class AuthorizationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        AuthorizationApi apiInstance = new AuthorizationApi();
        LoginRequest body = ; // LoginRequest | 
        try {
            LoginResponse result = apiInstance.login(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthorizationApi#login");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AuthorizationApi;

public class AuthorizationApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
LoginRequest *body = ; // 

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

// user login by username and password, return authorziation token
[apiInstance loginWith:body
              completionHandler: ^(LoginResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.AuthorizationApi()
var body = ; // {{LoginRequest}} 

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

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

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


            var apiInstance = new AuthorizationApi();
            var body = new LoginRequest(); // LoginRequest | 

            try
            {
                // user login by username and password, return authorziation token
                LoginResponse result = apiInstance.login(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthorizationApi.login: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAuthorizationApi();
$body = ; // LoginRequest | 

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

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


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

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

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


# create an instance of the API class
api_instance = swagger_client.AuthorizationApi()
body =  # LoginRequest | 

try: 
    # user login by username and password, return authorziation token
    api_response = api_instance.login(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthorizationApi->login: %s\n" % e)

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

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

public class CirclesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        CirclesApi apiInstance = new CirclesApi();
        Circle body = ; // Circle | 
        try {
            apiInstance.circleCreateOrUpdate(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CirclesApi#circleCreateOrUpdate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CirclesApi;

public class CirclesApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
Circle *body = ; // 

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

// create or update connection
[apiInstance circleCreateOrUpdateWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.CirclesApi()
var body = ; // {{Circle}} 

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

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

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


            var apiInstance = new CirclesApi();
            var body = new Circle(); // Circle | 

            try
            {
                // create or update connection
                apiInstance.circleCreateOrUpdate(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CirclesApi.circleCreateOrUpdate: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiCirclesApi();
$body = ; // Circle | 

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

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


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

eval { 
    $api_instance->circleCreateOrUpdate(body => $body);
};
if ($@) {
    warn "Exception when calling CirclesApi->circleCreateOrUpdate: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.CirclesApi()
body =  # Circle | 

try: 
    # create or update connection
    api_instance.circle_create_or_update(body)
except ApiException as e:
    print("Exception when calling CirclesApi->circleCreateOrUpdate: %s\n" % e)

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

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

public class CirclesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        CirclesApi apiInstance = new CirclesApi();
        String circleId = circleId_example; // String | connection id
        try {
            apiInstance.circleDel(circleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CirclesApi#circleDel");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CirclesApi;

public class CirclesApiExample {

    public static void main(String[] args) {
        CirclesApi apiInstance = new CirclesApi();
        String circleId = circleId_example; // String | connection id
        try {
            apiInstance.circleDel(circleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CirclesApi#circleDel");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *circleId = circleId_example; // connection id

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

// remove connection
[apiInstance circleDelWith:circleId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.CirclesApi()
var circleId = circleId_example; // {{String}} connection id

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

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

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


            var apiInstance = new CirclesApi();
            var circleId = circleId_example;  // String | connection id

            try
            {
                // remove connection
                apiInstance.circleDel(circleId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CirclesApi.circleDel: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiCirclesApi();
$circleId = circleId_example; // String | connection id

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

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


my $api_instance = WWW::SwaggerClient::CirclesApi->new();
my $circleId = circleId_example; # String | connection id

eval { 
    $api_instance->circleDel(circleId => $circleId);
};
if ($@) {
    warn "Exception when calling CirclesApi->circleDel: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.CirclesApi()
circleId = circleId_example # String | connection id

try: 
    # remove connection
    api_instance.circle_del(circleId)
except ApiException as e:
    print("Exception when calling CirclesApi->circleDel: %s\n" % e)

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

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

public class CirclesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        CirclesApi apiInstance = new CirclesApi();
        String circleId = circleId_example; // String | connection id
        try {
            Circle result = apiInstance.circleGet(circleId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CirclesApi#circleGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CirclesApi;

public class CirclesApiExample {

    public static void main(String[] args) {
        CirclesApi apiInstance = new CirclesApi();
        String circleId = circleId_example; // String | connection id
        try {
            Circle result = apiInstance.circleGet(circleId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CirclesApi#circleGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *circleId = circleId_example; // connection id

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

// get connection information
[apiInstance circleGetWith:circleId
              completionHandler: ^(Circle output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.CirclesApi()
var circleId = circleId_example; // {{String}} connection id

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

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

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


            var apiInstance = new CirclesApi();
            var circleId = circleId_example;  // String | connection id

            try
            {
                // get connection information
                Circle result = apiInstance.circleGet(circleId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CirclesApi.circleGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiCirclesApi();
$circleId = circleId_example; // String | connection id

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

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


my $api_instance = WWW::SwaggerClient::CirclesApi->new();
my $circleId = circleId_example; # String | connection id

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

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


# create an instance of the API class
api_instance = swagger_client.CirclesApi()
circleId = circleId_example # String | connection id

try: 
    # get connection information
    api_response = api_instance.circle_get(circleId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CirclesApi->circleGet: %s\n" % e)

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

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

public class CirclesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        CirclesApi apiInstance = new CirclesApi();
        String circleId = circleId_example; // String | connection id
        Integer deviceId = 56; // Integer | connection id
        try {
            apiInstance.circleRemoveDevice(circleId, deviceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CirclesApi#circleRemoveDevice");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CirclesApi;

public class CirclesApiExample {

    public static void main(String[] args) {
        CirclesApi apiInstance = new CirclesApi();
        String circleId = circleId_example; // String | connection id
        Integer deviceId = 56; // Integer | connection id
        try {
            apiInstance.circleRemoveDevice(circleId, deviceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CirclesApi#circleRemoveDevice");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *circleId = circleId_example; // connection id
Integer *deviceId = 56; // connection id

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

// remove device from list in connection
[apiInstance circleRemoveDeviceWith:circleId
    deviceId:deviceId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.CirclesApi()
var circleId = circleId_example; // {{String}} connection id
var deviceId = 56; // {{Integer}} connection id

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

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

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


            var apiInstance = new CirclesApi();
            var circleId = circleId_example;  // String | connection id
            var deviceId = 56;  // Integer | connection id

            try
            {
                // remove device from list in connection
                apiInstance.circleRemoveDevice(circleId, deviceId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CirclesApi.circleRemoveDevice: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiCirclesApi();
$circleId = circleId_example; // String | connection id
$deviceId = 56; // Integer | connection id

try {
    $api_instance->circleRemoveDevice($circleId, $deviceId);
} catch (Exception $e) {
    echo 'Exception when calling CirclesApi->circleRemoveDevice: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::CirclesApi->new();
my $circleId = circleId_example; # String | connection id
my $deviceId = 56; # Integer | connection id

eval { 
    $api_instance->circleRemoveDevice(circleId => $circleId, deviceId => $deviceId);
};
if ($@) {
    warn "Exception when calling CirclesApi->circleRemoveDevice: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.CirclesApi()
circleId = circleId_example # String | connection id
deviceId = 56 # Integer | connection id

try: 
    # remove device from list in connection
    api_instance.circle_remove_device(circleId, deviceId)
except ApiException as e:
    print("Exception when calling CirclesApi->circleRemoveDevice: %s\n" % e)

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

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

public class CirclesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        CirclesApi apiInstance = new CirclesApi();
        String circleId = circleId_example; // String | connection id
        Integer begin = 56; // Integer | begin address
        Integer end = 56; // Integer | end address
        try {
            apiInstance.circleUpdate(circleId, begin, end);
        } catch (ApiException e) {
            System.err.println("Exception when calling CirclesApi#circleUpdate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CirclesApi;

public class CirclesApiExample {

    public static void main(String[] args) {
        CirclesApi apiInstance = new CirclesApi();
        String circleId = circleId_example; // String | connection id
        Integer begin = 56; // Integer | begin address
        Integer end = 56; // Integer | end address
        try {
            apiInstance.circleUpdate(circleId, begin, end);
        } catch (ApiException e) {
            System.err.println("Exception when calling CirclesApi#circleUpdate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *circleId = circleId_example; // connection id
Integer *begin = 56; // begin address (optional)
Integer *end = 56; // end address (optional)

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

// update device list in connection (search new devices)
[apiInstance circleUpdateWith:circleId
    begin:begin
    end:end
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.CirclesApi()
var circleId = circleId_example; // {{String}} connection id
var opts = { 
  'begin': 56, // {{Integer}} begin address
  'end': 56 // {{Integer}} end address
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.circleUpdate(circleId, opts, callback);

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

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


            var apiInstance = new CirclesApi();
            var circleId = circleId_example;  // String | connection id
            var begin = 56;  // Integer | begin address (optional) 
            var end = 56;  // Integer | end address (optional) 

            try
            {
                // update device list in connection (search new devices)
                apiInstance.circleUpdate(circleId, begin, end);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CirclesApi.circleUpdate: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiCirclesApi();
$circleId = circleId_example; // String | connection id
$begin = 56; // Integer | begin address
$end = 56; // Integer | end address

try {
    $api_instance->circleUpdate($circleId, $begin, $end);
} catch (Exception $e) {
    echo 'Exception when calling CirclesApi->circleUpdate: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::CirclesApi->new();
my $circleId = circleId_example; # String | connection id
my $begin = 56; # Integer | begin address
my $end = 56; # Integer | end address

eval { 
    $api_instance->circleUpdate(circleId => $circleId, begin => $begin, end => $end);
};
if ($@) {
    warn "Exception when calling CirclesApi->circleUpdate: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.CirclesApi()
circleId = circleId_example # String | connection id
begin = 56 # Integer | begin address (optional)
end = 56 # Integer | end address (optional)

try: 
    # update device list in connection (search new devices)
    api_instance.circle_update(circleId, begin=begin, end=end)
except ApiException as e:
    print("Exception when calling CirclesApi->circleUpdate: %s\n" % e)

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

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

public class CommandsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        CommandsApi apiInstance = new CommandsApi();
        CommandRequest body = ; // CommandRequest | 
        try {
            CommandResponse result = apiInstance.runCommand(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommandsApi#runCommand");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CommandsApi;

public class CommandsApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
CommandRequest *body = ; // 

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

// send command to device
[apiInstance runCommandWith:body
              completionHandler: ^(CommandResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.CommandsApi()
var body = ; // {{CommandRequest}} 

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

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

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


            var apiInstance = new CommandsApi();
            var body = new CommandRequest(); // CommandRequest | 

            try
            {
                // send command to device
                CommandResponse result = apiInstance.runCommand(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommandsApi.runCommand: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiCommandsApi();
$body = ; // CommandRequest | 

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

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


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

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

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


# create an instance of the API class
api_instance = swagger_client.CommandsApi()
body =  # CommandRequest | 

try: 
    # send command to device
    api_response = api_instance.run_command(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommandsApi->runCommand: %s\n" % e)

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

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

public class DeviceInfoApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        DeviceInfoApi apiInstance = new DeviceInfoApi();
        DeviceInfo body = ; // DeviceInfo | 
        String circleId = circleId_example; // String | connection id
        try {
            apiInstance.setDeviceInfoForCircle(body, circleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeviceInfoApi#setDeviceInfoForCircle");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DeviceInfoApi;

public class DeviceInfoApiExample {

    public static void main(String[] args) {
        DeviceInfoApi apiInstance = new DeviceInfoApi();
        DeviceInfo body = ; // DeviceInfo | 
        String circleId = circleId_example; // String | connection id
        try {
            apiInstance.setDeviceInfoForCircle(body, circleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeviceInfoApi#setDeviceInfoForCircle");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
DeviceInfo *body = ; // 
String *circleId = circleId_example; // connection id

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

// set connection additional information
[apiInstance setDeviceInfoForCircleWith:body
    circleId:circleId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.DeviceInfoApi()
var body = ; // {{DeviceInfo}} 
var circleId = circleId_example; // {{String}} connection id

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

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

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


            var apiInstance = new DeviceInfoApi();
            var body = new DeviceInfo(); // DeviceInfo | 
            var circleId = circleId_example;  // String | connection id

            try
            {
                // set connection additional information
                apiInstance.setDeviceInfoForCircle(body, circleId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DeviceInfoApi.setDeviceInfoForCircle: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiDeviceInfoApi();
$body = ; // DeviceInfo | 
$circleId = circleId_example; // String | connection id

try {
    $api_instance->setDeviceInfoForCircle($body, $circleId);
} catch (Exception $e) {
    echo 'Exception when calling DeviceInfoApi->setDeviceInfoForCircle: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::DeviceInfoApi->new();
my $body = WWW::SwaggerClient::Object::DeviceInfo->new(); # DeviceInfo | 
my $circleId = circleId_example; # String | connection id

eval { 
    $api_instance->setDeviceInfoForCircle(body => $body, circleId => $circleId);
};
if ($@) {
    warn "Exception when calling DeviceInfoApi->setDeviceInfoForCircle: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.DeviceInfoApi()
body =  # DeviceInfo | 
circleId = circleId_example # String | connection id

try: 
    # set connection additional information
    api_instance.set_device_info_for_circle(body, circleId)
except ApiException as e:
    print("Exception when calling DeviceInfoApi->setDeviceInfoForCircle: %s\n" % e)

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

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

public class DeviceInfoApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        DeviceInfoApi apiInstance = new DeviceInfoApi();
        DeviceInfo body = ; // DeviceInfo | 
        String circleId = circleId_example; // String | connection id
        Integer deviceId = 56; // Integer | device id
        try {
            apiInstance.setDeviceInfoForDevice(body, circleId, deviceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeviceInfoApi#setDeviceInfoForDevice");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DeviceInfoApi;

public class DeviceInfoApiExample {

    public static void main(String[] args) {
        DeviceInfoApi apiInstance = new DeviceInfoApi();
        DeviceInfo body = ; // DeviceInfo | 
        String circleId = circleId_example; // String | connection id
        Integer deviceId = 56; // Integer | device id
        try {
            apiInstance.setDeviceInfoForDevice(body, circleId, deviceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeviceInfoApi#setDeviceInfoForDevice");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
DeviceInfo *body = ; // 
String *circleId = circleId_example; // connection id
Integer *deviceId = 56; // device id

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

// set device additional information
[apiInstance setDeviceInfoForDeviceWith:body
    circleId:circleId
    deviceId:deviceId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.DeviceInfoApi()
var body = ; // {{DeviceInfo}} 
var circleId = circleId_example; // {{String}} connection id
var deviceId = 56; // {{Integer}} device id

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

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

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


            var apiInstance = new DeviceInfoApi();
            var body = new DeviceInfo(); // DeviceInfo | 
            var circleId = circleId_example;  // String | connection id
            var deviceId = 56;  // Integer | device id

            try
            {
                // set device additional information
                apiInstance.setDeviceInfoForDevice(body, circleId, deviceId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DeviceInfoApi.setDeviceInfoForDevice: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiDeviceInfoApi();
$body = ; // DeviceInfo | 
$circleId = circleId_example; // String | connection id
$deviceId = 56; // Integer | device id

try {
    $api_instance->setDeviceInfoForDevice($body, $circleId, $deviceId);
} catch (Exception $e) {
    echo 'Exception when calling DeviceInfoApi->setDeviceInfoForDevice: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::DeviceInfoApi->new();
my $body = WWW::SwaggerClient::Object::DeviceInfo->new(); # DeviceInfo | 
my $circleId = circleId_example; # String | connection id
my $deviceId = 56; # Integer | device id

eval { 
    $api_instance->setDeviceInfoForDevice(body => $body, circleId => $circleId, deviceId => $deviceId);
};
if ($@) {
    warn "Exception when calling DeviceInfoApi->setDeviceInfoForDevice: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.DeviceInfoApi()
body =  # DeviceInfo | 
circleId = circleId_example # String | connection id
deviceId = 56 # Integer | device id

try: 
    # set device additional information
    api_instance.set_device_info_for_device(body, circleId, deviceId)
except ApiException as e:
    print("Exception when calling DeviceInfoApi->setDeviceInfoForDevice: %s\n" % e)

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

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

public class DeviceInfoApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        DeviceInfoApi apiInstance = new DeviceInfoApi();
        DeviceInfo body = ; // DeviceInfo | 
        String circleId = circleId_example; // String | connection id
        Integer deviceId = 56; // Integer | device id
        Integer portId = 56; // Integer | port id
        try {
            apiInstance.setDeviceInfoForPort(body, circleId, deviceId, portId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeviceInfoApi#setDeviceInfoForPort");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DeviceInfoApi;

public class DeviceInfoApiExample {

    public static void main(String[] args) {
        DeviceInfoApi apiInstance = new DeviceInfoApi();
        DeviceInfo body = ; // DeviceInfo | 
        String circleId = circleId_example; // String | connection id
        Integer deviceId = 56; // Integer | device id
        Integer portId = 56; // Integer | port id
        try {
            apiInstance.setDeviceInfoForPort(body, circleId, deviceId, portId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeviceInfoApi#setDeviceInfoForPort");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
DeviceInfo *body = ; // 
String *circleId = circleId_example; // connection id
Integer *deviceId = 56; // device id
Integer *portId = 56; // port id

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

// set device port additional information
[apiInstance setDeviceInfoForPortWith:body
    circleId:circleId
    deviceId:deviceId
    portId:portId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.DeviceInfoApi()
var body = ; // {{DeviceInfo}} 
var circleId = circleId_example; // {{String}} connection id
var deviceId = 56; // {{Integer}} device id
var portId = 56; // {{Integer}} port id

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

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

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


            var apiInstance = new DeviceInfoApi();
            var body = new DeviceInfo(); // DeviceInfo | 
            var circleId = circleId_example;  // String | connection id
            var deviceId = 56;  // Integer | device id
            var portId = 56;  // Integer | port id

            try
            {
                // set device port additional information
                apiInstance.setDeviceInfoForPort(body, circleId, deviceId, portId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DeviceInfoApi.setDeviceInfoForPort: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiDeviceInfoApi();
$body = ; // DeviceInfo | 
$circleId = circleId_example; // String | connection id
$deviceId = 56; // Integer | device id
$portId = 56; // Integer | port id

try {
    $api_instance->setDeviceInfoForPort($body, $circleId, $deviceId, $portId);
} catch (Exception $e) {
    echo 'Exception when calling DeviceInfoApi->setDeviceInfoForPort: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::DeviceInfoApi->new();
my $body = WWW::SwaggerClient::Object::DeviceInfo->new(); # DeviceInfo | 
my $circleId = circleId_example; # String | connection id
my $deviceId = 56; # Integer | device id
my $portId = 56; # Integer | port id

eval { 
    $api_instance->setDeviceInfoForPort(body => $body, circleId => $circleId, deviceId => $deviceId, portId => $portId);
};
if ($@) {
    warn "Exception when calling DeviceInfoApi->setDeviceInfoForPort: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.DeviceInfoApi()
body =  # DeviceInfo | 
circleId = circleId_example # String | connection id
deviceId = 56 # Integer | device id
portId = 56 # Integer | port id

try: 
    # set device port additional information
    api_instance.set_device_info_for_port(body, circleId, deviceId, portId)
except ApiException as e:
    print("Exception when calling DeviceInfoApi->setDeviceInfoForPort: %s\n" % e)

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

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

public class EventsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        EventsApi apiInstance = new EventsApi();
        Date begin = 2013-10-20T19:20:30+01:00; // Date | date time begin
        Date end = 2013-10-20T19:20:30+01:00; // Date | date time end
        try {
            apiInstance.delEvents(begin, end);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsApi#delEvents");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EventsApi;

public class EventsApiExample {

    public static void main(String[] args) {
        EventsApi apiInstance = new EventsApi();
        Date begin = 2013-10-20T19:20:30+01:00; // Date | date time begin
        Date end = 2013-10-20T19:20:30+01:00; // Date | date time end
        try {
            apiInstance.delEvents(begin, end);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsApi#delEvents");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Date *begin = 2013-10-20T19:20:30+01:00; // date time begin (optional)
Date *end = 2013-10-20T19:20:30+01:00; // date time end (optional)

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

// clean events list
[apiInstance delEventsWith:begin
    end:end
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.EventsApi()
var opts = { 
  'begin': 2013-10-20T19:20:30+01:00, // {{Date}} date time begin
  'end': 2013-10-20T19:20:30+01:00 // {{Date}} date time end
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.delEvents(opts, callback);

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

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


            var apiInstance = new EventsApi();
            var begin = 2013-10-20T19:20:30+01:00;  // Date | date time begin (optional) 
            var end = 2013-10-20T19:20:30+01:00;  // Date | date time end (optional) 

            try
            {
                // clean events list
                apiInstance.delEvents(begin, end);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventsApi.delEvents: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiEventsApi();
$begin = 2013-10-20T19:20:30+01:00; // Date | date time begin
$end = 2013-10-20T19:20:30+01:00; // Date | date time end

try {
    $api_instance->delEvents($begin, $end);
} catch (Exception $e) {
    echo 'Exception when calling EventsApi->delEvents: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::EventsApi->new();
my $begin = 2013-10-20T19:20:30+01:00; # Date | date time begin
my $end = 2013-10-20T19:20:30+01:00; # Date | date time end

eval { 
    $api_instance->delEvents(begin => $begin, end => $end);
};
if ($@) {
    warn "Exception when calling EventsApi->delEvents: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.EventsApi()
begin = 2013-10-20T19:20:30+01:00 # Date | date time begin (optional)
end = 2013-10-20T19:20:30+01:00 # Date | date time end (optional)

try: 
    # clean events list
    api_instance.del_events(begin=begin, end=end)
except ApiException as e:
    print("Exception when calling EventsApi->delEvents: %s\n" % e)

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

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

public class EventsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        EventsApi apiInstance = new EventsApi();
        Date begin = 2013-10-20T19:20:30+01:00; // Date | date and time begin
        Date end = 2013-10-20T19:20:30+01:00; // Date | date and time end
        String lang = lang_example; // String | events report language
        String type = type_example; // String | events report type (CSV or HTNL)
        try {
            EventsResponse result = apiInstance.getEvents(begin, end, lang, type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsApi#getEvents");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EventsApi;

public class EventsApiExample {

    public static void main(String[] args) {
        EventsApi apiInstance = new EventsApi();
        Date begin = 2013-10-20T19:20:30+01:00; // Date | date and time begin
        Date end = 2013-10-20T19:20:30+01:00; // Date | date and time end
        String lang = lang_example; // String | events report language
        String type = type_example; // String | events report type (CSV or HTNL)
        try {
            EventsResponse result = apiInstance.getEvents(begin, end, lang, type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsApi#getEvents");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Date *begin = 2013-10-20T19:20:30+01:00; // date and time begin (optional)
Date *end = 2013-10-20T19:20:30+01:00; // date and time end (optional)
String *lang = lang_example; // events report language (optional)
String *type = type_example; // events report type (CSV or HTNL) (optional)

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

// get events list
[apiInstance getEventsWith:begin
    end:end
    lang:lang
    type:type
              completionHandler: ^(EventsResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.EventsApi()
var opts = { 
  'begin': 2013-10-20T19:20:30+01:00, // {{Date}} date and time begin
  'end': 2013-10-20T19:20:30+01:00, // {{Date}} date and time end
  'lang': lang_example, // {{String}} events report language
  'type': type_example // {{String}} events report type (CSV or HTNL)
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getEvents(opts, callback);

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

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


            var apiInstance = new EventsApi();
            var begin = 2013-10-20T19:20:30+01:00;  // Date | date and time begin (optional) 
            var end = 2013-10-20T19:20:30+01:00;  // Date | date and time end (optional) 
            var lang = lang_example;  // String | events report language (optional) 
            var type = type_example;  // String | events report type (CSV or HTNL) (optional) 

            try
            {
                // get events list
                EventsResponse result = apiInstance.getEvents(begin, end, lang, type);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventsApi.getEvents: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiEventsApi();
$begin = 2013-10-20T19:20:30+01:00; // Date | date and time begin
$end = 2013-10-20T19:20:30+01:00; // Date | date and time end
$lang = lang_example; // String | events report language
$type = type_example; // String | events report type (CSV or HTNL)

try {
    $result = $api_instance->getEvents($begin, $end, $lang, $type);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling EventsApi->getEvents: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::EventsApi->new();
my $begin = 2013-10-20T19:20:30+01:00; # Date | date and time begin
my $end = 2013-10-20T19:20:30+01:00; # Date | date and time end
my $lang = lang_example; # String | events report language
my $type = type_example; # String | events report type (CSV or HTNL)

eval { 
    my $result = $api_instance->getEvents(begin => $begin, end => $end, lang => $lang, type => $type);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EventsApi->getEvents: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.EventsApi()
begin = 2013-10-20T19:20:30+01:00 # Date | date and time begin (optional)
end = 2013-10-20T19:20:30+01:00 # Date | date and time end (optional)
lang = lang_example # String | events report language (optional)
type = type_example # String | events report type (CSV or HTNL) (optional)

try: 
    # get events list
    api_response = api_instance.get_events(begin=begin, end=end, lang=lang, type=type)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventsApi->getEvents: %s\n" % e)

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

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

public class GroupsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        GroupsApi apiInstance = new GroupsApi();
        Long payload = 789; // Long | group id
        try {
            Group result = apiInstance.delGroupById(payload);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#delGroupById");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GroupsApi;

public class GroupsApiExample {

    public static void main(String[] args) {
        GroupsApi apiInstance = new GroupsApi();
        Long payload = 789; // Long | group id
        try {
            Group result = apiInstance.delGroupById(payload);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#delGroupById");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Long *payload = 789; // group id

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

// delete group
[apiInstance delGroupByIdWith:payload
              completionHandler: ^(Group output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.GroupsApi()
var payload = 789; // {{Long}} group id

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

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

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


            var apiInstance = new GroupsApi();
            var payload = 789;  // Long | group id

            try
            {
                // delete group
                Group result = apiInstance.delGroupById(payload);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GroupsApi.delGroupById: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiGroupsApi();
$payload = 789; // Long | group id

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

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


my $api_instance = WWW::SwaggerClient::GroupsApi->new();
my $payload = 789; # Long | group id

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

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


# create an instance of the API class
api_instance = swagger_client.GroupsApi()
payload = 789 # Long | group id

try: 
    # delete group
    api_response = api_instance.del_group_by_id(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GroupsApi->delGroupById: %s\n" % e)

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

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

public class GroupsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        GroupsApi apiInstance = new GroupsApi();
        Long payload = 789; // Long | group id
        try {
            Group result = apiInstance.getGroupById(payload);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#getGroupById");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GroupsApi;

public class GroupsApiExample {

    public static void main(String[] args) {
        GroupsApi apiInstance = new GroupsApi();
        Long payload = 789; // Long | group id
        try {
            Group result = apiInstance.getGroupById(payload);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#getGroupById");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Long *payload = 789; // group id

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

// get group by id
[apiInstance getGroupByIdWith:payload
              completionHandler: ^(Group output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.GroupsApi()
var payload = 789; // {{Long}} group id

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

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

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


            var apiInstance = new GroupsApi();
            var payload = 789;  // Long | group id

            try
            {
                // get group by id
                Group result = apiInstance.getGroupById(payload);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GroupsApi.getGroupById: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiGroupsApi();
$payload = 789; // Long | group id

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

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


my $api_instance = WWW::SwaggerClient::GroupsApi->new();
my $payload = 789; # Long | group id

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

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


# create an instance of the API class
api_instance = swagger_client.GroupsApi()
payload = 789 # Long | group id

try: 
    # get group by id
    api_response = api_instance.get_group_by_id(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GroupsApi->getGroupById: %s\n" % e)

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

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

public class GroupsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        GroupsApi apiInstance = new GroupsApi();
        String payload = payload_example; // String | group name
        try {
            Group result = apiInstance.getGroupByName(payload);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#getGroupByName");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GroupsApi;

public class GroupsApiExample {

    public static void main(String[] args) {
        GroupsApi apiInstance = new GroupsApi();
        String payload = payload_example; // String | group name
        try {
            Group result = apiInstance.getGroupByName(payload);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#getGroupByName");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *payload = payload_example; // group name

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

// get group by name
[apiInstance getGroupByNameWith:payload
              completionHandler: ^(Group output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.GroupsApi()
var payload = payload_example; // {{String}} group name

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

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

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


            var apiInstance = new GroupsApi();
            var payload = payload_example;  // String | group name

            try
            {
                // get group by name
                Group result = apiInstance.getGroupByName(payload);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GroupsApi.getGroupByName: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiGroupsApi();
$payload = payload_example; // String | group name

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

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


my $api_instance = WWW::SwaggerClient::GroupsApi->new();
my $payload = payload_example; # String | group name

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

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


# create an instance of the API class
api_instance = swagger_client.GroupsApi()
payload = payload_example # String | group name

try: 
    # get group by name
    api_response = api_instance.get_group_by_name(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GroupsApi->getGroupByName: %s\n" % e)

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

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

public class GroupsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        GroupsApi apiInstance = new GroupsApi();
        try {
            Group result = apiInstance.getGroupByToken();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#getGroupByToken");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GroupsApi;

public class GroupsApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// get group by authorization token
[apiInstance getGroupByTokenWithCompletionHandler: 
              ^(Group output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


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

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

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


            var apiInstance = new GroupsApi();

            try
            {
                // get group by authorization token
                Group result = apiInstance.getGroupByToken();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GroupsApi.getGroupByToken: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

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


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

try: 
    # get group by authorization token
    api_response = api_instance.get_group_by_token()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GroupsApi->getGroupByToken: %s\n" % e)

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

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

public class GroupsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        GroupsApi apiInstance = new GroupsApi();
        try {
            array[Group] result = apiInstance.getGroupsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#getGroupsList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GroupsApi;

public class GroupsApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// get user grouups list
[apiInstance getGroupsListWithCompletionHandler: 
              ^(array[Group] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


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

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

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


            var apiInstance = new GroupsApi();

            try
            {
                // get user grouups list
                array[Group] result = apiInstance.getGroupsList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GroupsApi.getGroupsList: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

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


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

try: 
    # get user grouups list
    api_response = api_instance.get_groups_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GroupsApi->getGroupsList: %s\n" % e)

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

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

public class GroupsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        GroupsApi apiInstance = new GroupsApi();
        Group body = ; // Group | 
        try {
            Group result = apiInstance.groupsCreateOrUpdate(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#groupsCreateOrUpdate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GroupsApi;

public class GroupsApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
Group *body = ; // 

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

// create or update users group
[apiInstance groupsCreateOrUpdateWith:body
              completionHandler: ^(Group output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.GroupsApi()
var body = ; // {{Group}} 

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

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

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


            var apiInstance = new GroupsApi();
            var body = new Group(); // Group | 

            try
            {
                // create or update users group
                Group result = apiInstance.groupsCreateOrUpdate(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GroupsApi.groupsCreateOrUpdate: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiGroupsApi();
$body = ; // Group | 

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

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


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

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

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


# create an instance of the API class
api_instance = swagger_client.GroupsApi()
body =  # Group | 

try: 
    # create or update users group
    api_response = api_instance.groups_create_or_update(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GroupsApi->groupsCreateOrUpdate: %s\n" % e)

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

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

public class LicenseApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        LicenseApi apiInstance = new LicenseApi();
        byte[] fileName = fileName_example; // byte[] | 
        try {
            apiInstance.activatorUpload(fileName);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicenseApi#activatorUpload");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LicenseApi;

public class LicenseApiExample {

    public static void main(String[] args) {
        LicenseApi apiInstance = new LicenseApi();
        byte[] fileName = fileName_example; // byte[] | 
        try {
            apiInstance.activatorUpload(fileName);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicenseApi#activatorUpload");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
byte[] *fileName = fileName_example; // 

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

// upload license activator file
[apiInstance activatorUploadWith:fileName
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.LicenseApi()
var fileName = fileName_example; // {{byte[]}} 

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

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

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


            var apiInstance = new LicenseApi();
            var fileName = fileName_example;  // byte[] | 

            try
            {
                // upload license activator file
                apiInstance.activatorUpload(fileName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LicenseApi.activatorUpload: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiLicenseApi();
$fileName = fileName_example; // byte[] | 

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

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


my $api_instance = WWW::SwaggerClient::LicenseApi->new();
my $fileName = fileName_example; # byte[] | 

eval { 
    $api_instance->activatorUpload(fileName => $fileName);
};
if ($@) {
    warn "Exception when calling LicenseApi->activatorUpload: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.LicenseApi()
fileName = fileName_example # byte[] | 

try: 
    # upload license activator file
    api_instance.activator_upload(fileName)
except ApiException as e:
    print("Exception when calling LicenseApi->activatorUpload: %s\n" % e)

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

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

public class LicenseApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        LicenseApi apiInstance = new LicenseApi();
        try {
            Limits result = apiInstance.getLicenseActual();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicenseApi#getLicenseActual");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LicenseApi;

public class LicenseApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// get license actual usage limits
[apiInstance getLicenseActualWithCompletionHandler: 
              ^(Limits output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


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

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

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


            var apiInstance = new LicenseApi();

            try
            {
                // get license actual usage limits
                Limits result = apiInstance.getLicenseActual();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LicenseApi.getLicenseActual: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

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


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

try: 
    # get license actual usage limits
    api_response = api_instance.get_license_actual()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LicenseApi->getLicenseActual: %s\n" % e)

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

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

public class LicenseApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        LicenseApi apiInstance = new LicenseApi();
        try {
            Limits result = apiInstance.getLicenseBalance();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicenseApi#getLicenseBalance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LicenseApi;

public class LicenseApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// get license limits balance (limits - actual)
[apiInstance getLicenseBalanceWithCompletionHandler: 
              ^(Limits output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


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

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

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


            var apiInstance = new LicenseApi();

            try
            {
                // get license limits balance (limits - actual)
                Limits result = apiInstance.getLicenseBalance();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LicenseApi.getLicenseBalance: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

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


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

try: 
    # get license limits balance (limits - actual)
    api_response = api_instance.get_license_balance()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LicenseApi->getLicenseBalance: %s\n" % e)

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

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

public class LicenseApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        LicenseApi apiInstance = new LicenseApi();
        try {
            Limits result = apiInstance.getLicenseLimits();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicenseApi#getLicenseLimits");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LicenseApi;

public class LicenseApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// get license limits
[apiInstance getLicenseLimitsWithCompletionHandler: 
              ^(Limits output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


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

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

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


            var apiInstance = new LicenseApi();

            try
            {
                // get license limits
                Limits result = apiInstance.getLicenseLimits();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LicenseApi.getLicenseLimits: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

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


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

try: 
    # get license limits
    api_response = api_instance.get_license_limits()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LicenseApi->getLicenseLimits: %s\n" % e)

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

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

public class LicenseApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        LicenseApi apiInstance = new LicenseApi();
        byte[] fileName = fileName_example; // byte[] | 
        try {
            apiInstance.licenseUpload(fileName);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicenseApi#licenseUpload");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LicenseApi;

public class LicenseApiExample {

    public static void main(String[] args) {
        LicenseApi apiInstance = new LicenseApi();
        byte[] fileName = fileName_example; // byte[] | 
        try {
            apiInstance.licenseUpload(fileName);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicenseApi#licenseUpload");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
byte[] *fileName = fileName_example; // 

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

// upload license file
[apiInstance licenseUploadWith:fileName
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.LicenseApi()
var fileName = fileName_example; // {{byte[]}} 

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

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

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


            var apiInstance = new LicenseApi();
            var fileName = fileName_example;  // byte[] | 

            try
            {
                // upload license file
                apiInstance.licenseUpload(fileName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LicenseApi.licenseUpload: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiLicenseApi();
$fileName = fileName_example; // byte[] | 

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

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


my $api_instance = WWW::SwaggerClient::LicenseApi->new();
my $fileName = fileName_example; # byte[] | 

eval { 
    $api_instance->licenseUpload(fileName => $fileName);
};
if ($@) {
    warn "Exception when calling LicenseApi->licenseUpload: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.LicenseApi()
fileName = fileName_example # byte[] | 

try: 
    # upload license file
    api_instance.license_upload(fileName)
except ApiException as e:
    print("Exception when calling LicenseApi->licenseUpload: %s\n" % e)

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

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

public class OptionsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        OptionsApi apiInstance = new OptionsApi();
        String circleId = circleId_example; // String | connection id
        Integer deviceId = 56; // Integer | device id
        try {
            Options result = apiInstance.getDeviceOptions(circleId, deviceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OptionsApi#getDeviceOptions");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OptionsApi;

public class OptionsApiExample {

    public static void main(String[] args) {
        OptionsApi apiInstance = new OptionsApi();
        String circleId = circleId_example; // String | connection id
        Integer deviceId = 56; // Integer | device id
        try {
            Options result = apiInstance.getDeviceOptions(circleId, deviceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OptionsApi#getDeviceOptions");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *circleId = circleId_example; // connection id
Integer *deviceId = 56; // device id

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

// get device options in connection
[apiInstance getDeviceOptionsWith:circleId
    deviceId:deviceId
              completionHandler: ^(Options output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.OptionsApi()
var circleId = circleId_example; // {{String}} connection id
var deviceId = 56; // {{Integer}} device id

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

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

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


            var apiInstance = new OptionsApi();
            var circleId = circleId_example;  // String | connection id
            var deviceId = 56;  // Integer | device id

            try
            {
                // get device options in connection
                Options result = apiInstance.getDeviceOptions(circleId, deviceId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OptionsApi.getDeviceOptions: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiOptionsApi();
$circleId = circleId_example; // String | connection id
$deviceId = 56; // Integer | device id

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

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


my $api_instance = WWW::SwaggerClient::OptionsApi->new();
my $circleId = circleId_example; # String | connection id
my $deviceId = 56; # Integer | device id

eval { 
    my $result = $api_instance->getDeviceOptions(circleId => $circleId, deviceId => $deviceId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OptionsApi->getDeviceOptions: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.OptionsApi()
circleId = circleId_example # String | connection id
deviceId = 56 # Integer | device id

try: 
    # get device options in connection
    api_response = api_instance.get_device_options(circleId, deviceId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OptionsApi->getDeviceOptions: %s\n" % e)

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

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

public class OptionsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        OptionsApi apiInstance = new OptionsApi();
        Options body = ; // Options | 
        String circleId = circleId_example; // String | connection id
        Integer deviceId = 56; // Integer | device id
        Boolean file = true; // Boolean | get options as a JSON file
        Boolean refresh = true; // Boolean | get options with refresh it on device
        try {
            apiInstance.setDeviceOptions(body, circleId, deviceId, file, refresh);
        } catch (ApiException e) {
            System.err.println("Exception when calling OptionsApi#setDeviceOptions");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OptionsApi;

public class OptionsApiExample {

    public static void main(String[] args) {
        OptionsApi apiInstance = new OptionsApi();
        Options body = ; // Options | 
        String circleId = circleId_example; // String | connection id
        Integer deviceId = 56; // Integer | device id
        Boolean file = true; // Boolean | get options as a JSON file
        Boolean refresh = true; // Boolean | get options with refresh it on device
        try {
            apiInstance.setDeviceOptions(body, circleId, deviceId, file, refresh);
        } catch (ApiException e) {
            System.err.println("Exception when calling OptionsApi#setDeviceOptions");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Options *body = ; // 
String *circleId = circleId_example; // connection id
Integer *deviceId = 56; // device id
Boolean *file = true; // get options as a JSON file (optional)
Boolean *refresh = true; // get options with refresh it on device (optional)

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

// set options for device in connection
[apiInstance setDeviceOptionsWith:body
    circleId:circleId
    deviceId:deviceId
    file:file
    refresh:refresh
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.OptionsApi()
var body = ; // {{Options}} 
var circleId = circleId_example; // {{String}} connection id
var deviceId = 56; // {{Integer}} device id
var opts = { 
  'file': true // {{Boolean}} get options as a JSON file
  'refresh': true // {{Boolean}} get options with refresh it on device
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.setDeviceOptions(bodycircleIddeviceId, opts, callback);

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

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


            var apiInstance = new OptionsApi();
            var body = new Options(); // Options | 
            var circleId = circleId_example;  // String | connection id
            var deviceId = 56;  // Integer | device id
            var file = true;  // Boolean | get options as a JSON file (optional) 
            var refresh = true;  // Boolean | get options with refresh it on device (optional) 

            try
            {
                // set options for device in connection
                apiInstance.setDeviceOptions(body, circleId, deviceId, file, refresh);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OptionsApi.setDeviceOptions: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiOptionsApi();
$body = ; // Options | 
$circleId = circleId_example; // String | connection id
$deviceId = 56; // Integer | device id
$file = true; // Boolean | get options as a JSON file
$refresh = true; // Boolean | get options with refresh it on device

try {
    $api_instance->setDeviceOptions($body, $circleId, $deviceId, $file, $refresh);
} catch (Exception $e) {
    echo 'Exception when calling OptionsApi->setDeviceOptions: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::OptionsApi->new();
my $body = WWW::SwaggerClient::Object::Options->new(); # Options | 
my $circleId = circleId_example; # String | connection id
my $deviceId = 56; # Integer | device id
my $file = true; # Boolean | get options as a JSON file
my $refresh = true; # Boolean | get options with refresh it on device

eval { 
    $api_instance->setDeviceOptions(body => $body, circleId => $circleId, deviceId => $deviceId, file => $file, refresh => $refresh);
};
if ($@) {
    warn "Exception when calling OptionsApi->setDeviceOptions: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.OptionsApi()
body =  # Options | 
circleId = circleId_example # String | connection id
deviceId = 56 # Integer | device id
file = true # Boolean | get options as a JSON file (optional)
refresh = true # Boolean | get options with refresh it on device (optional)

try: 
    # set options for device in connection
    api_instance.set_device_options(body, circleId, deviceId, file=file, refresh=refresh)
except ApiException as e:
    print("Exception when calling OptionsApi->setDeviceOptions: %s\n" % e)

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

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

public class SchemeApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        SchemeApi apiInstance = new SchemeApi();
        try {
            DeviceScheme result = apiInstance.scheme();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SchemeApi#scheme");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SchemeApi;

public class SchemeApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// return current devices scheme
[apiInstance schemeWithCompletionHandler: 
              ^(DeviceScheme output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


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

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

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


            var apiInstance = new SchemeApi();

            try
            {
                // return current devices scheme
                DeviceScheme result = apiInstance.scheme();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SchemeApi.scheme: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

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


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

try: 
    # return current devices scheme
    api_response = api_instance.scheme()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SchemeApi->scheme: %s\n" % e)

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

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

public class ServiceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ServiceApi apiInstance = new ServiceApi();
        String action = action_example; // String | action (enable or disable)
        String type = type_example; // String | object for action (circle or device)
        String id = id_example; // String | id for action (for device full id connection_id.device_id)
        try {
            apiInstance.changeServiceMode(action, type, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#changeServiceMode");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServiceApi;

public class ServiceApiExample {

    public static void main(String[] args) {
        ServiceApi apiInstance = new ServiceApi();
        String action = action_example; // String | action (enable or disable)
        String type = type_example; // String | object for action (circle or device)
        String id = id_example; // String | id for action (for device full id connection_id.device_id)
        try {
            apiInstance.changeServiceMode(action, type, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#changeServiceMode");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *action = action_example; // action (enable or disable)
String *type = type_example; // object for action (circle or device)
String *id = id_example; // id for action (for device full id connection_id.device_id)

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

// change service mode on device and connections
[apiInstance changeServiceModeWith:action
    type:type
    id:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.ServiceApi()
var action = action_example; // {{String}} action (enable or disable)
var type = type_example; // {{String}} object for action (circle or device)
var id = id_example; // {{String}} id for action (for device full id connection_id.device_id)

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.changeServiceMode(action, type, id, callback);

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

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


            var apiInstance = new ServiceApi();
            var action = action_example;  // String | action (enable or disable)
            var type = type_example;  // String | object for action (circle or device)
            var id = id_example;  // String | id for action (for device full id connection_id.device_id)

            try
            {
                // change service mode on device and connections
                apiInstance.changeServiceMode(action, type, id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServiceApi.changeServiceMode: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiServiceApi();
$action = action_example; // String | action (enable or disable)
$type = type_example; // String | object for action (circle or device)
$id = id_example; // String | id for action (for device full id connection_id.device_id)

try {
    $api_instance->changeServiceMode($action, $type, $id);
} catch (Exception $e) {
    echo 'Exception when calling ServiceApi->changeServiceMode: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::ServiceApi->new();
my $action = action_example; # String | action (enable or disable)
my $type = type_example; # String | object for action (circle or device)
my $id = id_example; # String | id for action (for device full id connection_id.device_id)

eval { 
    $api_instance->changeServiceMode(action => $action, type => $type, id => $id);
};
if ($@) {
    warn "Exception when calling ServiceApi->changeServiceMode: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.ServiceApi()
action = action_example # String | action (enable or disable)
type = type_example # String | object for action (circle or device)
id = id_example # String | id for action (for device full id connection_id.device_id)

try: 
    # change service mode on device and connections
    api_instance.change_service_mode(action, type, id)
except ApiException as e:
    print("Exception when calling ServiceApi->changeServiceMode: %s\n" % e)

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

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

public class ServiceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ServiceApi apiInstance = new ServiceApi();
        byte[] fileName = fileName_example; // byte[] | 
        try {
            apiInstance.firmwareUpdate(fileName);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#firmwareUpdate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServiceApi;

public class ServiceApiExample {

    public static void main(String[] args) {
        ServiceApi apiInstance = new ServiceApi();
        byte[] fileName = fileName_example; // byte[] | 
        try {
            apiInstance.firmwareUpdate(fileName);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#firmwareUpdate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
byte[] *fileName = fileName_example; // 

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

// update firmware (service) to new or old version
[apiInstance firmwareUpdateWith:fileName
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.ServiceApi()
var fileName = fileName_example; // {{byte[]}} 

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

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

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


            var apiInstance = new ServiceApi();
            var fileName = fileName_example;  // byte[] | 

            try
            {
                // update firmware (service) to new or old version
                apiInstance.firmwareUpdate(fileName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServiceApi.firmwareUpdate: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiServiceApi();
$fileName = fileName_example; // byte[] | 

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

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


my $api_instance = WWW::SwaggerClient::ServiceApi->new();
my $fileName = fileName_example; # byte[] | 

eval { 
    $api_instance->firmwareUpdate(fileName => $fileName);
};
if ($@) {
    warn "Exception when calling ServiceApi->firmwareUpdate: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.ServiceApi()
fileName = fileName_example # byte[] | 

try: 
    # update firmware (service) to new or old version
    api_instance.firmware_update(fileName)
except ApiException as e:
    print("Exception when calling ServiceApi->firmwareUpdate: %s\n" % e)

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

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

public class ServiceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ServiceApi apiInstance = new ServiceApi();
        try {
            'Date' result = apiInstance.getDateTime();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#getDateTime");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServiceApi;

public class ServiceApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// get date and time in OS
[apiInstance getDateTimeWithCompletionHandler: 
              ^('Date' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


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

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

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


            var apiInstance = new ServiceApi();

            try
            {
                // get date and time in OS
                'Date' result = apiInstance.getDateTime();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServiceApi.getDateTime: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

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


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

try: 
    # get date and time in OS
    api_response = api_instance.get_date_time()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServiceApi->getDateTime: %s\n" % e)

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

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

public class ServiceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ServiceApi apiInstance = new ServiceApi();
        try {
            apiInstance.health();
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#health");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServiceApi;

public class ServiceApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// health checker method
[apiInstance healthWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.ServiceApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.health(callback);

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

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


            var apiInstance = new ServiceApi();

            try
            {
                // health checker method
                apiInstance.health();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServiceApi.health: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

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


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

try: 
    # health checker method
    api_instance.health()
except ApiException as e:
    print("Exception when calling ServiceApi->health: %s\n" % e)

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

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

public class ServiceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ServiceApi apiInstance = new ServiceApi();
        try {
            byte[] result = apiInstance.serviceBackup();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#serviceBackup");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServiceApi;

public class ServiceApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// backup system to archive file
[apiInstance serviceBackupWithCompletionHandler: 
              ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


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

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

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


            var apiInstance = new ServiceApi();

            try
            {
                // backup system to archive file
                byte[] result = apiInstance.serviceBackup();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServiceApi.serviceBackup: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

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


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

try: 
    # backup system to archive file
    api_response = api_instance.service_backup()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServiceApi->serviceBackup: %s\n" % e)

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

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

public class ServiceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ServiceApi apiInstance = new ServiceApi();
        try {
            apiInstance.serviceRestart();
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#serviceRestart");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServiceApi;

public class ServiceApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// restart service K2
[apiInstance serviceRestartWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.ServiceApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.serviceRestart(callback);

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

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


            var apiInstance = new ServiceApi();

            try
            {
                // restart service K2
                apiInstance.serviceRestart();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServiceApi.serviceRestart: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

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


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

try: 
    # restart service K2
    api_instance.service_restart()
except ApiException as e:
    print("Exception when calling ServiceApi->serviceRestart: %s\n" % e)

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

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

public class ServiceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ServiceApi apiInstance = new ServiceApi();
        byte[] fileName = fileName_example; // byte[] | 
        try {
            apiInstance.serviceRestore(fileName);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#serviceRestore");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServiceApi;

public class ServiceApiExample {

    public static void main(String[] args) {
        ServiceApi apiInstance = new ServiceApi();
        byte[] fileName = fileName_example; // byte[] | 
        try {
            apiInstance.serviceRestore(fileName);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#serviceRestore");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
byte[] *fileName = fileName_example; // 

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

// restore configuration from archive copy file
[apiInstance serviceRestoreWith:fileName
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.ServiceApi()
var fileName = fileName_example; // {{byte[]}} 

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

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

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


            var apiInstance = new ServiceApi();
            var fileName = fileName_example;  // byte[] | 

            try
            {
                // restore configuration from archive copy file
                apiInstance.serviceRestore(fileName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServiceApi.serviceRestore: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiServiceApi();
$fileName = fileName_example; // byte[] | 

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

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


my $api_instance = WWW::SwaggerClient::ServiceApi->new();
my $fileName = fileName_example; # byte[] | 

eval { 
    $api_instance->serviceRestore(fileName => $fileName);
};
if ($@) {
    warn "Exception when calling ServiceApi->serviceRestore: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.ServiceApi()
fileName = fileName_example # byte[] | 

try: 
    # restore configuration from archive copy file
    api_instance.service_restore(fileName)
except ApiException as e:
    print("Exception when calling ServiceApi->serviceRestore: %s\n" % e)

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

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

public class ServiceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ServiceApi apiInstance = new ServiceApi();
        try {
            apiInstance.serviceShutdow();
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#serviceShutdow");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServiceApi;

public class ServiceApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// shutting down PC
[apiInstance serviceShutdowWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.ServiceApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.serviceShutdow(callback);

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

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


            var apiInstance = new ServiceApi();

            try
            {
                // shutting down PC
                apiInstance.serviceShutdow();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServiceApi.serviceShutdow: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

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


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

try: 
    # shutting down PC
    api_instance.service_shutdow()
except ApiException as e:
    print("Exception when calling ServiceApi->serviceShutdow: %s\n" % e)

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

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

public class ServiceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ServiceApi apiInstance = new ServiceApi();
        DateTime body = ; // DateTime | 
        try {
            apiInstance.setDateTime(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#setDateTime");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServiceApi;

public class ServiceApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
DateTime *body = ; // 

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

// set date and time in OS
[apiInstance setDateTimeWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.ServiceApi()
var body = ; // {{DateTime}} 

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

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

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


            var apiInstance = new ServiceApi();
            var body = new DateTime(); // DateTime | 

            try
            {
                // set date and time in OS
                apiInstance.setDateTime(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServiceApi.setDateTime: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiServiceApi();
$body = ; // DateTime | 

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

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


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

eval { 
    $api_instance->setDateTime(body => $body);
};
if ($@) {
    warn "Exception when calling ServiceApi->setDateTime: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.ServiceApi()
body =  # DateTime | 

try: 
    # set date and time in OS
    api_instance.set_date_time(body)
except ApiException as e:
    print("Exception when calling ServiceApi->setDateTime: %s\n" % e)

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

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

public class ServiceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ServiceApi apiInstance = new ServiceApi();
        try {
            'String' result = apiInstance.version();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#version");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServiceApi;

public class ServiceApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// return information about application
[apiInstance versionWithCompletionHandler: 
              ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


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

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

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


            var apiInstance = new ServiceApi();

            try
            {
                // return information about application
                'String' result = apiInstance.version();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServiceApi.version: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

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


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

try: 
    # return information about application
    api_response = api_instance.version()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServiceApi->version: %s\n" % e)

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

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

public class SystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        SystemApi apiInstance = new SystemApi();
        try {
            SystemInfo result = apiInstance.getSystemInfo();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemApi#getSystemInfo");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SystemApi;

public class SystemApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// get system info
[apiInstance getSystemInfoWithCompletionHandler: 
              ^(SystemInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


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

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

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


            var apiInstance = new SystemApi();

            try
            {
                // get system info
                SystemInfo result = apiInstance.getSystemInfo();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SystemApi.getSystemInfo: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

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


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

try: 
    # get system info
    api_response = api_instance.get_system_info()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SystemApi->getSystemInfo: %s\n" % e)

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

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

public class SystemApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        SystemApi apiInstance = new SystemApi();
        try {
            array['String'] result = apiInstance.getSystemSerialPorts();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemApi#getSystemSerialPorts");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SystemApi;

public class SystemApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// get active system serial ports
[apiInstance getSystemSerialPortsWithCompletionHandler: 
              ^(array['String'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


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

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

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


            var apiInstance = new SystemApi();

            try
            {
                // get active system serial ports
                array['String'] result = apiInstance.getSystemSerialPorts();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SystemApi.getSystemSerialPorts: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

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


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

try: 
    # get active system serial ports
    api_response = api_instance.get_system_serial_ports()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SystemApi->getSystemSerialPorts: %s\n" % e)

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

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

public class SystemLogApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        SystemLogApi apiInstance = new SystemLogApi();
        Date begin = 2013-10-20T19:20:30+01:00; // Date | date and time begin
        Date end = 2013-10-20T19:20:30+01:00; // Date | date and time end
        String level = level_example; // String | filter by log level
        try {
            apiInstance.delSystemLog(begin, end, level);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemLogApi#delSystemLog");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SystemLogApi;

public class SystemLogApiExample {

    public static void main(String[] args) {
        SystemLogApi apiInstance = new SystemLogApi();
        Date begin = 2013-10-20T19:20:30+01:00; // Date | date and time begin
        Date end = 2013-10-20T19:20:30+01:00; // Date | date and time end
        String level = level_example; // String | filter by log level
        try {
            apiInstance.delSystemLog(begin, end, level);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemLogApi#delSystemLog");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Date *begin = 2013-10-20T19:20:30+01:00; // date and time begin (optional)
Date *end = 2013-10-20T19:20:30+01:00; // date and time end (optional)
String *level = level_example; // filter by log level (optional)

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

// delete system log records
[apiInstance delSystemLogWith:begin
    end:end
    level:level
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.SystemLogApi()
var opts = { 
  'begin': 2013-10-20T19:20:30+01:00, // {{Date}} date and time begin
  'end': 2013-10-20T19:20:30+01:00, // {{Date}} date and time end
  'level': level_example // {{String}} filter by log level
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.delSystemLog(opts, callback);

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

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


            var apiInstance = new SystemLogApi();
            var begin = 2013-10-20T19:20:30+01:00;  // Date | date and time begin (optional) 
            var end = 2013-10-20T19:20:30+01:00;  // Date | date and time end (optional) 
            var level = level_example;  // String | filter by log level (optional) 

            try
            {
                // delete system log records
                apiInstance.delSystemLog(begin, end, level);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SystemLogApi.delSystemLog: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiSystemLogApi();
$begin = 2013-10-20T19:20:30+01:00; // Date | date and time begin
$end = 2013-10-20T19:20:30+01:00; // Date | date and time end
$level = level_example; // String | filter by log level

try {
    $api_instance->delSystemLog($begin, $end, $level);
} catch (Exception $e) {
    echo 'Exception when calling SystemLogApi->delSystemLog: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::SystemLogApi->new();
my $begin = 2013-10-20T19:20:30+01:00; # Date | date and time begin
my $end = 2013-10-20T19:20:30+01:00; # Date | date and time end
my $level = level_example; # String | filter by log level

eval { 
    $api_instance->delSystemLog(begin => $begin, end => $end, level => $level);
};
if ($@) {
    warn "Exception when calling SystemLogApi->delSystemLog: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.SystemLogApi()
begin = 2013-10-20T19:20:30+01:00 # Date | date and time begin (optional)
end = 2013-10-20T19:20:30+01:00 # Date | date and time end (optional)
level = level_example # String | filter by log level (optional)

try: 
    # delete system log records
    api_instance.del_system_log(begin=begin, end=end, level=level)
except ApiException as e:
    print("Exception when calling SystemLogApi->delSystemLog: %s\n" % e)

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

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

public class SystemLogApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        SystemLogApi apiInstance = new SystemLogApi();
        Date begin = 2013-10-20T19:20:30+01:00; // Date | date and time begin
        Date end = 2013-10-20T19:20:30+01:00; // Date | date and time end
        String level = level_example; // String | filter by log level
        try {
            array[SystemLogRecord] result = apiInstance.getSystemLog(begin, end, level);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemLogApi#getSystemLog");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SystemLogApi;

public class SystemLogApiExample {

    public static void main(String[] args) {
        SystemLogApi apiInstance = new SystemLogApi();
        Date begin = 2013-10-20T19:20:30+01:00; // Date | date and time begin
        Date end = 2013-10-20T19:20:30+01:00; // Date | date and time end
        String level = level_example; // String | filter by log level
        try {
            array[SystemLogRecord] result = apiInstance.getSystemLog(begin, end, level);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemLogApi#getSystemLog");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Date *begin = 2013-10-20T19:20:30+01:00; // date and time begin (optional)
Date *end = 2013-10-20T19:20:30+01:00; // date and time end (optional)
String *level = level_example; // filter by log level (optional)

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

// get system log records
[apiInstance getSystemLogWith:begin
    end:end
    level:level
              completionHandler: ^(array[SystemLogRecord] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.SystemLogApi()
var opts = { 
  'begin': 2013-10-20T19:20:30+01:00, // {{Date}} date and time begin
  'end': 2013-10-20T19:20:30+01:00, // {{Date}} date and time end
  'level': level_example // {{String}} filter by log level
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSystemLog(opts, callback);

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

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


            var apiInstance = new SystemLogApi();
            var begin = 2013-10-20T19:20:30+01:00;  // Date | date and time begin (optional) 
            var end = 2013-10-20T19:20:30+01:00;  // Date | date and time end (optional) 
            var level = level_example;  // String | filter by log level (optional) 

            try
            {
                // get system log records
                array[SystemLogRecord] result = apiInstance.getSystemLog(begin, end, level);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SystemLogApi.getSystemLog: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiSystemLogApi();
$begin = 2013-10-20T19:20:30+01:00; // Date | date and time begin
$end = 2013-10-20T19:20:30+01:00; // Date | date and time end
$level = level_example; // String | filter by log level

try {
    $result = $api_instance->getSystemLog($begin, $end, $level);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SystemLogApi->getSystemLog: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::SystemLogApi->new();
my $begin = 2013-10-20T19:20:30+01:00; # Date | date and time begin
my $end = 2013-10-20T19:20:30+01:00; # Date | date and time end
my $level = level_example; # String | filter by log level

eval { 
    my $result = $api_instance->getSystemLog(begin => $begin, end => $end, level => $level);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SystemLogApi->getSystemLog: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.SystemLogApi()
begin = 2013-10-20T19:20:30+01:00 # Date | date and time begin (optional)
end = 2013-10-20T19:20:30+01:00 # Date | date and time end (optional)
level = level_example # String | filter by log level (optional)

try: 
    # get system log records
    api_response = api_instance.get_system_log(begin=begin, end=end, level=level)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SystemLogApi->getSystemLog: %s\n" % e)

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

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

public class UsersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        UsersApi apiInstance = new UsersApi();
        Long payload = 789; // Long | user id
        try {
            User result = apiInstance.getUserById(payload);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#getUserById");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        Long payload = 789; // Long | user id
        try {
            User result = apiInstance.getUserById(payload);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#getUserById");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Long *payload = 789; // user id

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

// get user by id
[apiInstance getUserByIdWith:payload
              completionHandler: ^(User output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.UsersApi()
var payload = 789; // {{Long}} user id

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

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

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


            var apiInstance = new UsersApi();
            var payload = 789;  // Long | user id

            try
            {
                // get user by id
                User result = apiInstance.getUserById(payload);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.getUserById: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiUsersApi();
$payload = 789; // Long | user id

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

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


my $api_instance = WWW::SwaggerClient::UsersApi->new();
my $payload = 789; # Long | user id

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

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


# create an instance of the API class
api_instance = swagger_client.UsersApi()
payload = 789 # Long | user id

try: 
    # get user by id
    api_response = api_instance.get_user_by_id(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->getUserById: %s\n" % e)

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

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

public class UsersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        UsersApi apiInstance = new UsersApi();
        String payload = payload_example; // String | user name
        try {
            User result = apiInstance.getUserByName(payload);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#getUserByName");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        String payload = payload_example; // String | user name
        try {
            User result = apiInstance.getUserByName(payload);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#getUserByName");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *payload = payload_example; // user name

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

// get user by name
[apiInstance getUserByNameWith:payload
              completionHandler: ^(User output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.UsersApi()
var payload = payload_example; // {{String}} user name

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

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

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


            var apiInstance = new UsersApi();
            var payload = payload_example;  // String | user name

            try
            {
                // get user by name
                User result = apiInstance.getUserByName(payload);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.getUserByName: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiUsersApi();
$payload = payload_example; // String | user name

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

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


my $api_instance = WWW::SwaggerClient::UsersApi->new();
my $payload = payload_example; # String | user name

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

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


# create an instance of the API class
api_instance = swagger_client.UsersApi()
payload = payload_example # String | user name

try: 
    # get user by name
    api_response = api_instance.get_user_by_name(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->getUserByName: %s\n" % e)

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

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

public class UsersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        UsersApi apiInstance = new UsersApi();
        try {
            User result = apiInstance.getUserByToken();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#getUserByToken");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// get user by authorization token
[apiInstance getUserByTokenWithCompletionHandler: 
              ^(User output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


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

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

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


            var apiInstance = new UsersApi();

            try
            {
                // get user by authorization token
                User result = apiInstance.getUserByToken();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.getUserByToken: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

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


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

try: 
    # get user by authorization token
    api_response = api_instance.get_user_by_token()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->getUserByToken: %s\n" % e)

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

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

public class UsersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        UsersApi apiInstance = new UsersApi();
        try {
            array[User] result = apiInstance.getUserList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#getUserList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// get user list
[apiInstance getUserListWithCompletionHandler: 
              ^(array[User] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


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

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

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


            var apiInstance = new UsersApi();

            try
            {
                // get user list
                array[User] result = apiInstance.getUserList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.getUserList: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

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


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

try: 
    # get user list
    api_response = api_instance.get_user_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->getUserList: %s\n" % e)

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

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

public class UsersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        UsersApi apiInstance = new UsersApi();
        User body = ; // User | 
        try {
            User result = apiInstance.userCreateOrUpdate(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#userCreateOrUpdate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
User *body = ; // 

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

// create or update user
[apiInstance userCreateOrUpdateWith:body
              completionHandler: ^(User output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.UsersApi()
var body = ; // {{User}} 

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

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

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


            var apiInstance = new UsersApi();
            var body = new User(); // User | 

            try
            {
                // create or update user
                User result = apiInstance.userCreateOrUpdate(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.userCreateOrUpdate: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiUsersApi();
$body = ; // User | 

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

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


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

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

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


# create an instance of the API class
api_instance = swagger_client.UsersApi()
body =  # User | 

try: 
    # create or update user
    api_response = api_instance.user_create_or_update(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->userCreateOrUpdate: %s\n" % e)

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

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

public class UsersActionsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        UsersActionsApi apiInstance = new UsersActionsApi();
        Date begin = 2013-10-20T19:20:30+01:00; // Date | date and time begin
        Date end = 2013-10-20T19:20:30+01:00; // Date | date and time end
        String action = action_example; // String | filter by users action
        try {
            array[UsersLogEntry] result = apiInstance.getUsersLog(begin, end, action);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersActionsApi#getUsersLog");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersActionsApi;

public class UsersActionsApiExample {

    public static void main(String[] args) {
        UsersActionsApi apiInstance = new UsersActionsApi();
        Date begin = 2013-10-20T19:20:30+01:00; // Date | date and time begin
        Date end = 2013-10-20T19:20:30+01:00; // Date | date and time end
        String action = action_example; // String | filter by users action
        try {
            array[UsersLogEntry] result = apiInstance.getUsersLog(begin, end, action);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersActionsApi#getUsersLog");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Date *begin = 2013-10-20T19:20:30+01:00; // date and time begin (optional)
Date *end = 2013-10-20T19:20:30+01:00; // date and time end (optional)
String *action = action_example; // filter by users action (optional)

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

// get users actions entries
[apiInstance getUsersLogWith:begin
    end:end
    action:action
              completionHandler: ^(array[UsersLogEntry] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrezorK2HttpApi = require('trezor_k_2_http_api');
var defaultClient = TrezorK2HttpApi.ApiClient.instance;


var api = new TrezorK2HttpApi.UsersActionsApi()
var opts = { 
  'begin': 2013-10-20T19:20:30+01:00, // {{Date}} date and time begin
  'end': 2013-10-20T19:20:30+01:00, // {{Date}} date and time end
  'action': action_example // {{String}} filter by users action
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUsersLog(opts, callback);

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

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


            var apiInstance = new UsersActionsApi();
            var begin = 2013-10-20T19:20:30+01:00;  // Date | date and time begin (optional) 
            var end = 2013-10-20T19:20:30+01:00;  // Date | date and time end (optional) 
            var action = action_example;  // String | filter by users action (optional) 

            try
            {
                // get users actions entries
                array[UsersLogEntry] result = apiInstance.getUsersLog(begin, end, action);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersActionsApi.getUsersLog: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiUsersActionsApi();
$begin = 2013-10-20T19:20:30+01:00; // Date | date and time begin
$end = 2013-10-20T19:20:30+01:00; // Date | date and time end
$action = action_example; // String | filter by users action

try {
    $result = $api_instance->getUsersLog($begin, $end, $action);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UsersActionsApi->getUsersLog: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::UsersActionsApi->new();
my $begin = 2013-10-20T19:20:30+01:00; # Date | date and time begin
my $end = 2013-10-20T19:20:30+01:00; # Date | date and time end
my $action = action_example; # String | filter by users action

eval { 
    my $result = $api_instance->getUsersLog(begin => $begin, end => $end, action => $action);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersActionsApi->getUsersLog: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.UsersActionsApi()
begin = 2013-10-20T19:20:30+01:00 # Date | date and time begin (optional)
end = 2013-10-20T19:20:30+01:00 # Date | date and time end (optional)
action = action_example # String | filter by users action (optional)

try: 
    # get users actions entries
    api_response = api_instance.get_users_log(begin=begin, end=end, action=action)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersActionsApi->getUsersLog: %s\n" % e)