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

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

public class AcmeDnsAuthenticatorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.acme_dns_authenticator_authenticator_schemas_get()
except ApiException as e:
    print("Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorAuthenticatorSchemasGet: %s\n" % e)

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

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

public class AcmeDnsAuthenticatorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AcmeDnsAuthenticatorApi apiInstance = new AcmeDnsAuthenticatorApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.acmeDnsAuthenticatorGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling AcmeDnsAuthenticatorApi#acmeDnsAuthenticatorGet");
            e.printStackTrace();
        }
    }
}

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AcmeDnsAuthenticatorApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->acmeDnsAuthenticatorGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorGet: $@\n";
}

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AcmeDnsAuthenticatorApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.acme_dns_authenticator_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorGet: %s\n" % e)

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

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

public class AcmeDnsAuthenticatorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AcmeDnsAuthenticatorApi apiInstance = new AcmeDnsAuthenticatorApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.acmeDnsAuthenticatorIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling AcmeDnsAuthenticatorApi#acmeDnsAuthenticatorIdIdDelete");
            e.printStackTrace();
        }
    }
}

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

eval { 
    $api_instance->acmeDnsAuthenticatorIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorIdIdDelete: $@\n";
}

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AcmeDnsAuthenticatorApi()
id = 56 # Integer | 

try: 
    api_instance.acme_dns_authenticator_id_id_delete(id)
except ApiException as e:
    print("Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorIdIdDelete: %s\n" % e)

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

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

public class AcmeDnsAuthenticatorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AcmeDnsAuthenticatorApi apiInstance = new AcmeDnsAuthenticatorApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.acmeDnsAuthenticatorIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling AcmeDnsAuthenticatorApi#acmeDnsAuthenticatorIdIdGet");
            e.printStackTrace();
        }
    }
}

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AcmeDnsAuthenticatorApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->acmeDnsAuthenticatorIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorIdIdGet: $@\n";
}

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AcmeDnsAuthenticatorApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.acme_dns_authenticator_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorIdIdGet: %s\n" % e)

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

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

public class AcmeDnsAuthenticatorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AcmeDnsAuthenticatorApi apiInstance = new AcmeDnsAuthenticatorApi();
        Integer id = 56; // Integer | 
        Acme_dns_authenticator_update_1 body = ; // Acme_dns_authenticator_update_1 | 
        try {
            apiInstance.acmeDnsAuthenticatorIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AcmeDnsAuthenticatorApi#acmeDnsAuthenticatorIdIdPut");
            e.printStackTrace();
        }
    }
}

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AcmeDnsAuthenticatorApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Acme_dns_authenticator_update_1->new(); # Acme_dns_authenticator_update_1 | 

eval { 
    $api_instance->acmeDnsAuthenticatorIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorIdIdPut: $@\n";
}

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AcmeDnsAuthenticatorApi()
id = 56 # Integer | 
body =  # Acme_dns_authenticator_update_1 |  (optional)

try: 
    api_instance.acme_dns_authenticator_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorIdIdPut: %s\n" % e)

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

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

public class AcmeDnsAuthenticatorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AcmeDnsAuthenticatorApi()
body =  # Acme_dns_authenticator_create_0 |  (optional)

try: 
    api_instance.acme_dns_authenticator_post(body=body)
except ApiException as e:
    print("Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorPost: %s\n" % e)

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

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

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.activedirectory_change_trust_account_pw_get()
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryChangeTrustAccountPwGet: %s\n" % e)

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

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

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.activedirectory_domain_info_get()
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryDomainInfoGet: %s\n" % e)

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

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

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.activedirectory_get()
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryGet: %s\n" % e)

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

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

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.activedirectory_get_spn_list_get()
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryGetSpnListGet: %s\n" % e)

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

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

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.activedirectory_get_state_get()
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryGetStateGet: %s\n" % e)

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

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

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ActivedirectoryApi()
body =  # Activedirectory_leave_0 |  (optional)

try: 
    api_instance.activedirectory_leave_post(body=body)
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryLeavePost: %s\n" % e)

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

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

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.activedirectory_nss_info_choices_get()
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryNssInfoChoicesGet: %s\n" % e)

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

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

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ActivedirectoryApi()
body =  # Activedirectory_update_0 |  (optional)

