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

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

public class AccountApiExample {

    public static void main(String[] args) {
        
        AccountApi apiInstance = new AccountApi();
        Integer userId = 56; // Integer | 
        try {
            apiInstance.accountsUserIdOptions(userId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#accountsUserIdOptions");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        Integer userId = 56; // Integer | 
        try {
            apiInstance.accountsUserIdOptions(userId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#accountsUserIdOptions");
            e.printStackTrace();
        }
    }
}

Integer *userId = 56; // 

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

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

var AirmonitorApi = require('airmonitor_api');

var api = new AirmonitorApi.AccountApi()
var userId = 56; // {{Integer}} 

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

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

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

            var apiInstance = new AccountApi();
            var userId = 56;  // Integer | 

            try
            {
                apiInstance.accountsUserIdOptions(userId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.accountsUserIdOptions: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAccountApi();
$userId = 56; // Integer | 

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

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

my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $userId = 56; # Integer | 

eval { 
    $api_instance->accountsUserIdOptions(userId => $userId);
};
if ($@) {
    warn "Exception when calling AccountApi->accountsUserIdOptions: $@\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.AccountApi()
userId = 56 # Integer | 

try: 
    api_instance.accounts_user_id_options(userId)
except ApiException as e:
    print("Exception when calling AccountApi->accountsUserIdOptions: %s\n" % e)

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

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

public class AccountApiExample {

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

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

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

ChangePassword *body = ; //  (optional)

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

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

var AirmonitorApi = require('airmonitor_api');

var api = new AirmonitorApi.AccountApi()

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

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

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

            var apiInstance = new AccountApi();
            var body = new ChangePassword(); // ChangePassword |  (optional) 

            try
            {
                apiInstance.changePasswordPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.changePasswordPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // ChangePassword | 

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

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

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

eval { 
    $api_instance->changePasswordPost(body => $body);
};
if ($@) {
    warn "Exception when calling AccountApi->changePasswordPost: $@\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.AccountApi()
body =  # ChangePassword |  (optional)

try: 
    api_instance.change_password_post(body=body)
except ApiException as e:
    print("Exception when calling AccountApi->changePasswordPost: %s\n" % e)

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

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

public class AccountApiExample {

    public static void main(String[] args) {
        
        AccountApi apiInstance = new AccountApi();
        Integer userId = 56; // Integer | 
        Account body = ; // Account | The start time
        try {
            Data result = apiInstance.userAccount(userId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#userAccount");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        Integer userId = 56; // Integer | 
        Account body = ; // Account | The start time
        try {
            Data result = apiInstance.userAccount(userId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#userAccount");
            e.printStackTrace();
        }
    }
}

Integer *userId = 56; // 
Account *body = ; // The start time (optional)

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

// changes an existing account
[apiInstance userAccountWith:userId
    body:body
              completionHandler: ^(Data output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AirmonitorApi = require('airmonitor_api');

var api = new AirmonitorApi.AccountApi()
var userId = 56; // {{Integer}} 

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

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

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

            var apiInstance = new AccountApi();
            var userId = 56;  // Integer | 
            var body = new Account(); // Account | The start time (optional) 

            try
            {
                // changes an existing account
                Data result = apiInstance.userAccount(userId, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.userAccount: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAccountApi();
$userId = 56; // Integer | 
$body = ; // Account | The start time

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

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

my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $userId = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Account->new(); # Account | The start time

eval { 
    my $result = $api_instance->userAccount(userId => $userId, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountApi->userAccount: $@\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.AccountApi()
userId = 56 # Integer | 
body =  # Account | The start time (optional)

try: 
    # changes an existing account
    api_response = api_instance.user_account(userId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->userAccount: %s\n" % e)

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

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

public class AccountApiExample {

    public static void main(String[] args) {
        
        AccountApi apiInstance = new AccountApi();
        Integer userId = 56; // Integer | 
        try {
            apiInstance.userAccountDelete(userId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#userAccountDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        Integer userId = 56; // Integer | 
        try {
            apiInstance.userAccountDelete(userId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#userAccountDelete");
            e.printStackTrace();
        }
    }
}

Integer *userId = 56; // 

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

// deletes an existing account
[apiInstance userAccountDeleteWith:userId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AirmonitorApi = require('airmonitor_api');

var api = new AirmonitorApi.AccountApi()
var userId = 56; // {{Integer}} 

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

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

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

            var apiInstance = new AccountApi();
            var userId = 56;  // Integer | 

            try
            {
                // deletes an existing account
                apiInstance.userAccountDelete(userId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.userAccountDelete: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAccountApi();
$userId = 56; // Integer | 

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

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

my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $userId = 56; # Integer | 

eval { 
    $api_instance->userAccountDelete(userId => $userId);
};
if ($@) {
    warn "Exception when calling AccountApi->userAccountDelete: $@\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.AccountApi()
userId = 56 # Integer | 

try: 
    # deletes an existing account
    api_instance.user_account_delete(userId)
except ApiException as e:
    print("Exception when calling AccountApi->userAccountDelete: %s\n" % e)

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

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

public class AccountApiExample {

    public static void main(String[] args) {
        
        AccountApi apiInstance = new AccountApi();
        Account body = ; // Account | The start time
        try {
            Data result = apiInstance.userAccountPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#userAccountPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        Account body = ; // Account | The start time
        try {
            Data result = apiInstance.userAccountPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#userAccountPost");
            e.printStackTrace();
        }
    }
}

Account *body = ; // The start time (optional)

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

// adds new account
[apiInstance userAccountPostWith:body
              completionHandler: ^(Data output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AirmonitorApi = require('airmonitor_api');

var api = new AirmonitorApi.AccountApi()

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

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

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

            var apiInstance = new AccountApi();
            var body = new Account(); // Account | The start time (optional) 

            try
            {
                // adds new account
                Data result = apiInstance.userAccountPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.userAccountPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // Account | The start time

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

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

my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $body = WWW::SwaggerClient::Object::Account->new(); # Account | The start time

eval { 
    my $result = $api_instance->userAccountPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountApi->userAccountPost: $@\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.AccountApi()
body =  # Account | The start time (optional)

try: 
    # adds new account
    api_response = api_instance.user_account_post(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->userAccountPost: %s\n" % e)

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

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

public class AirmonitorSettingsApiExample {

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

import io.swagger.client.api.AirmonitorSettingsApi;

public class AirmonitorSettingsApiExample {

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

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

// retrieves airmonitor settings
[apiInstance airmonitorSettingsWithCompletionHandler: 
              ^(AirmonitorSettings output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AirmonitorApi = require('airmonitor_api');

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

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

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

            var apiInstance = new AirmonitorSettingsApi();

            try
            {
                // retrieves airmonitor settings
                AirmonitorSettings result = apiInstance.airmonitorSettings();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AirmonitorSettingsApi.airmonitorSettings: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try: 
    # retrieves airmonitor settings
    api_response = api_instance.airmonitor_settings()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AirmonitorSettingsApi->airmonitorSettings: %s\n" % e)

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

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

public class AirmonitorSettingsApiExample {

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

import io.swagger.client.api.AirmonitorSettingsApi;

public class AirmonitorSettingsApiExample {

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

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

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

var AirmonitorApi = require('airmonitor_api');

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

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

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

            var apiInstance = new AirmonitorSettingsApi();

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

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

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

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

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

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

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

try: 
    api_instance.airmonitor_settings_options()
except ApiException as e:
    print("Exception when calling AirmonitorSettingsApi->airmonitorSettingsOptions: %s\n" % e)

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

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

public class AirmonitorSettingsApiExample {

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

import io.swagger.client.api.AirmonitorSettingsApi;

public class AirmonitorSettingsApiExample {

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

AirmonitorSettings *body = ; //  (optional)

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

// updates device settings
[apiInstance airmonitorSettingsPutWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AirmonitorApi = require('airmonitor_api');

var api = new AirmonitorApi.AirmonitorSettingsApi()

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

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

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

            var apiInstance = new AirmonitorSettingsApi();
            var body = new AirmonitorSettings(); // AirmonitorSettings |  (optional) 

            try
            {
                // updates device settings
                apiInstance.airmonitorSettingsPut(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AirmonitorSettingsApi.airmonitorSettingsPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAirmonitorSettingsApi();
$body = ; // AirmonitorSettings | 

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

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

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

eval { 
    $api_instance->airmonitorSettingsPut(body => $body);
};
if ($@) {
    warn "Exception when calling AirmonitorSettingsApi->airmonitorSettingsPut: $@\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.AirmonitorSettingsApi()
body =  # AirmonitorSettings |  (optional)

try: 
    # updates device settings
    api_instance.airmonitor_settings_put(body=body)
except ApiException as e:
    print("Exception when calling AirmonitorSettingsApi->airmonitorSettingsPut: %s\n" % e)

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

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

public class BaseApiExample {

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

import io.swagger.client.api.BaseApi;

public class BaseApiExample {

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

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

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

var AirmonitorApi = require('airmonitor_api');

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

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

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

            var apiInstance = new BaseApi();

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

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

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

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

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

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

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

try: 
    api_instance.root_options()
except ApiException as e:
    print("Exception when calling BaseApi->rootOptions: %s\n" % e)

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

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

public class DashboardApiExample {

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

import io.swagger.client.api.DashboardApi;

public class DashboardApiExample {

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

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

// delivers information about the to be displayed tiles
[apiInstance dashboardWithCompletionHandler: 
              ^(Tiles output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AirmonitorApi = require('airmonitor_api');

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

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

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

            var apiInstance = new DashboardApi();

            try
            {
                // delivers information about the to be displayed tiles
                Tiles result = apiInstance.dashboard();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DashboardApi.dashboard: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try: 
    # delivers information about the to be displayed tiles
    api_response = api_instance.dashboard()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DashboardApi->dashboard: %s\n" % e)

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

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

public class DashboardApiExample {

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

import io.swagger.client.api.DashboardApi;

public class DashboardApiExample {

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

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

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

var AirmonitorApi = require('airmonitor_api');

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

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

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

            var apiInstance = new DashboardApi();

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

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

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

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

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

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

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

try: 
    api_instance.dashboard_options()
except ApiException as e:
    print("Exception when calling DashboardApi->dashboardOptions: %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 startTime = startTime_example; // String | The start time in UTC
        try {
            Data result = apiInstance.dataStartTime(startTime);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#dataStartTime");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataApi;

public class DataApiExample {

    public static void main(String[] args) {
        DataApi apiInstance = new DataApi();
        String startTime = startTime_example; // String | The start time in UTC
        try {
            Data result = apiInstance.dataStartTime(startTime);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#dataStartTime");
            e.printStackTrace();
        }
    }
}

String *startTime = startTime_example; // The start time in UTC

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

// retrieves all data from start time till now (1000 datapoints)
[apiInstance dataStartTimeWith:startTime
              completionHandler: ^(Data output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AirmonitorApi = require('airmonitor_api');

var api = new AirmonitorApi.DataApi()
var startTime = startTime_example; // {{String}} The start time in UTC

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

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

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

            var apiInstance = new DataApi();
            var startTime = startTime_example;  // String | The start time in UTC

            try
            {
                // retrieves all data from start time till now (1000 datapoints)
                Data result = apiInstance.dataStartTime(startTime);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataApi.dataStartTime: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDataApi();
$startTime = startTime_example; // String | The start time in UTC

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

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

my $api_instance = WWW::SwaggerClient::DataApi->new();
my $startTime = startTime_example; # String | The start time in UTC

eval { 
    my $result = $api_instance->dataStartTime(startTime => $startTime);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataApi->dataStartTime: $@\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()
startTime = startTime_example # String | The start time in UTC

try: 
    # retrieves all data from start time till now (1000 datapoints)
    api_response = api_instance.data_start_time(startTime)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataApi->dataStartTime: %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 startTime = startTime_example; // String | The start time in UTC
        String endTime = endTime_example; // String | The end time in UTC
        BigDecimal numberOfDataPoints = 1.2; // BigDecimal | number of data points to be returned
        try {
            Data result = apiInstance.dataStartTimeEndTimeNumberOfDataPointsGet(startTime, endTime, numberOfDataPoints);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#dataStartTimeEndTimeNumberOfDataPointsGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataApi;

public class DataApiExample {

    public static void main(String[] args) {
        DataApi apiInstance = new DataApi();
        String startTime = startTime_example; // String | The start time in UTC
        String endTime = endTime_example; // String | The end time in UTC
        BigDecimal numberOfDataPoints = 1.2; // BigDecimal | number of data points to be returned
        try {
            Data result = apiInstance.dataStartTimeEndTimeNumberOfDataPointsGet(startTime, endTime, numberOfDataPoints);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#dataStartTimeEndTimeNumberOfDataPointsGet");
            e.printStackTrace();
        }
    }
}

String *startTime = startTime_example; // The start time in UTC
String *endTime = endTime_example; // The end time in UTC
BigDecimal *numberOfDataPoints = 1.2; // number of data points to be returned

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

// retrieves a specific amount of data points from start time till end time
[apiInstance dataStartTimeEndTimeNumberOfDataPointsGetWith:startTime
    endTime:endTime
    numberOfDataPoints:numberOfDataPoints
              completionHandler: ^(Data output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AirmonitorApi = require('airmonitor_api');

var api = new AirmonitorApi.DataApi()
var startTime = startTime_example; // {{String}} The start time in UTC
var endTime = endTime_example; // {{String}} The end time in UTC
var numberOfDataPoints = 1.2; // {{BigDecimal}} number of data points to be returned

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

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

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

            var apiInstance = new DataApi();
            var startTime = startTime_example;  // String | The start time in UTC
            var endTime = endTime_example;  // String | The end time in UTC
            var numberOfDataPoints = 1.2;  // BigDecimal | number of data points to be returned

            try
            {
                // retrieves a specific amount of data points from start time till end time
                Data result = apiInstance.dataStartTimeEndTimeNumberOfDataPointsGet(startTime, endTime, numberOfDataPoints);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataApi.dataStartTimeEndTimeNumberOfDataPointsGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDataApi();
$startTime = startTime_example; // String | The start time in UTC
$endTime = endTime_example; // String | The end time in UTC
$numberOfDataPoints = 1.2; // BigDecimal | number of data points to be returned

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

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

my $api_instance = WWW::SwaggerClient::DataApi->new();
my $startTime = startTime_example; # String | The start time in UTC
my $endTime = endTime_example; # String | The end time in UTC
my $numberOfDataPoints = 1.2; # BigDecimal | number of data points to be returned

eval { 
    my $result = $api_instance->dataStartTimeEndTimeNumberOfDataPointsGet(startTime => $startTime, endTime => $endTime, numberOfDataPoints => $numberOfDataPoints);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataApi->dataStartTimeEndTimeNumberOfDataPointsGet: $@\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()
startTime = startTime_example # String | The start time in UTC
endTime = endTime_example # String | The end time in UTC
numberOfDataPoints = 1.2 # BigDecimal | number of data points to be returned

try: 
    # retrieves a specific amount of data points from start time till end time
    api_response = api_instance.data_start_time_end_time_number_of_data_points_get(startTime, endTime, numberOfDataPoints)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataApi->dataStartTimeEndTimeNumberOfDataPointsGet: %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 startTime = startTime_example; // String | The start time in UTC
        String endTime = endTime_example; // String | The end time in UTC
        BigDecimal numberOfDataPoints = 1.2; // BigDecimal | number of data points to be returned
        try {
            apiInstance.dataStartTimeEndTimeNumberOfDataPointsOptions(startTime, endTime, numberOfDataPoints);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#dataStartTimeEndTimeNumberOfDataPointsOptions");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataApi;

public class DataApiExample {

    public static void main(String[] args) {
        DataApi apiInstance = new DataApi();
        String startTime = startTime_example; // String | The start time in UTC
        String endTime = endTime_example; // String | The end time in UTC
        BigDecimal numberOfDataPoints = 1.2; // BigDecimal | number of data points to be returned
        try {
            apiInstance.dataStartTimeEndTimeNumberOfDataPointsOptions(startTime, endTime, numberOfDataPoints);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#dataStartTimeEndTimeNumberOfDataPointsOptions");
            e.printStackTrace();
        }
    }
}

String *startTime = startTime_example; // The start time in UTC
String *endTime = endTime_example; // The end time in UTC
BigDecimal *numberOfDataPoints = 1.2; // number of data points to be returned

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

[apiInstance dataStartTimeEndTimeNumberOfDataPointsOptionsWith:startTime
    endTime:endTime
    numberOfDataPoints:numberOfDataPoints
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AirmonitorApi = require('airmonitor_api');

var api = new AirmonitorApi.DataApi()
var startTime = startTime_example; // {{String}} The start time in UTC
var endTime = endTime_example; // {{String}} The end time in UTC
var numberOfDataPoints = 1.2; // {{BigDecimal}} number of data points to be returned

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

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

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

            var apiInstance = new DataApi();
            var startTime = startTime_example;  // String | The start time in UTC
            var endTime = endTime_example;  // String | The end time in UTC
            var numberOfDataPoints = 1.2;  // BigDecimal | number of data points to be returned

            try
            {
                apiInstance.dataStartTimeEndTimeNumberOfDataPointsOptions(startTime, endTime, numberOfDataPoints);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataApi.dataStartTimeEndTimeNumberOfDataPointsOptions: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDataApi();
$startTime = startTime_example; // String | The start time in UTC
$endTime = endTime_example; // String | The end time in UTC
$numberOfDataPoints = 1.2; // BigDecimal | number of data points to be returned

try {
    $api_instance->dataStartTimeEndTimeNumberOfDataPointsOptions($startTime, $endTime, $numberOfDataPoints);
} catch (Exception $e) {
    echo 'Exception when calling DataApi->dataStartTimeEndTimeNumberOfDataPointsOptions: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DataApi->new();
my $startTime = startTime_example; # String | The start time in UTC
my $endTime = endTime_example; # String | The end time in UTC
my $numberOfDataPoints = 1.2; # BigDecimal | number of data points to be returned

eval { 
    $api_instance->dataStartTimeEndTimeNumberOfDataPointsOptions(startTime => $startTime, endTime => $endTime, numberOfDataPoints => $numberOfDataPoints);
};
if ($@) {
    warn "Exception when calling DataApi->dataStartTimeEndTimeNumberOfDataPointsOptions: $@\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()
startTime = startTime_example # String | The start time in UTC
endTime = endTime_example # String | The end time in UTC
numberOfDataPoints = 1.2 # BigDecimal | number of data points to be returned

try: 
    api_instance.data_start_time_end_time_number_of_data_points_options(startTime, endTime, numberOfDataPoints)
except ApiException as e:
    print("Exception when calling DataApi->dataStartTimeEndTimeNumberOfDataPointsOptions: %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 startTime = startTime_example; // String | The start time in UTC
        String endTime = endTime_example; // String | The end time in UTC
        try {
            apiInstance.dataStartTimeEndTimeOptions(startTime, endTime);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#dataStartTimeEndTimeOptions");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataApi;

public class DataApiExample {

    public static void main(String[] args) {
        DataApi apiInstance = new DataApi();
        String startTime = startTime_example; // String | The start time in UTC
        String endTime = endTime_example; // String | The end time in UTC
        try {
            apiInstance.dataStartTimeEndTimeOptions(startTime, endTime);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#dataStartTimeEndTimeOptions");
            e.printStackTrace();
        }
    }
}

String *startTime = startTime_example; // The start time in UTC
String *endTime = endTime_example; // The end time in UTC

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

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

var AirmonitorApi = require('airmonitor_api');

var api = new AirmonitorApi.DataApi()
var startTime = startTime_example; // {{String}} The start time in UTC
var endTime = endTime_example; // {{String}} The end time in UTC

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

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

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

            var apiInstance = new DataApi();
            var startTime = startTime_example;  // String | The start time in UTC
            var endTime = endTime_example;  // String | The end time in UTC

            try
            {
                apiInstance.dataStartTimeEndTimeOptions(startTime, endTime);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataApi.dataStartTimeEndTimeOptions: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDataApi();
$startTime = startTime_example; // String | The start time in UTC
$endTime = endTime_example; // String | The end time in UTC

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

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

my $api_instance = WWW::SwaggerClient::DataApi->new();
my $startTime = startTime_example; # String | The start time in UTC
my $endTime = endTime_example; # String | The end time in UTC

eval { 
    $api_instance->dataStartTimeEndTimeOptions(startTime => $startTime, endTime => $endTime);
};
if ($@) {
    warn "Exception when calling DataApi->dataStartTimeEndTimeOptions: $@\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()
startTime = startTime_example # String | The start time in UTC
endTime = endTime_example # String | The end time in UTC

try: 
    api_instance.data_start_time_end_time_options(startTime, endTime)
except ApiException as e:
    print("Exception when calling DataApi->dataStartTimeEndTimeOptions: %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 startTime = startTime_example; // String | The start time in UTC
        try {
            apiInstance.dataStartTimeOptions(startTime);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#dataStartTimeOptions");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataApi;

public class DataApiExample {

    public static void main(String[] args) {
        DataApi apiInstance = new DataApi();
        String startTime = startTime_example; // String | The start time in UTC
        try {
            apiInstance.dataStartTimeOptions(startTime);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#dataStartTimeOptions");
            e.printStackTrace();
        }
    }
}

String *startTime = startTime_example; // The start time in UTC

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

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

var AirmonitorApi = require('airmonitor_api');

var api = new AirmonitorApi.DataApi()
var startTime = startTime_example; // {{String}} The start time in UTC

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

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

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

            var apiInstance = new DataApi();
            var startTime = startTime_example;  // String | The start time in UTC

            try
            {
                apiInstance.dataStartTimeOptions(startTime);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataApi.dataStartTimeOptions: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDataApi();
$startTime = startTime_example; // String | The start time in UTC

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

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

my $api_instance = WWW::SwaggerClient::DataApi->new();
my $startTime = startTime_example; # String | The start time in UTC

eval { 
    $api_instance->dataStartTimeOptions(startTime => $startTime);
};
if ($@) {
    warn "Exception when calling DataApi->dataStartTimeOptions: $@\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()
startTime = startTime_example # String | The start time in UTC

try: 
    api_instance.data_start_time_options(startTime)
except ApiException as e:
    print("Exception when calling DataApi->dataStartTimeOptions: %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 startTime = startTime_example; // String | The start time in UTC
        String endTime = endTime_example; // String | The end time in UTC
        try {
            Data result = apiInstance.dataTimeRange(startTime, endTime);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#dataTimeRange");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataApi;

public class DataApiExample {

    public static void main(String[] args) {
        DataApi apiInstance = new DataApi();
        String startTime = startTime_example; // String | The start time in UTC
        String endTime = endTime_example; // String | The end time in UTC
        try {
            Data result = apiInstance.dataTimeRange(startTime, endTime);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataApi#dataTimeRange");
            e.printStackTrace();
        }
    }
}

String *startTime = startTime_example; // The start time in UTC
String *endTime = endTime_example; // The end time in UTC

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

// retrieves all data from start till end time (1000 datapoints)
[apiInstance dataTimeRangeWith:startTime
    endTime:endTime
              completionHandler: ^(Data output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AirmonitorApi = require('airmonitor_api');

var api = new AirmonitorApi.DataApi()
var startTime = startTime_example; // {{String}} The start time in UTC
var endTime = endTime_example; // {{String}} The end time in UTC

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

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

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

            var apiInstance = new DataApi();
            var startTime = startTime_example;  // String | The start time in UTC
            var endTime = endTime_example;  // String | The end time in UTC

            try
            {
                // retrieves all data from start till end time (1000 datapoints)
                Data result = apiInstance.dataTimeRange(startTime, endTime);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataApi.dataTimeRange: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDataApi();
$startTime = startTime_example; // String | The start time in UTC
$endTime = endTime_example; // String | The end time in UTC

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

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

my $api_instance = WWW::SwaggerClient::DataApi->new();
my $startTime = startTime_example; # String | The start time in UTC
my $endTime = endTime_example; # String | The end time in UTC

eval { 
    my $result = $api_instance->dataTimeRange(startTime => $startTime, endTime => $endTime);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataApi->dataTimeRange: $@\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()
startTime = startTime_example # String | The start time in UTC
endTime = endTime_example # String | The end time in UTC

try: 
    # retrieves all data from start till end time (1000 datapoints)
    api_response = api_instance.data_time_range(startTime, endTime)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataApi->dataTimeRange: %s\n" % e)

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

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

public class DataBackupApiExample {

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

import io.swagger.client.api.DataBackupApi;

public class DataBackupApiExample {

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

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

// starts data backup
[apiInstance dataBackupGetWithCompletionHandler: 
              ^(Job output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AirmonitorApi = require('airmonitor_api');

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

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

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

            var apiInstance = new DataBackupApi();

            try
            {
                // starts data backup
                Job result = apiInstance.dataBackupGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataBackupApi.dataBackupGet: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try: 
    # starts data backup
    api_response = api_instance.data_backup_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataBackupApi->dataBackupGet: %s\n" % e)

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

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

public class DataBackupApiExample {

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

import io.swagger.client.api.DataBackupApi;

public class DataBackupApiExample {

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

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

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

var AirmonitorApi = require('airmonitor_api');

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

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

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

            var apiInstance = new DataBackupApi();

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

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

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

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

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

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

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

try: 
    api_instance.data_backup_options()
except ApiException as e:
    print("Exception when calling DataBackupApi->dataBackupOptions: %s\n" % e)

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

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

public class DataBackupApiExample {

    public static void main(String[] args) {
        
        DataBackupApi apiInstance = new DataBackupApi();
        File body = ; // File | upload data file
        try {
            Job result = apiInstance.dataBackupPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataBackupApi#dataBackupPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataBackupApi;

public class DataBackupApiExample {

    public static void main(String[] args) {
        DataBackupApi apiInstance = new DataBackupApi();
        File body = ; // File | upload data file
        try {
            Job result = apiInstance.dataBackupPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataBackupApi#dataBackupPost");
            e.printStackTrace();
        }
    }
}

File *body = ; // upload data file (optional)

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

// upload data file
[apiInstance dataBackupPostWith:body
              completionHandler: ^(Job output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AirmonitorApi = require('airmonitor_api');

var api = new AirmonitorApi.DataBackupApi()

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

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

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

            var apiInstance = new DataBackupApi();
            var body = new File(); // File | upload data file (optional) 

            try
            {
                // upload data file
                Job result = apiInstance.dataBackupPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataBackupApi.dataBackupPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDataBackupApi();
$body = ; // File | upload data file

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

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

my $api_instance = WWW::SwaggerClient::DataBackupApi->new();
my $body = WWW::SwaggerClient::Object::File->new(); # File | upload data file

eval { 
    my $result = $api_instance->dataBackupPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataBackupApi->dataBackupPost: $@\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.DataBackupApi()
body =  # File | upload data file (optional)

try: 
    # upload data file
    api_response = api_instance.data_backup_post(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataBackupApi->dataBackupPost: %s\n" % e)

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

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

public class DeviceSettingsApiExample {

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

import io.swagger.client.api.DeviceSettingsApi;

public class DeviceSettingsApiExample {

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

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

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

var AirmonitorApi = require('airmonitor_api');

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

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

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

            var apiInstance = new DeviceSettingsApi();

            try
            {
                DeviceSettings result = apiInstance.deviceSettingsGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DeviceSettingsApi.deviceSettingsGet: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

public class DeviceSettingsApiExample {

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

import io.swagger.client.api.DeviceSettingsApi;

public class DeviceSettingsApiExample {

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

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

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

var AirmonitorApi = require('airmonitor_api');

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

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

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

            var apiInstance = new DeviceSettingsApi();

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

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

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

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

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

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

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

try: 
    api_instance.device_settings_options()
except ApiException as e:
    print("Exception when calling DeviceSettingsApi->deviceSettingsOptions: %s\n" % e)

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

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

public class DeviceSettingsApiExample {

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

import io.swagger.client.api.DeviceSettingsApi;

public class DeviceSettingsApiExample {

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

DeviceSettings *body = ; //  (optional)

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

// updates device settings
[apiInstance updateDeviceSettingsWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AirmonitorApi = require('airmonitor_api');

var api = new AirmonitorApi.DeviceSettingsApi()

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

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

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

            var apiInstance = new DeviceSettingsApi();
            var body = new DeviceSettings(); // DeviceSettings |  (optional) 

            try
            {
                // updates device settings
                apiInstance.updateDeviceSettings(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DeviceSettingsApi.updateDeviceSettings: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDeviceSettingsApi();
$body = ; // DeviceSettings | 

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

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

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

eval { 
    $api_instance->updateDeviceSettings(body => $body);
};
if ($@) {
    warn "Exception when calling DeviceSettingsApi->updateDeviceSettings: $@\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.DeviceSettingsApi()
body =  # DeviceSettings |  (optional)

try: 
    # updates device settings
    api_instance.update_device_settings(body=body)
except ApiException as e:
    print("Exception when calling DeviceSettingsApi->updateDeviceSettings: %s\n" % e)

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

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

public class FirmwareUploadApiExample {

    public static void main(String[] args) {
        
        FirmwareUploadApi apiInstance = new FirmwareUploadApi();
        File body = ; // File | upload new firmware file
        try {
            Job result = apiInstance.firmwareUpload(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareUploadApi#firmwareUpload");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FirmwareUploadApi;

public class FirmwareUploadApiExample {

    public static void main(String[] args) {
        FirmwareUploadApi apiInstance = new FirmwareUploadApi();
        File body = ; // File | upload new firmware file
        try {
            Job result = apiInstance.firmwareUpload(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareUploadApi#firmwareUpload");
            e.printStackTrace();
        }
    }
}

File *body = ; // upload new firmware file (optional)

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

// uploads a new firmware
[apiInstance firmwareUploadWith:body
              completionHandler: ^(Job output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AirmonitorApi = require('airmonitor_api');

var api = new AirmonitorApi.FirmwareUploadApi()

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

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

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

            var apiInstance = new FirmwareUploadApi();
            var body = new File(); // File | upload new firmware file (optional) 

            try
            {
                // uploads a new firmware
                Job result = apiInstance.firmwareUpload(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FirmwareUploadApi.firmwareUpload: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFirmwareUploadApi();
$body = ; // File | upload new firmware file

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

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

my $api_instance = WWW::SwaggerClient::FirmwareUploadApi->new();
my $body = WWW::SwaggerClient::Object::File->new(); # File | upload new firmware file

eval { 
    my $result = $api_instance->firmwareUpload(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FirmwareUploadApi->firmwareUpload: $@\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.FirmwareUploadApi()
body =  # File | upload new firmware file (optional)

try: 
    # uploads a new firmware
    api_response = api_instance.firmware_upload(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FirmwareUploadApi->firmwareUpload: %s\n" % e)

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

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

public class FirmwareUploadApiExample {

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

import io.swagger.client.api.FirmwareUploadApi;

public class FirmwareUploadApiExample {

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

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

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

var AirmonitorApi = require('airmonitor_api');

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

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

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

            var apiInstance = new FirmwareUploadApi();

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

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

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

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

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

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

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

try: 
    api_instance.firmware_upload_options()
except ApiException as e:
    print("Exception when calling FirmwareUploadApi->firmwareUploadOptions: %s\n" % e)

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

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

public class JobApiExample {

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

import io.swagger.client.api.JobApi;

public class JobApiExample {

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

String *jobId = jobId_example; // jobId

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

// retrieves job satus
[apiInstance jobsJobIdGetWith:jobId
              completionHandler: ^(Job output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AirmonitorApi = require('airmonitor_api');

var api = new AirmonitorApi.JobApi()
var jobId = jobId_example; // {{String}} jobId

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

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

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

            var apiInstance = new JobApi();
            var jobId = jobId_example;  // String | jobId

            try
            {
                // retrieves job satus
                Job result = apiInstance.jobsJobIdGet(jobId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobApi.jobsJobIdGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiJobApi();
$jobId = jobId_example; // String | jobId

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

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

my $api_instance = WWW::SwaggerClient::JobApi->new();
my $jobId = jobId_example; # String | jobId

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

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

# create an instance of the API class
api_instance = swagger_client.JobApi()
jobId = jobId_example # String | jobId

try: 
    # retrieves job satus
    api_response = api_instance.jobs_job_id_get(jobId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JobApi->jobsJobIdGet: %s\n" % e)

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

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

public class JobApiExample {

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

import io.swagger.client.api.JobApi;

public class JobApiExample {

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

String *jobId = jobId_example; // jobId

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

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

var AirmonitorApi = require('airmonitor_api');

var api = new AirmonitorApi.JobApi()
var jobId = jobId_example; // {{String}} jobId

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

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

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

            var apiInstance = new JobApi();
            var jobId = jobId_example;  // String | jobId

            try
            {
                apiInstance.jobsJobIdOptions(jobId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobApi.jobsJobIdOptions: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiJobApi();
$jobId = jobId_example; // String | jobId

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

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

my $api_instance = WWW::SwaggerClient::JobApi->new();
my $jobId = jobId_example; # String | jobId

eval { 
    $api_instance->jobsJobIdOptions(jobId => $jobId);
};
if ($@) {
    warn "Exception when calling JobApi->jobsJobIdOptions: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.JobApi()
jobId = jobId_example # String | jobId

try: 
    api_instance.jobs_job_id_options(jobId)
except ApiException as e:
    print("Exception when calling JobApi->jobsJobIdOptions: %s\n" % e)

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

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

public class LoginApiExample {

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

import io.swagger.client.api.LoginApi;

public class LoginApiExample {

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

Login *body = ; //  (optional)

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

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

var AirmonitorApi = require('airmonitor_api');

var api = new AirmonitorApi.LoginApi()

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

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

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

            var apiInstance = new LoginApi();
            var body = new Login(); // Login |  (optional) 

            try
            {
                apiInstance.loginPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LoginApi.loginPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiLoginApi();
$body = ; // Login | 

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

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

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

eval { 
    $api_instance->loginPost(body => $body);
};
if ($@) {
    warn "Exception when calling LoginApi->loginPost: $@\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.LoginApi()
body =  # Login |  (optional)

try: 
    api_instance.login_post(body=body)
except ApiException as e:
    print("Exception when calling LoginApi->loginPost: %s\n" % e)

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

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

public class SSIDApiExample {

    public static void main(String[] args) {
        
        SSIDApi apiInstance = new SSIDApi();
        String ssidName = ssidName_example; // String | 
        Ssid body = ; // Ssid | The start time
        try {
            Ssid result = apiInstance.ssid(ssidName, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SSIDApi#ssid");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SSIDApi;

public class SSIDApiExample {

    public static void main(String[] args) {
        SSIDApi apiInstance = new SSIDApi();
        String ssidName = ssidName_example; // String | 
        Ssid body = ; // Ssid | The start time
        try {
            Ssid result = apiInstance.ssid(ssidName, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SSIDApi#ssid");
            e.printStackTrace();
        }
    }
}

String *ssidName = ssidName_example; // 
Ssid *body = ; // The start time (optional)

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

// changes SSID configuration
[apiInstance ssidWith:ssidName
    body:body
              completionHandler: ^(Ssid output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AirmonitorApi = require('airmonitor_api');

var api = new AirmonitorApi.SSIDApi()
var ssidName = ssidName_example; // {{String}} 

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

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

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

            var apiInstance = new SSIDApi();
            var ssidName = ssidName_example;  // String | 
            var body = new Ssid(); // Ssid | The start time (optional) 

            try
            {
                // changes SSID configuration
                Ssid result = apiInstance.ssid(ssidName, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SSIDApi.ssid: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiSSIDApi();
$ssidName = ssidName_example; // String | 
$body = ; // Ssid | The start time

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

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

my $api_instance = WWW::SwaggerClient::SSIDApi->new();
my $ssidName = ssidName_example; # String | 
my $body = WWW::SwaggerClient::Object::Ssid->new(); # Ssid | The start time

eval { 
    my $result = $api_instance->ssid(ssidName => $ssidName, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SSIDApi->ssid: $@\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.SSIDApi()
ssidName = ssidName_example # String | 
body =  # Ssid | The start time (optional)

try: 
    # changes SSID configuration
    api_response = api_instance.ssid(ssidName, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SSIDApi->ssid: %s\n" % e)

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

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

public class SSIDApiExample {

    public static void main(String[] args) {
        
        SSIDApi apiInstance = new SSIDApi();
        String ssidName = ssidName_example; // String | 
        try {
            Data result = apiInstance.ssidDelete(ssidName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SSIDApi#ssidDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SSIDApi;

public class SSIDApiExample {

    public static void main(String[] args) {
        SSIDApi apiInstance = new SSIDApi();
        String ssidName = ssidName_example; // String | 
        try {
            Data result = apiInstance.ssidDelete(ssidName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SSIDApi#ssidDelete");
            e.printStackTrace();
        }
    }
}

String *ssidName = ssidName_example; // 

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

// delete a ssid
[apiInstance ssidDeleteWith:ssidName
              completionHandler: ^(Data output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AirmonitorApi = require('airmonitor_api');

var api = new AirmonitorApi.SSIDApi()
var ssidName = ssidName_example; // {{String}} 

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

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

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

            var apiInstance = new SSIDApi();
            var ssidName = ssidName_example;  // String | 

            try
            {
                // delete a ssid
                Data result = apiInstance.ssidDelete(ssidName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SSIDApi.ssidDelete: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiSSIDApi();
$ssidName = ssidName_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::SSIDApi->new();
my $ssidName = ssidName_example; # String | 

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

try: 
    # delete a ssid
    api_response = api_instance.ssid_delete(ssidName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SSIDApi->ssidDelete: %s\n" % e)

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

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

public class SSIDApiExample {

    public static void main(String[] args) {
        
        SSIDApi apiInstance = new SSIDApi();
        String ssidName = ssidName_example; // String | 
        Ssid body = ; // Ssid | Ssid
        try {
            Data result = apiInstance.ssidPost(ssidName, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SSIDApi#ssidPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SSIDApi;

public class SSIDApiExample {

    public static void main(String[] args) {
        SSIDApi apiInstance = new SSIDApi();
        String ssidName = ssidName_example; // String | 
        Ssid body = ; // Ssid | Ssid
        try {
            Data result = apiInstance.ssidPost(ssidName, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SSIDApi#ssidPost");
            e.printStackTrace();
        }
    }
}

String *ssidName = ssidName_example; // 
Ssid *body = ; // Ssid (optional)

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

// adds a SSID.
[apiInstance ssidPostWith:ssidName
    body:body
              completionHandler: ^(Data output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AirmonitorApi = require('airmonitor_api');

var api = new AirmonitorApi.SSIDApi()
var ssidName = ssidName_example; // {{String}} 

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

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

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

            var apiInstance = new SSIDApi();
            var ssidName = ssidName_example;  // String | 
            var body = new Ssid(); // Ssid | Ssid (optional) 

            try
            {
                // adds a SSID.
                Data result = apiInstance.ssidPost(ssidName, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SSIDApi.ssidPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiSSIDApi();
$ssidName = ssidName_example; // String | 
$body = ; // Ssid | Ssid

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

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

my $api_instance = WWW::SwaggerClient::SSIDApi->new();
my $ssidName = ssidName_example; # String | 
my $body = WWW::SwaggerClient::Object::Ssid->new(); # Ssid | Ssid

eval { 
    my $result = $api_instance->ssidPost(ssidName => $ssidName, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SSIDApi->ssidPost: $@\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.SSIDApi()
ssidName = ssidName_example # String | 
body =  # Ssid | Ssid (optional)

try: 
    # adds a SSID.
    api_response = api_instance.ssid_post(ssidName, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SSIDApi->ssidPost: %s\n" % e)

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

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

public class SSIDApiExample {

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

import io.swagger.client.api.SSIDApi;

public class SSIDApiExample {

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

String *ssidName = ssidName_example; // 

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

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

var AirmonitorApi = require('airmonitor_api');

var api = new AirmonitorApi.SSIDApi()
var ssidName = ssidName_example; // {{String}} 

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

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

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

            var apiInstance = new SSIDApi();
            var ssidName = ssidName_example;  // String | 

            try
            {
                apiInstance.ssidsSsidNameOptions(ssidName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SSIDApi.ssidsSsidNameOptions: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiSSIDApi();
$ssidName = ssidName_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::SSIDApi->new();
my $ssidName = ssidName_example; # String | 

eval { 
    $api_instance->ssidsSsidNameOptions(ssidName => $ssidName);
};
if ($@) {
    warn "Exception when calling SSIDApi->ssidsSsidNameOptions: $@\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.SSIDApi()
ssidName = ssidName_example # String | 

try: 
    api_instance.ssids_ssid_name_options(ssidName)
except ApiException as e:
    print("Exception when calling SSIDApi->ssidsSsidNameOptions: %s\n" % e)

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

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

public class SettingsBackupApiExample {

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

import io.swagger.client.api.SettingsBackupApi;

public class SettingsBackupApiExample {

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

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

// starts settings backup
[apiInstance settingsBackupWithCompletionHandler: 
              ^(Job output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AirmonitorApi = require('airmonitor_api');

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

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

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

            var apiInstance = new SettingsBackupApi();

            try
            {
                // starts settings backup
                Job result = apiInstance.settingsBackup();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SettingsBackupApi.settingsBackup: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try: 
    # starts settings backup
    api_response = api_instance.settings_backup()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SettingsBackupApi->settingsBackup: %s\n" % e)

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

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

public class SettingsBackupApiExample {

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

import io.swagger.client.api.SettingsBackupApi;

public class SettingsBackupApiExample {

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

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

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

var AirmonitorApi = require('airmonitor_api');

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

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

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

            var apiInstance = new SettingsBackupApi();

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

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

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

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

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

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

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

try: 
    api_instance.settings_backup_options()
except ApiException as e:
    print("Exception when calling SettingsBackupApi->settingsBackupOptions: %s\n" % e)

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

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

public class SettingsBackupApiExample {

    public static void main(String[] args) {
        
        SettingsBackupApi apiInstance = new SettingsBackupApi();
        File body = ; // File | upload settings backup file
        try {
            Job result = apiInstance.settingsBackupPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SettingsBackupApi#settingsBackupPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SettingsBackupApi;

public class SettingsBackupApiExample {

    public static void main(String[] args) {
        SettingsBackupApi apiInstance = new SettingsBackupApi();
        File body = ; // File | upload settings backup file
        try {
            Job result = apiInstance.settingsBackupPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SettingsBackupApi#settingsBackupPost");
            e.printStackTrace();
        }
    }
}

File *body = ; // upload settings backup file (optional)

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

// upload settings backup file
[apiInstance settingsBackupPostWith:body
              completionHandler: ^(Job output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AirmonitorApi = require('airmonitor_api');

var api = new AirmonitorApi.SettingsBackupApi()

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

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

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

            var apiInstance = new SettingsBackupApi();
            var body = new File(); // File | upload settings backup file (optional) 

            try
            {
                // upload settings backup file
                Job result = apiInstance.settingsBackupPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SettingsBackupApi.settingsBackupPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiSettingsBackupApi();
$body = ; // File | upload settings backup file

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

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

my $api_instance = WWW::SwaggerClient::SettingsBackupApi->new();
my $body = WWW::SwaggerClient::Object::File->new(); # File | upload settings backup file

eval { 
    my $result = $api_instance->settingsBackupPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SettingsBackupApi->settingsBackupPost: $@\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.SettingsBackupApi()
body =  # File | upload settings backup file (optional)

try: 
    # upload settings backup file
    api_response = api_instance.settings_backup_post(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SettingsBackupApi->settingsBackupPost: %s\n" % e)