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

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

public class AICAApiExample {

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

import io.swagger.client.api.AICAApi;

public class AICAApiExample {

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

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

// API Version
[apiInstance getVersionWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.AICAApi()

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

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

namespace Example
{
    public class getVersionExample
    {
        public void main()
        {
            
            var apiInstance = new AICAApi();

            try
            {
                // API Version
                apiInstance.getVersion();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AICAApi.getVersion: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    $api_instance->getVersion();
};
if ($@) {
    warn "Exception when calling AICAApi->getVersion: $@\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.AICAApi()

try: 
    # API Version
    api_instance.get_version()
except ApiException as e:
    print("Exception when calling AICAApi->getVersion: %s\n" % e)

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

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

public class ApplicationsApiExample {

    public static void main(String[] args) {
        
        ApplicationsApi apiInstance = new ApplicationsApi();
        String serviceName = serviceName_example; // String | The name of the service
        String componentName = componentName_example; // String | The name of the component
        Payload_1 payload = ; // Payload_1 | 
        try {
            apiInstance.callService(serviceName, componentName, payload);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationsApi#callService");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApplicationsApi;

public class ApplicationsApiExample {

    public static void main(String[] args) {
        ApplicationsApi apiInstance = new ApplicationsApi();
        String serviceName = serviceName_example; // String | The name of the service
        String componentName = componentName_example; // String | The name of the component
        Payload_1 payload = ; // Payload_1 | 
        try {
            apiInstance.callService(serviceName, componentName, payload);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationsApi#callService");
            e.printStackTrace();
        }
    }
}

String *serviceName = serviceName_example; // The name of the service
String *componentName = componentName_example; // The name of the component
Payload_1 *payload = ; // 

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

// Call a service on a component
[apiInstance callServiceWith:serviceName
    componentName:componentName
    payload:payload
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.ApplicationsApi()

var serviceName = serviceName_example; // {String} The name of the service

var componentName = componentName_example; // {String} The name of the component

var payload = ; // {Payload_1} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.callService(serviceName, componentName, payload, callback);

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

namespace Example
{
    public class callServiceExample
    {
        public void main()
        {
            
            var apiInstance = new ApplicationsApi();
            var serviceName = serviceName_example;  // String | The name of the service
            var componentName = componentName_example;  // String | The name of the component
            var payload = new Payload_1(); // Payload_1 | 

            try
            {
                // Call a service on a component
                apiInstance.callService(serviceName, componentName, payload);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApplicationsApi.callService: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ApplicationsApi();
$serviceName = serviceName_example; // String | The name of the service
$componentName = componentName_example; // String | The name of the component
$payload = ; // Payload_1 | 

try {
    $api_instance->callService($serviceName, $componentName, $payload);
} catch (Exception $e) {
    echo 'Exception when calling ApplicationsApi->callService: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::ApplicationsApi->new();
my $serviceName = serviceName_example; # String | The name of the service
my $componentName = componentName_example; # String | The name of the component
my $payload = WWW::SwaggerClient::Object::Payload_1->new(); # Payload_1 | 

eval { 
    $api_instance->callService(serviceName => $serviceName, componentName => $componentName, payload => $payload);
};
if ($@) {
    warn "Exception when calling ApplicationsApi->callService: $@\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.ApplicationsApi()
serviceName = serviceName_example # String | The name of the service
componentName = componentName_example # String | The name of the component
payload =  # Payload_1 | 

try: 
    # Call a service on a component
    api_instance.call_service(serviceName, componentName, payload)
except ApiException as e:
    print("Exception when calling ApplicationsApi->callService: %s\n" % e)

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

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

public class ApplicationsApiExample {

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

import io.swagger.client.api.ApplicationsApi;

public class ApplicationsApiExample {

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

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

// Get the current application
[apiInstance getApplicationWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.ApplicationsApi()

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

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

namespace Example
{
    public class getApplicationExample
    {
        public void main()
        {
            
            var apiInstance = new ApplicationsApi();

            try
            {
                // Get the current application
                apiInstance.getApplication();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApplicationsApi.getApplication: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    $api_instance->getApplication();
};
if ($@) {
    warn "Exception when calling ApplicationsApi->getApplication: $@\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.ApplicationsApi()

try: 
    # Get the current application
    api_instance.get_application()
except ApiException as e:
    print("Exception when calling ApplicationsApi->getApplication: %s\n" % e)

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

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

public class ApplicationsApiExample {

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

import io.swagger.client.api.ApplicationsApi;

public class ApplicationsApiExample {

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

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

// Get the application state
[apiInstance getApplicationStateWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.ApplicationsApi()

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

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

namespace Example
{
    public class getApplicationStateExample
    {
        public void main()
        {
            
            var apiInstance = new ApplicationsApi();

            try
            {
                // Get the application state
                apiInstance.getApplicationState();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApplicationsApi.getApplicationState: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    $api_instance->getApplicationState();
};
if ($@) {
    warn "Exception when calling ApplicationsApi->getApplicationState: $@\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.ApplicationsApi()

try: 
    # Get the application state
    api_instance.get_application_state()
except ApiException as e:
    print("Exception when calling ApplicationsApi->getApplicationState: %s\n" % e)

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

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

public class ApplicationsApiExample {

    public static void main(String[] args) {
        
        ApplicationsApi apiInstance = new ApplicationsApi();
        String componentName = componentName_example; // String | The name of the component
        try {
            apiInstance.loadComponent(componentName);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationsApi#loadComponent");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApplicationsApi;

public class ApplicationsApiExample {

    public static void main(String[] args) {
        ApplicationsApi apiInstance = new ApplicationsApi();
        String componentName = componentName_example; // String | The name of the component
        try {
            apiInstance.loadComponent(componentName);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationsApi#loadComponent");
            e.printStackTrace();
        }
    }
}

String *componentName = componentName_example; // The name of the component

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

// Load a component
[apiInstance loadComponentWith:componentName
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.ApplicationsApi()

var componentName = componentName_example; // {String} The name of the component


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

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

namespace Example
{
    public class loadComponentExample
    {
        public void main()
        {
            
            var apiInstance = new ApplicationsApi();
            var componentName = componentName_example;  // String | The name of the component

            try
            {
                // Load a component
                apiInstance.loadComponent(componentName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApplicationsApi.loadComponent: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ApplicationsApi();
$componentName = componentName_example; // String | The name of the component

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

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

my $api_instance = WWW::SwaggerClient::ApplicationsApi->new();
my $componentName = componentName_example; # String | The name of the component

eval { 
    $api_instance->loadComponent(componentName => $componentName);
};
if ($@) {
    warn "Exception when calling ApplicationsApi->loadComponent: $@\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.ApplicationsApi()
componentName = componentName_example # String | The name of the component

try: 
    # Load a component
    api_instance.load_component(componentName)
except ApiException as e:
    print("Exception when calling ApplicationsApi->loadComponent: %s\n" % e)

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

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

public class ApplicationsApiExample {

    public static void main(String[] args) {
        
        ApplicationsApi apiInstance = new ApplicationsApi();
        String controllerName = controllerName_example; // String | The name of the controller
        String hardwareName = hardwareName_example; // String | The name of the hardware
        try {
            apiInstance.loadController(controllerName, hardwareName);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationsApi#loadController");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApplicationsApi;

public class ApplicationsApiExample {

    public static void main(String[] args) {
        ApplicationsApi apiInstance = new ApplicationsApi();
        String controllerName = controllerName_example; // String | The name of the controller
        String hardwareName = hardwareName_example; // String | The name of the hardware
        try {
            apiInstance.loadController(controllerName, hardwareName);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationsApi#loadController");
            e.printStackTrace();
        }
    }
}

String *controllerName = controllerName_example; // The name of the controller
String *hardwareName = hardwareName_example; // The name of the hardware

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

// Load a controller
[apiInstance loadControllerWith:controllerName
    hardwareName:hardwareName
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.ApplicationsApi()

var controllerName = controllerName_example; // {String} The name of the controller

var hardwareName = hardwareName_example; // {String} The name of the hardware


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

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

namespace Example
{
    public class loadControllerExample
    {
        public void main()
        {
            
            var apiInstance = new ApplicationsApi();
            var controllerName = controllerName_example;  // String | The name of the controller
            var hardwareName = hardwareName_example;  // String | The name of the hardware

            try
            {
                // Load a controller
                apiInstance.loadController(controllerName, hardwareName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApplicationsApi.loadController: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ApplicationsApi();
$controllerName = controllerName_example; // String | The name of the controller
$hardwareName = hardwareName_example; // String | The name of the hardware

try {
    $api_instance->loadController($controllerName, $hardwareName);
} catch (Exception $e) {
    echo 'Exception when calling ApplicationsApi->loadController: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::ApplicationsApi->new();
my $controllerName = controllerName_example; # String | The name of the controller
my $hardwareName = hardwareName_example; # String | The name of the hardware

eval { 
    $api_instance->loadController(controllerName => $controllerName, hardwareName => $hardwareName);
};
if ($@) {
    warn "Exception when calling ApplicationsApi->loadController: $@\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.ApplicationsApi()
controllerName = controllerName_example # String | The name of the controller
hardwareName = hardwareName_example # String | The name of the hardware

try: 
    # Load a controller
    api_instance.load_controller(controllerName, hardwareName)
except ApiException as e:
    print("Exception when calling ApplicationsApi->loadController: %s\n" % e)

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

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

public class ApplicationsApiExample {

    public static void main(String[] args) {
        
        ApplicationsApi apiInstance = new ApplicationsApi();
        String hardwareName = hardwareName_example; // String | The name of the hardware
        try {
            apiInstance.loadHardware(hardwareName);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationsApi#loadHardware");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApplicationsApi;

public class ApplicationsApiExample {

    public static void main(String[] args) {
        ApplicationsApi apiInstance = new ApplicationsApi();
        String hardwareName = hardwareName_example; // String | The name of the hardware
        try {
            apiInstance.loadHardware(hardwareName);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationsApi#loadHardware");
            e.printStackTrace();
        }
    }
}

String *hardwareName = hardwareName_example; // The name of the hardware

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

// Load a hardware interface
[apiInstance loadHardwareWith:hardwareName
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.ApplicationsApi()

var hardwareName = hardwareName_example; // {String} The name of the hardware


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

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

namespace Example
{
    public class loadHardwareExample
    {
        public void main()
        {
            
            var apiInstance = new ApplicationsApi();
            var hardwareName = hardwareName_example;  // String | The name of the hardware

            try
            {
                // Load a hardware interface
                apiInstance.loadHardware(hardwareName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApplicationsApi.loadHardware: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ApplicationsApi();
$hardwareName = hardwareName_example; // String | The name of the hardware

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

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

my $api_instance = WWW::SwaggerClient::ApplicationsApi->new();
my $hardwareName = hardwareName_example; # String | The name of the hardware

eval { 
    $api_instance->loadHardware(hardwareName => $hardwareName);
};
if ($@) {
    warn "Exception when calling ApplicationsApi->loadHardware: $@\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.ApplicationsApi()
hardwareName = hardwareName_example # String | The name of the hardware

try: 
    # Load a hardware interface
    api_instance.load_hardware(hardwareName)
except ApiException as e:
    print("Exception when calling ApplicationsApi->loadHardware: %s\n" % e)

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

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

public class ApplicationsApiExample {

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

import io.swagger.client.api.ApplicationsApi;

public class ApplicationsApiExample {

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

Payload *payload = ; // 

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

// Set the application
[apiInstance setApplicationWith:payload
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.ApplicationsApi()

var payload = ; // {Payload} 


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

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

namespace Example
{
    public class setApplicationExample
    {
        public void main()
        {
            
            var apiInstance = new ApplicationsApi();
            var payload = new Payload(); // Payload | 

            try
            {
                // Set the application
                apiInstance.setApplication(payload);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApplicationsApi.setApplication: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ApplicationsApi();
$payload = ; // Payload | 

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

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

my $api_instance = WWW::SwaggerClient::ApplicationsApi->new();
my $payload = WWW::SwaggerClient::Object::Payload->new(); # Payload | 

eval { 
    $api_instance->setApplication(payload => $payload);
};
if ($@) {
    warn "Exception when calling ApplicationsApi->setApplication: $@\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.ApplicationsApi()
payload =  # Payload | 

try: 
    # Set the application
    api_instance.set_application(payload)
except ApiException as e:
    print("Exception when calling ApplicationsApi->setApplication: %s\n" % e)

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

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

public class ApplicationsApiExample {

    public static void main(String[] args) {
        
        ApplicationsApi apiInstance = new ApplicationsApi();
        String action = action_example; // String | Bad choice: {error_msg}
        try {
            apiInstance.setApplicationTransition(action);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationsApi#setApplicationTransition");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApplicationsApi;

public class ApplicationsApiExample {

    public static void main(String[] args) {
        ApplicationsApi apiInstance = new ApplicationsApi();
        String action = action_example; // String | Bad choice: {error_msg}
        try {
            apiInstance.setApplicationTransition(action);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationsApi#setApplicationTransition");
            e.printStackTrace();
        }
    }
}

String *action = action_example; // Bad choice: {error_msg}

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

// Set an application state transition
[apiInstance setApplicationTransitionWith:action
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.ApplicationsApi()

var action = action_example; // {String} Bad choice: {error_msg}


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

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

namespace Example
{
    public class setApplicationTransitionExample
    {
        public void main()
        {
            
            var apiInstance = new ApplicationsApi();
            var action = action_example;  // String | Bad choice: {error_msg}

            try
            {
                // Set an application state transition
                apiInstance.setApplicationTransition(action);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApplicationsApi.setApplicationTransition: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ApplicationsApi();
$action = action_example; // String | Bad choice: {error_msg}

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

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

my $api_instance = WWW::SwaggerClient::ApplicationsApi->new();
my $action = action_example; # String | Bad choice: {error_msg}

eval { 
    $api_instance->setApplicationTransition(action => $action);
};
if ($@) {
    warn "Exception when calling ApplicationsApi->setApplicationTransition: $@\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.ApplicationsApi()
action = action_example # String | Bad choice: {error_msg}

try: 
    # Set an application state transition
    api_instance.set_application_transition(action)
except ApiException as e:
    print("Exception when calling ApplicationsApi->setApplicationTransition: %s\n" % e)

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

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

public class ApplicationsApiExample {

    public static void main(String[] args) {
        
        ApplicationsApi apiInstance = new ApplicationsApi();
        String parameterName = parameterName_example; // String | The name of the parameter
        String controllerName = controllerName_example; // String | The name of the controller
        String hardwareName = hardwareName_example; // String | The name of the hardware
        Parameter_value payload = ; // Parameter_value | 
        try {
            apiInstance.setControllerParameter(parameterName, controllerName, hardwareName, payload);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationsApi#setControllerParameter");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApplicationsApi;

public class ApplicationsApiExample {

    public static void main(String[] args) {
        ApplicationsApi apiInstance = new ApplicationsApi();
        String parameterName = parameterName_example; // String | The name of the parameter
        String controllerName = controllerName_example; // String | The name of the controller
        String hardwareName = hardwareName_example; // String | The name of the hardware
        Parameter_value payload = ; // Parameter_value | 
        try {
            apiInstance.setControllerParameter(parameterName, controllerName, hardwareName, payload);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationsApi#setControllerParameter");
            e.printStackTrace();
        }
    }
}

String *parameterName = parameterName_example; // The name of the parameter
String *controllerName = controllerName_example; // The name of the controller
String *hardwareName = hardwareName_example; // The name of the hardware
Parameter_value *payload = ; // 

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

// Set a parameter on a controller
[apiInstance setControllerParameterWith:parameterName
    controllerName:controllerName
    hardwareName:hardwareName
    payload:payload
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.ApplicationsApi()

var parameterName = parameterName_example; // {String} The name of the parameter

var controllerName = controllerName_example; // {String} The name of the controller

var hardwareName = hardwareName_example; // {String} The name of the hardware

var payload = ; // {Parameter_value} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.setControllerParameter(parameterName, controllerName, hardwareName, payload, callback);

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

namespace Example
{
    public class setControllerParameterExample
    {
        public void main()
        {
            
            var apiInstance = new ApplicationsApi();
            var parameterName = parameterName_example;  // String | The name of the parameter
            var controllerName = controllerName_example;  // String | The name of the controller
            var hardwareName = hardwareName_example;  // String | The name of the hardware
            var payload = new Parameter_value(); // Parameter_value | 

            try
            {
                // Set a parameter on a controller
                apiInstance.setControllerParameter(parameterName, controllerName, hardwareName, payload);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApplicationsApi.setControllerParameter: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ApplicationsApi();
$parameterName = parameterName_example; // String | The name of the parameter
$controllerName = controllerName_example; // String | The name of the controller
$hardwareName = hardwareName_example; // String | The name of the hardware
$payload = ; // Parameter_value | 

try {
    $api_instance->setControllerParameter($parameterName, $controllerName, $hardwareName, $payload);
} catch (Exception $e) {
    echo 'Exception when calling ApplicationsApi->setControllerParameter: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::ApplicationsApi->new();
my $parameterName = parameterName_example; # String | The name of the parameter
my $controllerName = controllerName_example; # String | The name of the controller
my $hardwareName = hardwareName_example; # String | The name of the hardware
my $payload = WWW::SwaggerClient::Object::Parameter_value->new(); # Parameter_value | 

eval { 
    $api_instance->setControllerParameter(parameterName => $parameterName, controllerName => $controllerName, hardwareName => $hardwareName, payload => $payload);
};
if ($@) {
    warn "Exception when calling ApplicationsApi->setControllerParameter: $@\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.ApplicationsApi()
parameterName = parameterName_example # String | The name of the parameter
controllerName = controllerName_example # String | The name of the controller
hardwareName = hardwareName_example # String | The name of the hardware
payload =  # Parameter_value | 

try: 
    # Set a parameter on a controller
    api_instance.set_controller_parameter(parameterName, controllerName, hardwareName, payload)
except ApiException as e:
    print("Exception when calling ApplicationsApi->setControllerParameter: %s\n" % e)

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

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

public class ApplicationsApiExample {

    public static void main(String[] args) {
        
        ApplicationsApi apiInstance = new ApplicationsApi();
        String componentName = componentName_example; // String | The name of the component
        String transition = transition_example; // String | Bad choice: {error_msg}
        try {
            apiInstance.setLifecycleTransition(componentName, transition);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationsApi#setLifecycleTransition");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApplicationsApi;

public class ApplicationsApiExample {

    public static void main(String[] args) {
        ApplicationsApi apiInstance = new ApplicationsApi();
        String componentName = componentName_example; // String | The name of the component
        String transition = transition_example; // String | Bad choice: {error_msg}
        try {
            apiInstance.setLifecycleTransition(componentName, transition);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationsApi#setLifecycleTransition");
            e.printStackTrace();
        }
    }
}

String *componentName = componentName_example; // The name of the component
String *transition = transition_example; // Bad choice: {error_msg}

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

// Set a lifecycle transition on a component
[apiInstance setLifecycleTransitionWith:componentName
    transition:transition
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.ApplicationsApi()

var componentName = componentName_example; // {String} The name of the component

var transition = transition_example; // {String} Bad choice: {error_msg}


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

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

namespace Example
{
    public class setLifecycleTransitionExample
    {
        public void main()
        {
            
            var apiInstance = new ApplicationsApi();
            var componentName = componentName_example;  // String | The name of the component
            var transition = transition_example;  // String | Bad choice: {error_msg}

            try
            {
                // Set a lifecycle transition on a component
                apiInstance.setLifecycleTransition(componentName, transition);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApplicationsApi.setLifecycleTransition: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ApplicationsApi();
$componentName = componentName_example; // String | The name of the component
$transition = transition_example; // String | Bad choice: {error_msg}

try {
    $api_instance->setLifecycleTransition($componentName, $transition);
} catch (Exception $e) {
    echo 'Exception when calling ApplicationsApi->setLifecycleTransition: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::ApplicationsApi->new();
my $componentName = componentName_example; # String | The name of the component
my $transition = transition_example; # String | Bad choice: {error_msg}

eval { 
    $api_instance->setLifecycleTransition(componentName => $componentName, transition => $transition);
};
if ($@) {
    warn "Exception when calling ApplicationsApi->setLifecycleTransition: $@\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.ApplicationsApi()
componentName = componentName_example # String | The name of the component
transition = transition_example # String | Bad choice: {error_msg}

try: 
    # Set a lifecycle transition on a component
    api_instance.set_lifecycle_transition(componentName, transition)
except ApiException as e:
    print("Exception when calling ApplicationsApi->setLifecycleTransition: %s\n" % e)

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

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

public class ApplicationsApiExample {

    public static void main(String[] args) {
        
        ApplicationsApi apiInstance = new ApplicationsApi();
        String parameterName = parameterName_example; // String | The name of the parameter
        String componentName = componentName_example; // String | The name of the component
        Parameter_value payload = ; // Parameter_value | 
        try {
            apiInstance.setParameter(parameterName, componentName, payload);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationsApi#setParameter");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApplicationsApi;

public class ApplicationsApiExample {

    public static void main(String[] args) {
        ApplicationsApi apiInstance = new ApplicationsApi();
        String parameterName = parameterName_example; // String | The name of the parameter
        String componentName = componentName_example; // String | The name of the component
        Parameter_value payload = ; // Parameter_value | 
        try {
            apiInstance.setParameter(parameterName, componentName, payload);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationsApi#setParameter");
            e.printStackTrace();
        }
    }
}

String *parameterName = parameterName_example; // The name of the parameter
String *componentName = componentName_example; // The name of the component
Parameter_value *payload = ; // 

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

// Set a parameter on a component
[apiInstance setParameterWith:parameterName
    componentName:componentName
    payload:payload
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.ApplicationsApi()

var parameterName = parameterName_example; // {String} The name of the parameter

var componentName = componentName_example; // {String} The name of the component

var payload = ; // {Parameter_value} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.setParameter(parameterName, componentName, payload, callback);

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

namespace Example
{
    public class setParameterExample
    {
        public void main()
        {
            
            var apiInstance = new ApplicationsApi();
            var parameterName = parameterName_example;  // String | The name of the parameter
            var componentName = componentName_example;  // String | The name of the component
            var payload = new Parameter_value(); // Parameter_value | 

            try
            {
                // Set a parameter on a component
                apiInstance.setParameter(parameterName, componentName, payload);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApplicationsApi.setParameter: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ApplicationsApi();
$parameterName = parameterName_example; // String | The name of the parameter
$componentName = componentName_example; // String | The name of the component
$payload = ; // Parameter_value | 

try {
    $api_instance->setParameter($parameterName, $componentName, $payload);
} catch (Exception $e) {
    echo 'Exception when calling ApplicationsApi->setParameter: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::ApplicationsApi->new();
my $parameterName = parameterName_example; # String | The name of the parameter
my $componentName = componentName_example; # String | The name of the component
my $payload = WWW::SwaggerClient::Object::Parameter_value->new(); # Parameter_value | 

eval { 
    $api_instance->setParameter(parameterName => $parameterName, componentName => $componentName, payload => $payload);
};
if ($@) {
    warn "Exception when calling ApplicationsApi->setParameter: $@\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.ApplicationsApi()
parameterName = parameterName_example # String | The name of the parameter
componentName = componentName_example # String | The name of the component
payload =  # Parameter_value | 

try: 
    # Set a parameter on a component
    api_instance.set_parameter(parameterName, componentName, payload)
except ApiException as e:
    print("Exception when calling ApplicationsApi->setParameter: %s\n" % e)

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

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

public class ApplicationsApiExample {

    public static void main(String[] args) {
        
        ApplicationsApi apiInstance = new ApplicationsApi();
        String hardwareName = hardwareName_example; // String | The name of the hardware
        array[String] activate = ; // array[String] | Expected the name of a controller to be activated ({error_msg})
        array[String] deactivate = ; // array[String] | Expected the name of a controller to be deactivated ({error_msg})
        try {
            apiInstance.switchControllers(hardwareName, activate, deactivate);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationsApi#switchControllers");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApplicationsApi;

public class ApplicationsApiExample {

    public static void main(String[] args) {
        ApplicationsApi apiInstance = new ApplicationsApi();
        String hardwareName = hardwareName_example; // String | The name of the hardware
        array[String] activate = ; // array[String] | Expected the name of a controller to be activated ({error_msg})
        array[String] deactivate = ; // array[String] | Expected the name of a controller to be deactivated ({error_msg})
        try {
            apiInstance.switchControllers(hardwareName, activate, deactivate);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationsApi#switchControllers");
            e.printStackTrace();
        }
    }
}

String *hardwareName = hardwareName_example; // The name of the hardware
array[String] *activate = ; // Expected the name of a controller to be activated ({error_msg}) (optional) (default to [])
array[String] *deactivate = ; // Expected the name of a controller to be deactivated ({error_msg}) (optional) (default to [])

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

// Switch one or several controllers
[apiInstance switchControllersWith:hardwareName
    activate:activate
    deactivate:deactivate
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.ApplicationsApi()

var hardwareName = hardwareName_example; // {String} The name of the hardware

var opts = { 
  'activate': , // {array[String]} Expected the name of a controller to be activated ({error_msg})
  'deactivate':  // {array[String]} Expected the name of a controller to be deactivated ({error_msg})
};

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

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

namespace Example
{
    public class switchControllersExample
    {
        public void main()
        {
            
            var apiInstance = new ApplicationsApi();
            var hardwareName = hardwareName_example;  // String | The name of the hardware
            var activate = new array[String](); // array[String] | Expected the name of a controller to be activated ({error_msg}) (optional)  (default to [])
            var deactivate = new array[String](); // array[String] | Expected the name of a controller to be deactivated ({error_msg}) (optional)  (default to [])

            try
            {
                // Switch one or several controllers
                apiInstance.switchControllers(hardwareName, activate, deactivate);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApplicationsApi.switchControllers: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ApplicationsApi();
$hardwareName = hardwareName_example; // String | The name of the hardware
$activate = ; // array[String] | Expected the name of a controller to be activated ({error_msg})
$deactivate = ; // array[String] | Expected the name of a controller to be deactivated ({error_msg})

try {
    $api_instance->switchControllers($hardwareName, $activate, $deactivate);
} catch (Exception $e) {
    echo 'Exception when calling ApplicationsApi->switchControllers: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::ApplicationsApi->new();
my $hardwareName = hardwareName_example; # String | The name of the hardware
my $activate = []; # array[String] | Expected the name of a controller to be activated ({error_msg})
my $deactivate = []; # array[String] | Expected the name of a controller to be deactivated ({error_msg})

eval { 
    $api_instance->switchControllers(hardwareName => $hardwareName, activate => $activate, deactivate => $deactivate);
};
if ($@) {
    warn "Exception when calling ApplicationsApi->switchControllers: $@\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.ApplicationsApi()
hardwareName = hardwareName_example # String | The name of the hardware
activate =  # array[String] | Expected the name of a controller to be activated ({error_msg}) (optional) (default to [])
deactivate =  # array[String] | Expected the name of a controller to be deactivated ({error_msg}) (optional) (default to [])

try: 
    # Switch one or several controllers
    api_instance.switch_controllers(hardwareName, activate=activate, deactivate=deactivate)
except ApiException as e:
    print("Exception when calling ApplicationsApi->switchControllers: %s\n" % e)

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

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

public class ApplicationsApiExample {

    public static void main(String[] args) {
        
        ApplicationsApi apiInstance = new ApplicationsApi();
        String componentName = componentName_example; // String | The name of the component
        try {
            apiInstance.unloadComponent(componentName);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationsApi#unloadComponent");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApplicationsApi;

public class ApplicationsApiExample {

    public static void main(String[] args) {
        ApplicationsApi apiInstance = new ApplicationsApi();
        String componentName = componentName_example; // String | The name of the component
        try {
            apiInstance.unloadComponent(componentName);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationsApi#unloadComponent");
            e.printStackTrace();
        }
    }
}

String *componentName = componentName_example; // The name of the component

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

// Unload a component
[apiInstance unloadComponentWith:componentName
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.ApplicationsApi()

var componentName = componentName_example; // {String} The name of the component


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

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

namespace Example
{
    public class unloadComponentExample
    {
        public void main()
        {
            
            var apiInstance = new ApplicationsApi();
            var componentName = componentName_example;  // String | The name of the component

            try
            {
                // Unload a component
                apiInstance.unloadComponent(componentName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApplicationsApi.unloadComponent: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ApplicationsApi();
$componentName = componentName_example; // String | The name of the component

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

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

my $api_instance = WWW::SwaggerClient::ApplicationsApi->new();
my $componentName = componentName_example; # String | The name of the component

eval { 
    $api_instance->unloadComponent(componentName => $componentName);
};
if ($@) {
    warn "Exception when calling ApplicationsApi->unloadComponent: $@\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.ApplicationsApi()
componentName = componentName_example # String | The name of the component

try: 
    # Unload a component
    api_instance.unload_component(componentName)
except ApiException as e:
    print("Exception when calling ApplicationsApi->unloadComponent: %s\n" % e)

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

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

public class ApplicationsApiExample {

    public static void main(String[] args) {
        
        ApplicationsApi apiInstance = new ApplicationsApi();
        String controllerName = controllerName_example; // String | The name of the controller
        String hardwareName = hardwareName_example; // String | The name of the hardware
        try {
            apiInstance.unloadController(controllerName, hardwareName);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationsApi#unloadController");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApplicationsApi;

public class ApplicationsApiExample {

    public static void main(String[] args) {
        ApplicationsApi apiInstance = new ApplicationsApi();
        String controllerName = controllerName_example; // String | The name of the controller
        String hardwareName = hardwareName_example; // String | The name of the hardware
        try {
            apiInstance.unloadController(controllerName, hardwareName);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationsApi#unloadController");
            e.printStackTrace();
        }
    }
}

String *controllerName = controllerName_example; // The name of the controller
String *hardwareName = hardwareName_example; // The name of the hardware

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

// Unload a controller
[apiInstance unloadControllerWith:controllerName
    hardwareName:hardwareName
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.ApplicationsApi()

var controllerName = controllerName_example; // {String} The name of the controller

var hardwareName = hardwareName_example; // {String} The name of the hardware


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

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

namespace Example
{
    public class unloadControllerExample
    {
        public void main()
        {
            
            var apiInstance = new ApplicationsApi();
            var controllerName = controllerName_example;  // String | The name of the controller
            var hardwareName = hardwareName_example;  // String | The name of the hardware

            try
            {
                // Unload a controller
                apiInstance.unloadController(controllerName, hardwareName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApplicationsApi.unloadController: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ApplicationsApi();
$controllerName = controllerName_example; // String | The name of the controller
$hardwareName = hardwareName_example; // String | The name of the hardware

try {
    $api_instance->unloadController($controllerName, $hardwareName);
} catch (Exception $e) {
    echo 'Exception when calling ApplicationsApi->unloadController: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::ApplicationsApi->new();
my $controllerName = controllerName_example; # String | The name of the controller
my $hardwareName = hardwareName_example; # String | The name of the hardware

eval { 
    $api_instance->unloadController(controllerName => $controllerName, hardwareName => $hardwareName);
};
if ($@) {
    warn "Exception when calling ApplicationsApi->unloadController: $@\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.ApplicationsApi()
controllerName = controllerName_example # String | The name of the controller
hardwareName = hardwareName_example # String | The name of the hardware

try: 
    # Unload a controller
    api_instance.unload_controller(controllerName, hardwareName)
except ApiException as e:
    print("Exception when calling ApplicationsApi->unloadController: %s\n" % e)

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

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

public class ApplicationsApiExample {

    public static void main(String[] args) {
        
        ApplicationsApi apiInstance = new ApplicationsApi();
        String hardwareName = hardwareName_example; // String | The name of the hardware
        try {
            apiInstance.unloadHardware(hardwareName);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationsApi#unloadHardware");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApplicationsApi;

public class ApplicationsApiExample {

    public static void main(String[] args) {
        ApplicationsApi apiInstance = new ApplicationsApi();
        String hardwareName = hardwareName_example; // String | The name of the hardware
        try {
            apiInstance.unloadHardware(hardwareName);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationsApi#unloadHardware");
            e.printStackTrace();
        }
    }
}

String *hardwareName = hardwareName_example; // The name of the hardware

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

// Unload a hardware interface
[apiInstance unloadHardwareWith:hardwareName
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.ApplicationsApi()

var hardwareName = hardwareName_example; // {String} The name of the hardware


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

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

namespace Example
{
    public class unloadHardwareExample
    {
        public void main()
        {
            
            var apiInstance = new ApplicationsApi();
            var hardwareName = hardwareName_example;  // String | The name of the hardware

            try
            {
                // Unload a hardware interface
                apiInstance.unloadHardware(hardwareName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApplicationsApi.unloadHardware: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ApplicationsApi();
$hardwareName = hardwareName_example; // String | The name of the hardware

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

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

my $api_instance = WWW::SwaggerClient::ApplicationsApi->new();
my $hardwareName = hardwareName_example; # String | The name of the hardware

eval { 
    $api_instance->unloadHardware(hardwareName => $hardwareName);
};
if ($@) {
    warn "Exception when calling ApplicationsApi->unloadHardware: $@\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.ApplicationsApi()
hardwareName = hardwareName_example # String | The name of the hardware

try: 
    # Unload a hardware interface
    api_instance.unload_hardware(hardwareName)
except ApiException as e:
    print("Exception when calling ApplicationsApi->unloadHardware: %s\n" % e)

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

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

public class DataApiExample {

    public static void main(String[] args) {
        
        DataApi apiInstance = new DataApi();
        String applicationName = applicationName_example; // String | The name of the application
        try {
            apiInstance.deleteDBApplication(applicationName);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#deleteDBApplication");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataApi;

public class DataApiExample {

    public static void main(String[] args) {
        DataApi apiInstance = new DataApi();
        String applicationName = applicationName_example; // String | The name of the application
        try {
            apiInstance.deleteDBApplication(applicationName);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#deleteDBApplication");
            e.printStackTrace();
        }
    }
}

String *applicationName = applicationName_example; // The name of the application

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

// Delete application from the database
[apiInstance deleteDBApplicationWith:applicationName
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.DataApi()

var applicationName = applicationName_example; // {String} The name of the application


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

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

namespace Example
{
    public class deleteDBApplicationExample
    {
        public void main()
        {
            
            var apiInstance = new DataApi();
            var applicationName = applicationName_example;  // String | The name of the application

            try
            {
                // Delete application from the database
                apiInstance.deleteDBApplication(applicationName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataApi.deleteDBApplication: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DataApi();
$applicationName = applicationName_example; // String | The name of the application

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

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

my $api_instance = WWW::SwaggerClient::DataApi->new();
my $applicationName = applicationName_example; # String | The name of the application

eval { 
    $api_instance->deleteDBApplication(applicationName => $applicationName);
};
if ($@) {
    warn "Exception when calling DataApi->deleteDBApplication: $@\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.DataApi()
applicationName = applicationName_example # String | The name of the application

try: 
    # Delete application from the database
    api_instance.delete_db_application(applicationName)
except ApiException as e:
    print("Exception when calling DataApi->deleteDBApplication: %s\n" % e)

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

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

public class DataApiExample {

    public static void main(String[] args) {
        
        DataApi apiInstance = new DataApi();
        String hardwareName = hardwareName_example; // String | The name of the hardware
        try {
            apiInstance.deleteDBHardware(hardwareName);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#deleteDBHardware");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataApi;

public class DataApiExample {

    public static void main(String[] args) {
        DataApi apiInstance = new DataApi();
        String hardwareName = hardwareName_example; // String | The name of the hardware
        try {
            apiInstance.deleteDBHardware(hardwareName);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#deleteDBHardware");
            e.printStackTrace();
        }
    }
}

String *hardwareName = hardwareName_example; // The name of the hardware

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

// Delete hardware from the database
[apiInstance deleteDBHardwareWith:hardwareName
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.DataApi()

var hardwareName = hardwareName_example; // {String} The name of the hardware


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

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

namespace Example
{
    public class deleteDBHardwareExample
    {
        public void main()
        {
            
            var apiInstance = new DataApi();
            var hardwareName = hardwareName_example;  // String | The name of the hardware

            try
            {
                // Delete hardware from the database
                apiInstance.deleteDBHardware(hardwareName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataApi.deleteDBHardware: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DataApi();
$hardwareName = hardwareName_example; // String | The name of the hardware

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

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

my $api_instance = WWW::SwaggerClient::DataApi->new();
my $hardwareName = hardwareName_example; # String | The name of the hardware

eval { 
    $api_instance->deleteDBHardware(hardwareName => $hardwareName);
};
if ($@) {
    warn "Exception when calling DataApi->deleteDBHardware: $@\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.DataApi()
hardwareName = hardwareName_example # String | The name of the hardware

try: 
    # Delete hardware from the database
    api_instance.delete_db_hardware(hardwareName)
except ApiException as e:
    print("Exception when calling DataApi->deleteDBHardware: %s\n" % e)

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

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

public class DataApiExample {

    public static void main(String[] args) {
        
        DataApi apiInstance = new DataApi();
        String applicationName = applicationName_example; // String | The name of the application
        String xFields = xFields_example; // String | An optional fields mask
        try {
            Application result = apiInstance.getDBApplication(applicationName, xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#getDBApplication");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataApi;

public class DataApiExample {

    public static void main(String[] args) {
        DataApi apiInstance = new DataApi();
        String applicationName = applicationName_example; // String | The name of the application
        String xFields = xFields_example; // String | An optional fields mask
        try {
            Application result = apiInstance.getDBApplication(applicationName, xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#getDBApplication");
            e.printStackTrace();
        }
    }
}

String *applicationName = applicationName_example; // The name of the application
String *xFields = xFields_example; // An optional fields mask (optional)

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

// Get application info
[apiInstance getDBApplicationWith:applicationName
    xFields:xFields
              completionHandler: ^(Application output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.DataApi()

var applicationName = applicationName_example; // {String} The name of the application

var opts = { 
  'xFields': xFields_example // {String} An optional fields mask
};

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

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

namespace Example
{
    public class getDBApplicationExample
    {
        public void main()
        {
            
            var apiInstance = new DataApi();
            var applicationName = applicationName_example;  // String | The name of the application
            var xFields = xFields_example;  // String | An optional fields mask (optional) 

            try
            {
                // Get application info
                Application result = apiInstance.getDBApplication(applicationName, xFields);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataApi.getDBApplication: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DataApi();
$applicationName = applicationName_example; // String | The name of the application
$xFields = xFields_example; // String | An optional fields mask

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

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

my $api_instance = WWW::SwaggerClient::DataApi->new();
my $applicationName = applicationName_example; # String | The name of the application
my $xFields = xFields_example; # String | An optional fields mask

eval { 
    my $result = $api_instance->getDBApplication(applicationName => $applicationName, xFields => $xFields);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataApi->getDBApplication: $@\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.DataApi()
applicationName = applicationName_example # String | The name of the application
xFields = xFields_example # String | An optional fields mask (optional)

try: 
    # Get application info
    api_response = api_instance.get_db_application(applicationName, xFields=xFields)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataApi->getDBApplication: %s\n" % e)

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

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

public class DataApiExample {

    public static void main(String[] args) {
        
        DataApi apiInstance = new DataApi();
        String xFields = xFields_example; // String | An optional fields mask
        try {
            array[Application] result = apiInstance.getDBApplicationList(xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#getDBApplicationList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataApi;

public class DataApiExample {

    public static void main(String[] args) {
        DataApi apiInstance = new DataApi();
        String xFields = xFields_example; // String | An optional fields mask
        try {
            array[Application] result = apiInstance.getDBApplicationList(xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#getDBApplicationList");
            e.printStackTrace();
        }
    }
}

String *xFields = xFields_example; // An optional fields mask (optional)

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

// List available applications from the database
[apiInstance getDBApplicationListWith:xFields
              completionHandler: ^(array[Application] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.DataApi()

var opts = { 
  'xFields': xFields_example // {String} An optional fields mask
};

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

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

namespace Example
{
    public class getDBApplicationListExample
    {
        public void main()
        {
            
            var apiInstance = new DataApi();
            var xFields = xFields_example;  // String | An optional fields mask (optional) 

            try
            {
                // List available applications from the database
                array[Application] result = apiInstance.getDBApplicationList(xFields);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataApi.getDBApplicationList: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DataApi();
$xFields = xFields_example; // String | An optional fields mask

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

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

my $api_instance = WWW::SwaggerClient::DataApi->new();
my $xFields = xFields_example; # String | An optional fields mask

eval { 
    my $result = $api_instance->getDBApplicationList(xFields => $xFields);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataApi->getDBApplicationList: $@\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.DataApi()
xFields = xFields_example # String | An optional fields mask (optional)

try: 
    # List available applications from the database
    api_response = api_instance.get_db_application_list(xFields=xFields)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataApi->getDBApplicationList: %s\n" % e)

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

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

public class DataApiExample {

    public static void main(String[] args) {
        
        DataApi apiInstance = new DataApi();
        String hardwareName = hardwareName_example; // String | The name of the hardware
        String xFields = xFields_example; // String | An optional fields mask
        try {
            Hardware result = apiInstance.getDBHardware(hardwareName, xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#getDBHardware");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataApi;

public class DataApiExample {

    public static void main(String[] args) {
        DataApi apiInstance = new DataApi();
        String hardwareName = hardwareName_example; // String | The name of the hardware
        String xFields = xFields_example; // String | An optional fields mask
        try {
            Hardware result = apiInstance.getDBHardware(hardwareName, xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#getDBHardware");
            e.printStackTrace();
        }
    }
}

String *hardwareName = hardwareName_example; // The name of the hardware
String *xFields = xFields_example; // An optional fields mask (optional)

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

// Get hardware info
[apiInstance getDBHardwareWith:hardwareName
    xFields:xFields
              completionHandler: ^(Hardware output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.DataApi()

var hardwareName = hardwareName_example; // {String} The name of the hardware

var opts = { 
  'xFields': xFields_example // {String} An optional fields mask
};

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

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

namespace Example
{
    public class getDBHardwareExample
    {
        public void main()
        {
            
            var apiInstance = new DataApi();
            var hardwareName = hardwareName_example;  // String | The name of the hardware
            var xFields = xFields_example;  // String | An optional fields mask (optional) 

            try
            {
                // Get hardware info
                Hardware result = apiInstance.getDBHardware(hardwareName, xFields);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataApi.getDBHardware: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DataApi();
$hardwareName = hardwareName_example; // String | The name of the hardware
$xFields = xFields_example; // String | An optional fields mask

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

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

my $api_instance = WWW::SwaggerClient::DataApi->new();
my $hardwareName = hardwareName_example; # String | The name of the hardware
my $xFields = xFields_example; # String | An optional fields mask

eval { 
    my $result = $api_instance->getDBHardware(hardwareName => $hardwareName, xFields => $xFields);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataApi->getDBHardware: $@\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.DataApi()
hardwareName = hardwareName_example # String | The name of the hardware
xFields = xFields_example # String | An optional fields mask (optional)

try: 
    # Get hardware info
    api_response = api_instance.get_db_hardware(hardwareName, xFields=xFields)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataApi->getDBHardware: %s\n" % e)

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

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

public class DataApiExample {

    public static void main(String[] args) {
        
        DataApi apiInstance = new DataApi();
        String xFields = xFields_example; // String | An optional fields mask
        try {
            array[Hardware] result = apiInstance.getDBHardwareList(xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#getDBHardwareList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataApi;

public class DataApiExample {

    public static void main(String[] args) {
        DataApi apiInstance = new DataApi();
        String xFields = xFields_example; // String | An optional fields mask
        try {
            array[Hardware] result = apiInstance.getDBHardwareList(xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#getDBHardwareList");
            e.printStackTrace();
        }
    }
}

String *xFields = xFields_example; // An optional fields mask (optional)

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

// List available hardware from the database
[apiInstance getDBHardwareListWith:xFields
              completionHandler: ^(array[Hardware] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.DataApi()

var opts = { 
  'xFields': xFields_example // {String} An optional fields mask
};

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

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

namespace Example
{
    public class getDBHardwareListExample
    {
        public void main()
        {
            
            var apiInstance = new DataApi();
            var xFields = xFields_example;  // String | An optional fields mask (optional) 

            try
            {
                // List available hardware from the database
                array[Hardware] result = apiInstance.getDBHardwareList(xFields);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataApi.getDBHardwareList: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DataApi();
$xFields = xFields_example; // String | An optional fields mask

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

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

my $api_instance = WWW::SwaggerClient::DataApi->new();
my $xFields = xFields_example; # String | An optional fields mask

eval { 
    my $result = $api_instance->getDBHardwareList(xFields => $xFields);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataApi->getDBHardwareList: $@\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.DataApi()
xFields = xFields_example # String | An optional fields mask (optional)

try: 
    # List available hardware from the database
    api_response = api_instance.get_db_hardware_list(xFields=xFields)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataApi->getDBHardwareList: %s\n" % e)

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

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

public class DataApiExample {

    public static void main(String[] args) {
        
        DataApi apiInstance = new DataApi();
        String applicationName = applicationName_example; // String | The name of the application
        Payload_3 payload = ; // Payload_3 | 
        String xFields = xFields_example; // String | An optional fields mask
        try {
            Application result = apiInstance.patchDBApplication(applicationName, payload, xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#patchDBApplication");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataApi;

public class DataApiExample {

    public static void main(String[] args) {
        DataApi apiInstance = new DataApi();
        String applicationName = applicationName_example; // String | The name of the application
        Payload_3 payload = ; // Payload_3 | 
        String xFields = xFields_example; // String | An optional fields mask
        try {
            Application result = apiInstance.patchDBApplication(applicationName, payload, xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#patchDBApplication");
            e.printStackTrace();
        }
    }
}

String *applicationName = applicationName_example; // The name of the application
Payload_3 *payload = ; // 
String *xFields = xFields_example; // An optional fields mask (optional)

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

// Update application info
[apiInstance patchDBApplicationWith:applicationName
    payload:payload
    xFields:xFields
              completionHandler: ^(Application output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.DataApi()

var applicationName = applicationName_example; // {String} The name of the application

var payload = ; // {Payload_3} 

var opts = { 
  'xFields': xFields_example // {String} An optional fields mask
};

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

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

namespace Example
{
    public class patchDBApplicationExample
    {
        public void main()
        {
            
            var apiInstance = new DataApi();
            var applicationName = applicationName_example;  // String | The name of the application
            var payload = new Payload_3(); // Payload_3 | 
            var xFields = xFields_example;  // String | An optional fields mask (optional) 

            try
            {
                // Update application info
                Application result = apiInstance.patchDBApplication(applicationName, payload, xFields);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataApi.patchDBApplication: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DataApi();
$applicationName = applicationName_example; // String | The name of the application
$payload = ; // Payload_3 | 
$xFields = xFields_example; // String | An optional fields mask

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

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

my $api_instance = WWW::SwaggerClient::DataApi->new();
my $applicationName = applicationName_example; # String | The name of the application
my $payload = WWW::SwaggerClient::Object::Payload_3->new(); # Payload_3 | 
my $xFields = xFields_example; # String | An optional fields mask

eval { 
    my $result = $api_instance->patchDBApplication(applicationName => $applicationName, payload => $payload, xFields => $xFields);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataApi->patchDBApplication: $@\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.DataApi()
applicationName = applicationName_example # String | The name of the application
payload =  # Payload_3 | 
xFields = xFields_example # String | An optional fields mask (optional)

try: 
    # Update application info
    api_response = api_instance.patch_db_application(applicationName, payload, xFields=xFields)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataApi->patchDBApplication: %s\n" % e)

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

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

public class DataApiExample {

    public static void main(String[] args) {
        
        DataApi apiInstance = new DataApi();
        String hardwareName = hardwareName_example; // String | The name of the hardware
        Payload_5 payload = ; // Payload_5 | 
        String xFields = xFields_example; // String | An optional fields mask
        try {
            Hardware result = apiInstance.patchDBHardware(hardwareName, payload, xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#patchDBHardware");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataApi;

public class DataApiExample {

    public static void main(String[] args) {
        DataApi apiInstance = new DataApi();
        String hardwareName = hardwareName_example; // String | The name of the hardware
        Payload_5 payload = ; // Payload_5 | 
        String xFields = xFields_example; // String | An optional fields mask
        try {
            Hardware result = apiInstance.patchDBHardware(hardwareName, payload, xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#patchDBHardware");
            e.printStackTrace();
        }
    }
}

String *hardwareName = hardwareName_example; // The name of the hardware
Payload_5 *payload = ; // 
String *xFields = xFields_example; // An optional fields mask (optional)

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

// Update hardware info
[apiInstance patchDBHardwareWith:hardwareName
    payload:payload
    xFields:xFields
              completionHandler: ^(Hardware output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.DataApi()

var hardwareName = hardwareName_example; // {String} The name of the hardware

var payload = ; // {Payload_5} 

var opts = { 
  'xFields': xFields_example // {String} An optional fields mask
};

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

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

namespace Example
{
    public class patchDBHardwareExample
    {
        public void main()
        {
            
            var apiInstance = new DataApi();
            var hardwareName = hardwareName_example;  // String | The name of the hardware
            var payload = new Payload_5(); // Payload_5 | 
            var xFields = xFields_example;  // String | An optional fields mask (optional) 

            try
            {
                // Update hardware info
                Hardware result = apiInstance.patchDBHardware(hardwareName, payload, xFields);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataApi.patchDBHardware: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DataApi();
$hardwareName = hardwareName_example; // String | The name of the hardware
$payload = ; // Payload_5 | 
$xFields = xFields_example; // String | An optional fields mask

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

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

my $api_instance = WWW::SwaggerClient::DataApi->new();
my $hardwareName = hardwareName_example; # String | The name of the hardware
my $payload = WWW::SwaggerClient::Object::Payload_5->new(); # Payload_5 | 
my $xFields = xFields_example; # String | An optional fields mask

eval { 
    my $result = $api_instance->patchDBHardware(hardwareName => $hardwareName, payload => $payload, xFields => $xFields);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataApi->patchDBHardware: $@\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.DataApi()
hardwareName = hardwareName_example # String | The name of the hardware
payload =  # Payload_5 | 
xFields = xFields_example # String | An optional fields mask (optional)

try: 
    # Update hardware info
    api_response = api_instance.patch_db_hardware(hardwareName, payload, xFields=xFields)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataApi->patchDBHardware: %s\n" % e)

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

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

public class DataApiExample {

    public static void main(String[] args) {
        
        DataApi apiInstance = new DataApi();
        String applicationName = applicationName_example; // String | The name of the application
        Payload_2 payload = ; // Payload_2 | 
        String xFields = xFields_example; // String | An optional fields mask
        try {
            Application result = apiInstance.putDBApplication(applicationName, payload, xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#putDBApplication");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataApi;

public class DataApiExample {

    public static void main(String[] args) {
        DataApi apiInstance = new DataApi();
        String applicationName = applicationName_example; // String | The name of the application
        Payload_2 payload = ; // Payload_2 | 
        String xFields = xFields_example; // String | An optional fields mask
        try {
            Application result = apiInstance.putDBApplication(applicationName, payload, xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#putDBApplication");
            e.printStackTrace();
        }
    }
}

String *applicationName = applicationName_example; // The name of the application
Payload_2 *payload = ; // 
String *xFields = xFields_example; // An optional fields mask (optional)

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

// Add application to the database
[apiInstance putDBApplicationWith:applicationName
    payload:payload
    xFields:xFields
              completionHandler: ^(Application output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.DataApi()

var applicationName = applicationName_example; // {String} The name of the application

var payload = ; // {Payload_2} 

var opts = { 
  'xFields': xFields_example // {String} An optional fields mask
};

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

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

namespace Example
{
    public class putDBApplicationExample
    {
        public void main()
        {
            
            var apiInstance = new DataApi();
            var applicationName = applicationName_example;  // String | The name of the application
            var payload = new Payload_2(); // Payload_2 | 
            var xFields = xFields_example;  // String | An optional fields mask (optional) 

            try
            {
                // Add application to the database
                Application result = apiInstance.putDBApplication(applicationName, payload, xFields);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataApi.putDBApplication: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DataApi();
$applicationName = applicationName_example; // String | The name of the application
$payload = ; // Payload_2 | 
$xFields = xFields_example; // String | An optional fields mask

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

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

my $api_instance = WWW::SwaggerClient::DataApi->new();
my $applicationName = applicationName_example; # String | The name of the application
my $payload = WWW::SwaggerClient::Object::Payload_2->new(); # Payload_2 | 
my $xFields = xFields_example; # String | An optional fields mask

eval { 
    my $result = $api_instance->putDBApplication(applicationName => $applicationName, payload => $payload, xFields => $xFields);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataApi->putDBApplication: $@\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.DataApi()
applicationName = applicationName_example # String | The name of the application
payload =  # Payload_2 | 
xFields = xFields_example # String | An optional fields mask (optional)

try: 
    # Add application to the database
    api_response = api_instance.put_db_application(applicationName, payload, xFields=xFields)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataApi->putDBApplication: %s\n" % e)

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

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

public class DataApiExample {

    public static void main(String[] args) {
        
        DataApi apiInstance = new DataApi();
        String hardwareName = hardwareName_example; // String | The name of the hardware
        Payload_4 payload = ; // Payload_4 | 
        String xFields = xFields_example; // String | An optional fields mask
        try {
            Hardware result = apiInstance.putDBHardware(hardwareName, payload, xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#putDBHardware");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataApi;

public class DataApiExample {

    public static void main(String[] args) {
        DataApi apiInstance = new DataApi();
        String hardwareName = hardwareName_example; // String | The name of the hardware
        Payload_4 payload = ; // Payload_4 | 
        String xFields = xFields_example; // String | An optional fields mask
        try {
            Hardware result = apiInstance.putDBHardware(hardwareName, payload, xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#putDBHardware");
            e.printStackTrace();
        }
    }
}

String *hardwareName = hardwareName_example; // The name of the hardware
Payload_4 *payload = ; // 
String *xFields = xFields_example; // An optional fields mask (optional)

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

// Add hardware to the database
[apiInstance putDBHardwareWith:hardwareName
    payload:payload
    xFields:xFields
              completionHandler: ^(Hardware output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.DataApi()

var hardwareName = hardwareName_example; // {String} The name of the hardware

var payload = ; // {Payload_4} 

var opts = { 
  'xFields': xFields_example // {String} An optional fields mask
};

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

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

namespace Example
{
    public class putDBHardwareExample
    {
        public void main()
        {
            
            var apiInstance = new DataApi();
            var hardwareName = hardwareName_example;  // String | The name of the hardware
            var payload = new Payload_4(); // Payload_4 | 
            var xFields = xFields_example;  // String | An optional fields mask (optional) 

            try
            {
                // Add hardware to the database
                Hardware result = apiInstance.putDBHardware(hardwareName, payload, xFields);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataApi.putDBHardware: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DataApi();
$hardwareName = hardwareName_example; // String | The name of the hardware
$payload = ; // Payload_4 | 
$xFields = xFields_example; // String | An optional fields mask

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

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

my $api_instance = WWW::SwaggerClient::DataApi->new();
my $hardwareName = hardwareName_example; # String | The name of the hardware
my $payload = WWW::SwaggerClient::Object::Payload_4->new(); # Payload_4 | 
my $xFields = xFields_example; # String | An optional fields mask

eval { 
    my $result = $api_instance->putDBHardware(hardwareName => $hardwareName, payload => $payload, xFields => $xFields);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataApi->putDBHardware: $@\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.DataApi()
hardwareName = hardwareName_example # String | The name of the hardware
payload =  # Payload_4 | 
xFields = xFields_example # String | An optional fields mask (optional)

try: 
    # Add hardware to the database
    api_response = api_instance.put_db_hardware(hardwareName, payload, xFields=xFields)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataApi->putDBHardware: %s\n" % e)

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

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

public class ExamplesApiExample {

    public static void main(String[] args) {
        
        ExamplesApi apiInstance = new ExamplesApi();
        String hardwareName = hardwareName_example; // String | The name of the hardware
        String xFields = xFields_example; // String | An optional fields mask
        try {
            Hardware result = apiInstance.getExampleHardware(hardwareName, xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExamplesApi#getExampleHardware");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ExamplesApi;

public class ExamplesApiExample {

    public static void main(String[] args) {
        ExamplesApi apiInstance = new ExamplesApi();
        String hardwareName = hardwareName_example; // String | The name of the hardware
        String xFields = xFields_example; // String | An optional fields mask
        try {
            Hardware result = apiInstance.getExampleHardware(hardwareName, xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExamplesApi#getExampleHardware");
            e.printStackTrace();
        }
    }
}

String *hardwareName = hardwareName_example; // The name of the hardware
String *xFields = xFields_example; // An optional fields mask (optional)

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

// Get the hardware info of a filesystem example
[apiInstance getExampleHardwareWith:hardwareName
    xFields:xFields
              completionHandler: ^(Hardware output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.ExamplesApi()

var hardwareName = hardwareName_example; // {String} The name of the hardware

var opts = { 
  'xFields': xFields_example // {String} An optional fields mask
};

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

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

namespace Example
{
    public class getExampleHardwareExample
    {
        public void main()
        {
            
            var apiInstance = new ExamplesApi();
            var hardwareName = hardwareName_example;  // String | The name of the hardware
            var xFields = xFields_example;  // String | An optional fields mask (optional) 

            try
            {
                // Get the hardware info of a filesystem example
                Hardware result = apiInstance.getExampleHardware(hardwareName, xFields);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ExamplesApi.getExampleHardware: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ExamplesApi();
$hardwareName = hardwareName_example; // String | The name of the hardware
$xFields = xFields_example; // String | An optional fields mask

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

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

my $api_instance = WWW::SwaggerClient::ExamplesApi->new();
my $hardwareName = hardwareName_example; # String | The name of the hardware
my $xFields = xFields_example; # String | An optional fields mask

eval { 
    my $result = $api_instance->getExampleHardware(hardwareName => $hardwareName, xFields => $xFields);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExamplesApi->getExampleHardware: $@\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.ExamplesApi()
hardwareName = hardwareName_example # String | The name of the hardware
xFields = xFields_example # String | An optional fields mask (optional)

try: 
    # Get the hardware info of a filesystem example
    api_response = api_instance.get_example_hardware(hardwareName, xFields=xFields)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ExamplesApi->getExampleHardware: %s\n" % e)

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

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

public class ExamplesApiExample {

    public static void main(String[] args) {
        
        ExamplesApi apiInstance = new ExamplesApi();
        String xFields = xFields_example; // String | An optional fields mask
        try {
            array[Hardware] result = apiInstance.getExampleHardwareList(xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExamplesApi#getExampleHardwareList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ExamplesApi;

public class ExamplesApiExample {

    public static void main(String[] args) {
        ExamplesApi apiInstance = new ExamplesApi();
        String xFields = xFields_example; // String | An optional fields mask
        try {
            array[Hardware] result = apiInstance.getExampleHardwareList(xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExamplesApi#getExampleHardwareList");
            e.printStackTrace();
        }
    }
}

String *xFields = xFields_example; // An optional fields mask (optional)

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

// List available hardware from the filesystem examples
[apiInstance getExampleHardwareListWith:xFields
              completionHandler: ^(array[Hardware] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.ExamplesApi()

var opts = { 
  'xFields': xFields_example // {String} An optional fields mask
};

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

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

namespace Example
{
    public class getExampleHardwareListExample
    {
        public void main()
        {
            
            var apiInstance = new ExamplesApi();
            var xFields = xFields_example;  // String | An optional fields mask (optional) 

            try
            {
                // List available hardware from the filesystem examples
                array[Hardware] result = apiInstance.getExampleHardwareList(xFields);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ExamplesApi.getExampleHardwareList: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ExamplesApi();
$xFields = xFields_example; // String | An optional fields mask

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

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

my $api_instance = WWW::SwaggerClient::ExamplesApi->new();
my $xFields = xFields_example; # String | An optional fields mask

eval { 
    my $result = $api_instance->getExampleHardwareList(xFields => $xFields);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExamplesApi->getExampleHardwareList: $@\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.ExamplesApi()
xFields = xFields_example # String | An optional fields mask (optional)

try: 
    # List available hardware from the filesystem examples
    api_response = api_instance.get_example_hardware_list(xFields=xFields)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ExamplesApi->getExampleHardwareList: %s\n" % e)

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

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

public class ROS2ApiExample {

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

import io.swagger.client.api.ROS2Api;

public class ROS2ApiExample {

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

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

// Lookup all transform from the TF buffer
[apiInstance getAllTransformsWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.ROS2Api()

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

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

namespace Example
{
    public class getAllTransformsExample
    {
        public void main()
        {
            
            var apiInstance = new ROS2Api();

            try
            {
                // Lookup all transform from the TF buffer
                apiInstance.getAllTransforms();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ROS2Api.getAllTransforms: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    $api_instance->getAllTransforms();
};
if ($@) {
    warn "Exception when calling ROS2Api->getAllTransforms: $@\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.ROS2Api()

try: 
    # Lookup all transform from the TF buffer
    api_instance.get_all_transforms()
except ApiException as e:
    print("Exception when calling ROS2Api->getAllTransforms: %s\n" % e)

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

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

public class ROS2ApiExample {

    public static void main(String[] args) {
        
        ROS2Api apiInstance = new ROS2Api();
        String frame = frame_example; // String | The name of the frame to look up
        String referenceFrame = referenceFrame_example; // String | The reference frame
        String xFields = xFields_example; // String | An optional fields mask
        try {
            apiInstance.getTransform(frame, referenceFrame, xFields);
        } catch (ApiException e) {
            System.err.println("Exception when calling ROS2Api#getTransform");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ROS2Api;

public class ROS2ApiExample {

    public static void main(String[] args) {
        ROS2Api apiInstance = new ROS2Api();
        String frame = frame_example; // String | The name of the frame to look up
        String referenceFrame = referenceFrame_example; // String | The reference frame
        String xFields = xFields_example; // String | An optional fields mask
        try {
            apiInstance.getTransform(frame, referenceFrame, xFields);
        } catch (ApiException e) {
            System.err.println("Exception when calling ROS2Api#getTransform");
            e.printStackTrace();
        }
    }
}

String *frame = frame_example; // The name of the frame to look up
String *referenceFrame = referenceFrame_example; // The reference frame (optional) (default to world)
String *xFields = xFields_example; // An optional fields mask (optional)

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

// Lookup a transform from the TF buffer
[apiInstance getTransformWith:frame
    referenceFrame:referenceFrame
    xFields:xFields
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.ROS2Api()

var frame = frame_example; // {String} The name of the frame to look up

var opts = { 
  'referenceFrame': referenceFrame_example, // {String} The reference frame
  'xFields': xFields_example // {String} An optional fields mask
};

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

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

namespace Example
{
    public class getTransformExample
    {
        public void main()
        {
            
            var apiInstance = new ROS2Api();
            var frame = frame_example;  // String | The name of the frame to look up
            var referenceFrame = referenceFrame_example;  // String | The reference frame (optional)  (default to world)
            var xFields = xFields_example;  // String | An optional fields mask (optional) 

            try
            {
                // Lookup a transform from the TF buffer
                apiInstance.getTransform(frame, referenceFrame, xFields);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ROS2Api.getTransform: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ROS2Api();
$frame = frame_example; // String | The name of the frame to look up
$referenceFrame = referenceFrame_example; // String | The reference frame
$xFields = xFields_example; // String | An optional fields mask

try {
    $api_instance->getTransform($frame, $referenceFrame, $xFields);
} catch (Exception $e) {
    echo 'Exception when calling ROS2Api->getTransform: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::ROS2Api->new();
my $frame = frame_example; # String | The name of the frame to look up
my $referenceFrame = referenceFrame_example; # String | The reference frame
my $xFields = xFields_example; # String | An optional fields mask

eval { 
    $api_instance->getTransform(frame => $frame, referenceFrame => $referenceFrame, xFields => $xFields);
};
if ($@) {
    warn "Exception when calling ROS2Api->getTransform: $@\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.ROS2Api()
frame = frame_example # String | The name of the frame to look up
referenceFrame = referenceFrame_example # String | The reference frame (optional) (default to world)
xFields = xFields_example # String | An optional fields mask (optional)

try: 
    # Lookup a transform from the TF buffer
    api_instance.get_transform(frame, referenceFrame=referenceFrame, xFields=xFields)
except ApiException as e:
    print("Exception when calling ROS2Api->getTransform: %s\n" % e)

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

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

public class RootApiExample {

    public static void main(String[] args) {
        
        RootApi apiInstance = new RootApi();
        String xFields = xFields_example; // String | An optional fields mask
        try {
            Component%20Descriptions result = apiInstance.getComponentDescriptions(xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RootApi#getComponentDescriptions");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RootApi;

public class RootApiExample {

    public static void main(String[] args) {
        RootApi apiInstance = new RootApi();
        String xFields = xFields_example; // String | An optional fields mask
        try {
            Component%20Descriptions result = apiInstance.getComponentDescriptions(xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RootApi#getComponentDescriptions");
            e.printStackTrace();
        }
    }
}

String *xFields = xFields_example; // An optional fields mask (optional)

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

// Get a collection of component descriptions
[apiInstance getComponentDescriptionsWith:xFields
              completionHandler: ^(Component%20Descriptions output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.RootApi()

var opts = { 
  'xFields': xFields_example // {String} An optional fields mask
};

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

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

namespace Example
{
    public class getComponentDescriptionsExample
    {
        public void main()
        {
            
            var apiInstance = new RootApi();
            var xFields = xFields_example;  // String | An optional fields mask (optional) 

            try
            {
                // Get a collection of component descriptions
                Component%20Descriptions result = apiInstance.getComponentDescriptions(xFields);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RootApi.getComponentDescriptions: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\RootApi();
$xFields = xFields_example; // String | An optional fields mask

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

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

my $api_instance = WWW::SwaggerClient::RootApi->new();
my $xFields = xFields_example; # String | An optional fields mask

eval { 
    my $result = $api_instance->getComponentDescriptions(xFields => $xFields);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RootApi->getComponentDescriptions: $@\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.RootApi()
xFields = xFields_example # String | An optional fields mask (optional)

try: 
    # Get a collection of component descriptions
    api_response = api_instance.get_component_descriptions(xFields=xFields)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RootApi->getComponentDescriptions: %s\n" % e)

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

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

public class RootApiExample {

    public static void main(String[] args) {
        
        RootApi apiInstance = new RootApi();
        String xFields = xFields_example; // String | An optional fields mask
        try {
            Controller%20Descriptions result = apiInstance.getControllerDescriptions(xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RootApi#getControllerDescriptions");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RootApi;

public class RootApiExample {

    public static void main(String[] args) {
        RootApi apiInstance = new RootApi();
        String xFields = xFields_example; // String | An optional fields mask
        try {
            Controller%20Descriptions result = apiInstance.getControllerDescriptions(xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RootApi#getControllerDescriptions");
            e.printStackTrace();
        }
    }
}

String *xFields = xFields_example; // An optional fields mask (optional)

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

// Get a collection of controller descriptions
[apiInstance getControllerDescriptionsWith:xFields
              completionHandler: ^(Controller%20Descriptions output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.RootApi()

var opts = { 
  'xFields': xFields_example // {String} An optional fields mask
};

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

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

namespace Example
{
    public class getControllerDescriptionsExample
    {
        public void main()
        {
            
            var apiInstance = new RootApi();
            var xFields = xFields_example;  // String | An optional fields mask (optional) 

            try
            {
                // Get a collection of controller descriptions
                Controller%20Descriptions result = apiInstance.getControllerDescriptions(xFields);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RootApi.getControllerDescriptions: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\RootApi();
$xFields = xFields_example; // String | An optional fields mask

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

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

my $api_instance = WWW::SwaggerClient::RootApi->new();
my $xFields = xFields_example; # String | An optional fields mask

eval { 
    my $result = $api_instance->getControllerDescriptions(xFields => $xFields);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RootApi->getControllerDescriptions: $@\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.RootApi()
xFields = xFields_example # String | An optional fields mask (optional)

try: 
    # Get a collection of controller descriptions
    api_response = api_instance.get_controller_descriptions(xFields=xFields)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RootApi->getControllerDescriptions: %s\n" % e)

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

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

public class RootApiExample {

    public static void main(String[] args) {
        
        RootApi apiInstance = new RootApi();
        String xFields = xFields_example; // String | An optional fields mask
        try {
            Features result = apiInstance.getFeatures(xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RootApi#getFeatures");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RootApi;

public class RootApiExample {

    public static void main(String[] args) {
        RootApi apiInstance = new RootApi();
        String xFields = xFields_example; // String | An optional fields mask
        try {
            Features result = apiInstance.getFeatures(xFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RootApi#getFeatures");
            e.printStackTrace();
        }
    }
}

String *xFields = xFields_example; // An optional fields mask (optional)

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

// Get the available features
[apiInstance getFeaturesWith:xFields
              completionHandler: ^(Features output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.RootApi()

var opts = { 
  'xFields': xFields_example // {String} An optional fields mask
};

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

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

namespace Example
{
    public class getFeaturesExample
    {
        public void main()
        {
            
            var apiInstance = new RootApi();
            var xFields = xFields_example;  // String | An optional fields mask (optional) 

            try
            {
                // Get the available features
                Features result = apiInstance.getFeatures(xFields);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RootApi.getFeatures: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\RootApi();
$xFields = xFields_example; // String | An optional fields mask

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

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

my $api_instance = WWW::SwaggerClient::RootApi->new();
my $xFields = xFields_example; # String | An optional fields mask

eval { 
    my $result = $api_instance->getFeatures(xFields => $xFields);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RootApi->getFeatures: $@\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.RootApi()
xFields = xFields_example # String | An optional fields mask (optional)

try: 
    # Get the available features
    api_response = api_instance.get_features(xFields=xFields)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RootApi->getFeatures: %s\n" % e)

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

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

public class RootApiExample {

    public static void main(String[] args) {
        
        RootApi apiInstance = new RootApi();
        String xFields = xFields_example; // String | An optional fields mask
        try {
            apiInstance.getLicensingStatus(xFields);
        } catch (ApiException e) {
            System.err.println("Exception when calling RootApi#getLicensingStatus");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RootApi;

public class RootApiExample {

    public static void main(String[] args) {
        RootApi apiInstance = new RootApi();
        String xFields = xFields_example; // String | An optional fields mask
        try {
            apiInstance.getLicensingStatus(xFields);
        } catch (ApiException e) {
            System.err.println("Exception when calling RootApi#getLicensingStatus");
            e.printStackTrace();
        }
    }
}

String *xFields = xFields_example; // An optional fields mask (optional)

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

// Get the current licensing status
[apiInstance getLicensingStatusWith:xFields
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AicaApi = require('aica_api');

var api = new AicaApi.RootApi()

var opts = { 
  'xFields': xFields_example // {String} An optional fields mask
};

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

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

namespace Example
{
    public class getLicensingStatusExample
    {
        public void main()
        {
            
            var apiInstance = new RootApi();
            var xFields = xFields_example;  // String | An optional fields mask (optional) 

            try
            {
                // Get the current licensing status
                apiInstance.getLicensingStatus(xFields);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RootApi.getLicensingStatus: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\RootApi();
$xFields = xFields_example; // String | An optional fields mask

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

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

my $api_instance = WWW::SwaggerClient::RootApi->new();
my $xFields = xFields_example; # String | An optional fields mask

eval { 
    $api_instance->getLicensingStatus(xFields => $xFields);
};
if ($@) {
    warn "Exception when calling RootApi->getLicensingStatus: $@\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.RootApi()
xFields = xFields_example # String | An optional fields mask (optional)

try: 
    # Get the current licensing status
    api_instance.get_licensing_status(xFields=xFields)
except ApiException as e:
    print("Exception when calling RootApi->getLicensingStatus: %s\n" % e)