try: 
    api_instance.activedirectory_put(body=body)
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryPut: %s\n" % e)

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

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

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.activedirectory_started_get()
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryStartedGet: %s\n" % e)

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

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

public class AfpApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.afp_bindip_choices_get()
except ApiException as e:
    print("Exception when calling AfpApi->afpBindipChoicesGet: %s\n" % e)

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

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

public class AfpApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.afp_get()
except ApiException as e:
    print("Exception when calling AfpApi->afpGet: %s\n" % e)

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

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

public class AfpApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AfpApi()
body =  # Afp_update_0 |  (optional)

try: 
    api_instance.afp_put(body=body)
except ApiException as e:
    print("Exception when calling AfpApi->afpPut: %s\n" % e)

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

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

public class AlertApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertApi()
body =  # String |  (optional)

try: 
    api_instance.alert_dismiss_post(body=body)
except ApiException as e:
    print("Exception when calling AlertApi->alertDismissPost: %s\n" % e)

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

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

public class AlertApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.alert_list_categories_get()
except ApiException as e:
    print("Exception when calling AlertApi->alertListCategoriesGet: %s\n" % e)

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

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

public class AlertApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.alert_list_get()
except ApiException as e:
    print("Exception when calling AlertApi->alertListGet: %s\n" % e)

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

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

public class AlertApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.alert_list_policies_get()
except ApiException as e:
    print("Exception when calling AlertApi->alertListPoliciesGet: %s\n" % e)

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

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

public class AlertApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertApi()
body =  # String |  (optional)

try: 
    api_instance.alert_restore_post(body=body)
except ApiException as e:
    print("Exception when calling AlertApi->alertRestorePost: %s\n" % e)

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

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

public class AlertclassesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.alertclasses_get()
except ApiException as e:
    print("Exception when calling AlertclassesApi->alertclassesGet: %s\n" % e)

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

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

public class AlertclassesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertclassesApi()
body =  # Alertclasses_update_0 |  (optional)

try: 
    api_instance.alertclasses_put(body=body)
except ApiException as e:
    print("Exception when calling AlertclassesApi->alertclassesPut: %s\n" % e)

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

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

public class AlertserviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertserviceApi apiInstance = new AlertserviceApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.alertserviceGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertserviceApi#alertserviceGet");
            e.printStackTrace();
        }
    }
}

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertserviceApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->alertserviceGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertserviceGet: $@\n";
}

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertserviceApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.alertservice_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling AlertserviceApi->alertserviceGet: %s\n" % e)

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

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

public class AlertserviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertserviceApi apiInstance = new AlertserviceApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.alertserviceIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertserviceApi#alertserviceIdIdDelete");
            e.printStackTrace();
        }
    }
}

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

eval { 
    $api_instance->alertserviceIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertserviceIdIdDelete: $@\n";
}

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertserviceApi()
id = 56 # Integer | 

try: 
    api_instance.alertservice_id_id_delete(id)
except ApiException as e:
    print("Exception when calling AlertserviceApi->alertserviceIdIdDelete: %s\n" % e)

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

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

public class AlertserviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertserviceApi apiInstance = new AlertserviceApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.alertserviceIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertserviceApi#alertserviceIdIdGet");
            e.printStackTrace();
        }
    }
}

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertserviceApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->alertserviceIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertserviceIdIdGet: $@\n";
}

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertserviceApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.alertservice_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling AlertserviceApi->alertserviceIdIdGet: %s\n" % e)

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

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

public class AlertserviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertserviceApi apiInstance = new AlertserviceApi();
        Integer id = 56; // Integer | 
        Alertservice_update_1 body = ; // Alertservice_update_1 | 
        try {
            apiInstance.alertserviceIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertserviceApi#alertserviceIdIdPut");
            e.printStackTrace();
        }
    }
}

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertserviceApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Alertservice_update_1->new(); # Alertservice_update_1 | 

eval { 
    $api_instance->alertserviceIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertserviceIdIdPut: $@\n";
}

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertserviceApi()
id = 56 # Integer | 
body =  # Alertservice_update_1 |  (optional)

try: 
    api_instance.alertservice_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling AlertserviceApi->alertserviceIdIdPut: %s\n" % e)

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

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

