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

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

public class AntennasApiExample {
    public static void main(String[] args) {

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

        try {
            Antenna result = apiInstance.getActiveAntenna();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AntennasApi#getActiveAntenna");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AntennasApi;

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

        try {
            Antenna result = apiInstance.getActiveAntenna();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AntennasApi#getActiveAntenna");
            e.printStackTrace();
        }
    }
}

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

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

var Rfkit = require('rfkit');

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

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

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

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

            try {
                Antenna result = apiInstance.getActiveAntenna();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AntennasApi.getActiveAntenna: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

extern crate AntennasApi;

pub fn main() {

    let mut context = AntennasApi::Context::default();
    let result = client.getActiveAntenna(&context).wait();

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

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

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

public class AntennasApiExample {
    public static void main(String[] args) {

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

        try {
            array[AntennaWithState] result = apiInstance.getAntennasWithState();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AntennasApi#getAntennasWithState");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AntennasApi;

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

        try {
            array[AntennaWithState] result = apiInstance.getAntennasWithState();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AntennasApi#getAntennasWithState");
            e.printStackTrace();
        }
    }
}

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

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

var Rfkit = require('rfkit');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate AntennasApi;

pub fn main() {

    let mut context = AntennasApi::Context::default();
    let result = client.getAntennasWithState(&context).wait();

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

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

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

public class AntennasApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AntennasApi apiInstance = new AntennasApi();
        Antenna antenna = ; // Antenna | 

        try {
            Antenna result = apiInstance.setActiveAntenna(antenna);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AntennasApi#setActiveAntenna");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AntennasApi;

public class AntennasApiExample {
    public static void main(String[] args) {
        AntennasApi apiInstance = new AntennasApi();
        Antenna antenna = ; // Antenna | 

        try {
            Antenna result = apiInstance.setActiveAntenna(antenna);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AntennasApi#setActiveAntenna");
            e.printStackTrace();
        }
    }
}

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

[apiInstance setActiveAntennaWith:antenna
              completionHandler: ^(Antenna output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var Rfkit = require('rfkit');

// Create an instance of the API class
var api = new Rfkit.AntennasApi()
var antenna = ; // {Antenna} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new AntennasApi();
            var antenna = new Antenna(); // Antenna | 

            try {
                Antenna result = apiInstance.setActiveAntenna(antenna);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AntennasApi.setActiveAntenna: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AntennasApi();
$antenna = ; // Antenna | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AntennasApi->new();
my $antenna = WWW::OPenAPIClient::Object::Antenna->new(); # Antenna | 

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

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

# Create an instance of the API class
api_instance = openapi_client.AntennasApi()
antenna =  # Antenna | 

try:
    api_response = api_instance.set_active_antenna(antenna)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AntennasApi->setActiveAntenna: %s\n" % e)

extern crate AntennasApi;

pub fn main() {
    let antenna = ; // Antenna

    let mut context = AntennasApi::Context::default();
    let result = client.setActiveAntenna(antenna, &context).wait();

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

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

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

public class DataApiExample {
    public static void main(String[] args) {

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

        try {
            Data result = apiInstance.getData();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#getData");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DataApi;

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

        try {
            Data result = apiInstance.getData();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#getData");
            e.printStackTrace();
        }
    }
}

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

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

var Rfkit = require('rfkit');

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

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

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

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

            try {
                Data result = apiInstance.getData();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataApi.getData: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

extern crate DataApi;

pub fn main() {

    let mut context = DataApi::Context::default();
    let result = client.getData(&context).wait();

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

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

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

public class ErrorApiExample {
    public static void main(String[] args) {

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

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

import org.openapitools.client.api.ErrorApi;

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

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

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

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

var Rfkit = require('rfkit');

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

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

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

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

            try {
                apiInstance.resetError();
            } catch (Exception e) {
                Debug.Print("Exception when calling ErrorApi.resetError: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    api_instance.reset_error()
except ApiException as e:
    print("Exception when calling ErrorApi->resetError: %s\n" % e)

extern crate ErrorApi;

pub fn main() {

    let mut context = ErrorApi::Context::default();
    let result = client.resetError(&context).wait();

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

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

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

public class InfoApiExample {
    public static void main(String[] args) {

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

        try {
            Info result = apiInstance.getInfo();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InfoApi#getInfo");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.InfoApi;

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

        try {
            Info result = apiInstance.getInfo();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InfoApi#getInfo");
            e.printStackTrace();
        }
    }
}

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

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

var Rfkit = require('rfkit');

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

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

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

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

            try {
                Info result = apiInstance.getInfo();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling InfoApi.getInfo: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

extern crate InfoApi;

pub fn main() {

    let mut context = InfoApi::Context::default();
    let result = client.getInfo(&context).wait();

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

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

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

public class OperateModeApiExample {
    public static void main(String[] args) {

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

        try {
            OperateMode result = apiInstance.getOperateMode();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperateModeApi#getOperateMode");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.OperateModeApi;

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

        try {
            OperateMode result = apiInstance.getOperateMode();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperateModeApi#getOperateMode");
            e.printStackTrace();
        }
    }
}

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

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

var Rfkit = require('rfkit');

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

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

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

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

            try {
                OperateMode result = apiInstance.getOperateMode();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperateModeApi.getOperateMode: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

extern crate OperateModeApi;

pub fn main() {

    let mut context = OperateModeApi::Context::default();
    let result = client.getOperateMode(&context).wait();

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

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

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

public class OperateModeApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        OperateModeApi apiInstance = new OperateModeApi();
        OperateMode operateMode = ; // OperateMode | 

        try {
            OperateMode result = apiInstance.setOperateMode(operateMode);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperateModeApi#setOperateMode");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.OperateModeApi;

public class OperateModeApiExample {
    public static void main(String[] args) {
        OperateModeApi apiInstance = new OperateModeApi();
        OperateMode operateMode = ; // OperateMode | 

        try {
            OperateMode result = apiInstance.setOperateMode(operateMode);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperateModeApi#setOperateMode");
            e.printStackTrace();
        }
    }
}

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

[apiInstance setOperateModeWith:operateMode
              completionHandler: ^(OperateMode output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var Rfkit = require('rfkit');

// Create an instance of the API class
var api = new Rfkit.OperateModeApi()
var operateMode = ; // {OperateMode} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new OperateModeApi();
            var operateMode = new OperateMode(); // OperateMode | 

            try {
                OperateMode result = apiInstance.setOperateMode(operateMode);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperateModeApi.setOperateMode: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\OperateModeApi();
$operateMode = ; // OperateMode | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::OperateModeApi->new();
my $operateMode = WWW::OPenAPIClient::Object::OperateMode->new(); # OperateMode | 

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

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

# Create an instance of the API class
api_instance = openapi_client.OperateModeApi()
operateMode =  # OperateMode | 

try:
    api_response = api_instance.set_operate_mode(operateMode)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperateModeApi->setOperateMode: %s\n" % e)

extern crate OperateModeApi;

pub fn main() {
    let operateMode = ; // OperateMode

    let mut context = OperateModeApi::Context::default();
    let result = client.setOperateMode(operateMode, &context).wait();

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

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

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

public class OperationalInterfaceApiExample {
    public static void main(String[] args) {

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

        try {
            OperationalInterface result = apiInstance.getOperationalInterface();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperationalInterfaceApi#getOperationalInterface");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.OperationalInterfaceApi;

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

        try {
            OperationalInterface result = apiInstance.getOperationalInterface();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperationalInterfaceApi#getOperationalInterface");
            e.printStackTrace();
        }
    }
}

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

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

var Rfkit = require('rfkit');

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

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

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

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

            try {
                OperationalInterface result = apiInstance.getOperationalInterface();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperationalInterfaceApi.getOperationalInterface: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

extern crate OperationalInterfaceApi;

pub fn main() {

    let mut context = OperationalInterfaceApi::Context::default();
    let result = client.getOperationalInterface(&context).wait();

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

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

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

public class OperationalInterfaceApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        OperationalInterfaceApi apiInstance = new OperationalInterfaceApi();
        OperationalInterface operationalInterface = ; // OperationalInterface | 

        try {
            OperationalInterface result = apiInstance.setOperationalInterface(operationalInterface);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperationalInterfaceApi#setOperationalInterface");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.OperationalInterfaceApi;

public class OperationalInterfaceApiExample {
    public static void main(String[] args) {
        OperationalInterfaceApi apiInstance = new OperationalInterfaceApi();
        OperationalInterface operationalInterface = ; // OperationalInterface | 

        try {
            OperationalInterface result = apiInstance.setOperationalInterface(operationalInterface);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperationalInterfaceApi#setOperationalInterface");
            e.printStackTrace();
        }
    }
}

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

[apiInstance setOperationalInterfaceWith:operationalInterface
              completionHandler: ^(OperationalInterface output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var Rfkit = require('rfkit');

// Create an instance of the API class
var api = new Rfkit.OperationalInterfaceApi()
var operationalInterface = ; // {OperationalInterface} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new OperationalInterfaceApi();
            var operationalInterface = new OperationalInterface(); // OperationalInterface | 

            try {
                OperationalInterface result = apiInstance.setOperationalInterface(operationalInterface);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperationalInterfaceApi.setOperationalInterface: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\OperationalInterfaceApi();
$operationalInterface = ; // OperationalInterface | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::OperationalInterfaceApi->new();
my $operationalInterface = WWW::OPenAPIClient::Object::OperationalInterface->new(); # OperationalInterface | 

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

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

# Create an instance of the API class
api_instance = openapi_client.OperationalInterfaceApi()
operationalInterface =  # OperationalInterface | 

try:
    api_response = api_instance.set_operational_interface(operationalInterface)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperationalInterfaceApi->setOperationalInterface: %s\n" % e)

extern crate OperationalInterfaceApi;

pub fn main() {
    let operationalInterface = ; // OperationalInterface

    let mut context = OperationalInterfaceApi::Context::default();
    let result = client.setOperationalInterface(operationalInterface, &context).wait();

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

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

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

public class PowerApiExample {
    public static void main(String[] args) {

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

        try {
            Power result = apiInstance.getPower();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PowerApi#getPower");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.PowerApi;

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

        try {
            Power result = apiInstance.getPower();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PowerApi#getPower");
            e.printStackTrace();
        }
    }
}

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

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

var Rfkit = require('rfkit');

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

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

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

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

            try {
                Power result = apiInstance.getPower();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PowerApi.getPower: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

extern crate PowerApi;

pub fn main() {

    let mut context = PowerApi::Context::default();
    let result = client.getPower(&context).wait();

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

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

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

public class TunerApiExample {
    public static void main(String[] args) {

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

        try {
            Tuner result = apiInstance.getTuner();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TunerApi#getTuner");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.TunerApi;

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

        try {
            Tuner result = apiInstance.getTuner();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TunerApi#getTuner");
            e.printStackTrace();
        }
    }
}

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

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

var Rfkit = require('rfkit');

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

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

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

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

            try {
                Tuner result = apiInstance.getTuner();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TunerApi.getTuner: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

extern crate TunerApi;

pub fn main() {

    let mut context = TunerApi::Context::default();
    let result = client.getTuner(&context).wait();

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