public class AlertserviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.alertservice_list_types_get()
except ApiException as e:
    print("Exception when calling AlertserviceApi->alertserviceListTypesGet: %s\n" % e)

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

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

public class AlertserviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertserviceApi()
body =  # Alertservice_create_0 |  (optional)

try: 
    api_instance.alertservice_post(body=body)
except ApiException as e:
    print("Exception when calling AlertserviceApi->alertservicePost: %s\n" % e)

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

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

public class AlertserviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertserviceApi()
body =  # Alertservice_test_0 |  (optional)

try: 
    api_instance.alertservice_test_post(body=body)
except ApiException as e:
    print("Exception when calling AlertserviceApi->alertserviceTestPost: %s\n" % e)

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

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

public class ApiKeyApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ApiKeyApi apiInstance = new ApiKeyApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.apiKeyGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiKeyApi#apiKeyGet");
            e.printStackTrace();
        }
    }
}

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiKeyApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->apiKeyGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling ApiKeyApi->apiKeyGet: $@\n";
}

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiKeyApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.api_key_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling ApiKeyApi->apiKeyGet: %s\n" % e)

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

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

public class ApiKeyApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ApiKeyApi apiInstance = new ApiKeyApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.apiKeyIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiKeyApi#apiKeyIdIdDelete");
            e.printStackTrace();
        }
    }
}

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

eval { 
    $api_instance->apiKeyIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling ApiKeyApi->apiKeyIdIdDelete: $@\n";
}

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiKeyApi()
id = 56 # Integer | 

try: 
    api_instance.api_key_id_id_delete(id)
except ApiException as e:
    print("Exception when calling ApiKeyApi->apiKeyIdIdDelete: %s\n" % e)

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

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

public class ApiKeyApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ApiKeyApi apiInstance = new ApiKeyApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.apiKeyIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiKeyApi#apiKeyIdIdGet");
            e.printStackTrace();
        }
    }
}

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiKeyApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->apiKeyIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling ApiKeyApi->apiKeyIdIdGet: $@\n";
}

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiKeyApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.api_key_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling ApiKeyApi->apiKeyIdIdGet: %s\n" % e)

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

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

public class ApiKeyApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ApiKeyApi apiInstance = new ApiKeyApi();
        Integer id = 56; // Integer | 
        Api_key_update_1 body = ; // Api_key_update_1 | 
        try {
            apiInstance.apiKeyIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiKeyApi#apiKeyIdIdPut");
            e.printStackTrace();
        }
    }
}

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiKeyApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Api_key_update_1->new(); # Api_key_update_1 | 

eval { 
    $api_instance->apiKeyIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling ApiKeyApi->apiKeyIdIdPut: $@\n";
}

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiKeyApi()
id = 56 # Integer | 
body =  # Api_key_update_1 |  (optional)

try: 
    api_instance.api_key_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling ApiKeyApi->apiKeyIdIdPut: %s\n" % e)

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

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

public class ApiKeyApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiKeyApi()
body =  # Api_key_create_0 |  (optional)

try: 
    api_instance.api_key_post(body=body)
except ApiException as e:
    print("Exception when calling ApiKeyApi->apiKeyPost: %s\n" % e)

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

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

public class AuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AuthApi()
body =  # Auth_check_user |  (optional)

try: 
    api_instance.auth_check_user_post(body=body)
except ApiException as e:
    print("Exception when calling AuthApi->authCheckUserPost: %s\n" % e)

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

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

public class AuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AuthApi()
body =  # Auth_generate_token |  (optional)

try: 
    api_instance.auth_generate_token_post(body=body)
except ApiException as e:
    print("Exception when calling AuthApi->authGenerateTokenPost: %s\n" % e)

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

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

public class AuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AuthApi apiInstance = new AuthApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.authSessionsGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authSessionsGet");
            e.printStackTrace();
        }
    }
}

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AuthApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->authSessionsGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling AuthApi->authSessionsGet: $@\n";
}

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AuthApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.auth_sessions_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling AuthApi->authSessionsGet: %s\n" % e)

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

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

public class AuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.auth_two_factor_auth_get()
except ApiException as e:
    print("Exception when calling AuthApi->authTwoFactorAuthGet: %s\n" % e)

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

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

public class AuthTwofactorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.auth_twofactor_get()
except ApiException as e:
    print("Exception when calling AuthTwofactorApi->authTwofactorGet: %s\n" % e)

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

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

public class AuthTwofactorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.auth_twofactor_provisioning_uri_get()
except ApiException as e:
    print("Exception when calling AuthTwofactorApi->authTwofactorProvisioningUriGet: %s\n" % e)

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

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

public class AuthTwofactorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AuthTwofactorApi()
body =  # Auth_twofactor_update_0 |  (optional)

try: 
    api_instance.auth_twofactor_put(body=body)
except ApiException as e:
    print("Exception when calling AuthTwofactorApi->authTwofactorPut: %s\n" % e)

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

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

public class AuthTwofactorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.auth_twofactor_renew_secret_get()
except ApiException as e:
    print("Exception when calling AuthTwofactorApi->authTwofactorRenewSecretGet: %s\n" % e)

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

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

public class AuthTwofactorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AuthTwofactorApi()
body =  # String |  (optional)

try: 
    api_instance.auth_twofactor_verify_post(body=body)
except ApiException as e:
    print("Exception when calling AuthTwofactorApi->authTwofactorVerifyPost: %s\n" % e)

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

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

public class BootApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootApi()
body =  # Boot_attach |  (optional)

try: 
    api_instance.boot_attach_post(body=body)
except ApiException as e:
    print("Exception when calling BootApi->bootAttachPost: %s\n" % e)

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

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

public class BootApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootApi()
body =  # String |  (optional)

try: 
    api_instance.boot_detach_post(body=body)
except ApiException as e:
    print("Exception when calling BootApi->bootDetachPost: %s\n" % e)

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

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

public class BootApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.boot_get_disks_get()
except ApiException as e:
    print("Exception when calling BootApi->bootGetDisksGet: %s\n" % e)

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

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

public class BootApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.boot_get_scrub_interval_get()
except ApiException as e:
    print("Exception when calling BootApi->bootGetScrubIntervalGet: %s\n" % e)

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

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

public class BootApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.boot_get_state_get()
except ApiException as e:
    print("Exception when calling BootApi->bootGetStateGet: %s\n" % e)

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

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

public class BootApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootApi()
body =  # Boot_replace |  (optional)

try: 
    api_instance.boot_replace_post(body=body)
except ApiException as e:
    print("Exception when calling BootApi->bootReplacePost: %s\n" % e)

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

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

public class BootApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.boot_scrub_get()
except ApiException as e:
    print("Exception when calling BootApi->bootScrubGet: %s\n" % e)

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

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

public class BootApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootApi()
body =  # Integer |  (optional)

try: 
    api_instance.boot_set_scrub_interval_post(body=body)
except ApiException as e:
    print("Exception when calling BootApi->bootSetScrubIntervalPost: %s\n" % e)

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

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

public class BootenvApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootenvApi apiInstance = new BootenvApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.bootenvGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootenvApi#bootenvGet");
            e.printStackTrace();
        }
    }
}

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootenvApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->bootenvGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvGet: $@\n";
}

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootenvApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.bootenv_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling BootenvApi->bootenvGet: %s\n" % e)

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

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

public class BootenvApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootenvApi apiInstance = new BootenvApi();
        String id = id_example; // String | 
        Bootenv_activate body = ; // Bootenv_activate | 
        try {
            apiInstance.bootenvIdIdActivatePost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootenvApi#bootenvIdIdActivatePost");
            e.printStackTrace();
        }
    }
}

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootenvApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Bootenv_activate->new(); # Bootenv_activate | 

eval { 
    $api_instance->bootenvIdIdActivatePost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvIdIdActivatePost: $@\n";
}

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootenvApi()
id = id_example # String | 
body =  # Bootenv_activate |  (optional)

try: 
    api_instance.bootenv_id_id_activate_post(id, body=body)
except ApiException as e:
    print("Exception when calling BootenvApi->bootenvIdIdActivatePost: %s\n" % e)

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

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

public class BootenvApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootenvApi apiInstance = new BootenvApi();
        String id = id_example; // String | 
        try {
            apiInstance.bootenvIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootenvApi#bootenvIdIdDelete");
            e.printStackTrace();
        }
    }
}

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootenvApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->bootenvIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvIdIdDelete: $@\n";
}

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootenvApi()
id = id_example # String | 

try: 
    api_instance.bootenv_id_id_delete(id)
except ApiException as e:
    print("Exception when calling BootenvApi->bootenvIdIdDelete: %s\n" % e)

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

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

public class BootenvApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootenvApi apiInstance = new BootenvApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.bootenvIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootenvApi#bootenvIdIdGet");
            e.printStackTrace();
        }
    }
}

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootenvApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->bootenvIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvIdIdGet: $@\n";
}

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootenvApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.bootenv_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling BootenvApi->bootenvIdIdGet: %s\n" % e)

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

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

public class BootenvApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootenvApi apiInstance = new BootenvApi();
        String id = id_example; // String | 
        Bootenv_update_1 body = ; // Bootenv_update_1 | 
        try {
            apiInstance.bootenvIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootenvApi#bootenvIdIdPut");
            e.printStackTrace();
        }
    }
}

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootenvApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Bootenv_update_1->new(); # Bootenv_update_1 | 

eval { 
    $api_instance->bootenvIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvIdIdPut: $@\n";
}

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootenvApi()
id = id_example # String | 
body =  # Bootenv_update_1 |  (optional)

try: 
    api_instance.bootenv_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling BootenvApi->bootenvIdIdPut: %s\n" % e)

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

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

public class BootenvApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootenvApi apiInstance = new BootenvApi();
        String id = id_example; // String | 
        Bootenv_set_attribute_1 body = ; // Bootenv_set_attribute_1 | 
        try {
            apiInstance.bootenvIdIdSetAttributePost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootenvApi#bootenvIdIdSetAttributePost");
            e.printStackTrace();
        }
    }
}

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootenvApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Bootenv_set_attribute_1->new(); # Bootenv_set_attribute_1 | 

eval { 
    $api_instance->bootenvIdIdSetAttributePost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvIdIdSetAttributePost: $@\n";
}

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootenvApi()
id = id_example # String | 
body =  # Bootenv_set_attribute_1 |  (optional)

try: 
    api_instance.bootenv_id_id_set_attribute_post(id, body=body)
except ApiException as e:
    print("Exception when calling BootenvApi->bootenvIdIdSetAttributePost: %s\n" % e)

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

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

public class BootenvApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootenvApi()
body =  # Bootenv_create_0 |  (optional)

try: 
    api_instance.bootenv_post(body=body)
except ApiException as e:
    print("Exception when calling BootenvApi->bootenvPost: %s\n" % e)

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

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

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.certificate_acme_server_choices_get()
except ApiException as e:
    print("Exception when calling CertificateApi->certificateAcmeServerChoicesGet: %s\n" % e)

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

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

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.certificate_country_choices_get()
except ApiException as e:
    print("Exception when calling CertificateApi->certificateCountryChoicesGet: %s\n" % e)

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

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

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.certificate_ec_curve_choices_get()
except ApiException as e:
    print("Exception when calling CertificateApi->certificateEcCurveChoicesGet: %s\n" % e)

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

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

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

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

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.certificate_extended_key_usage_choices_get()
except ApiException as e:
    print("Exception when calling CertificateApi->certificateExtendedKeyUsageChoicesGet: %s\n" % e)

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

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

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.certificateGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateGet");
            e.printStackTrace();
        }
    }
}

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->certificateGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateGet: $@\n";
}

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.certificate_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CertificateApi->certificateGet: %s\n" % e)

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

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

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        Integer id = 56; // Integer | 
        Boolean body = ; // Boolean | 
        try {
            apiInstance.certificateIdIdDelete(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateIdIdDelete");
            e.printStackTrace();
        }
    }
}

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Boolean->new(); # Boolean | 

eval { 
    $api_instance->certificateIdIdDelete(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateIdIdDelete: $@\n";
}

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

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateApi()
id = 56 # Integer | 
body =  # Boolean |  (optional)

try: 
    api_instance.certificate_id_id_delete(id, body=body)
except ApiException as e:
    print("Exception when calling CertificateApi->certificateIdIdDelete: %s\n" % e)

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

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

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.certificateIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateIdIdGet");
            e.printStackTrace();
        }
    }
}

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

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->certificateIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateIdIdGet: $@\n";
}