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();
        }
    }
}

import io.swagger.client.api.AcmeDnsAuthenticatorApi;

public class AcmeDnsAuthenticatorApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AcmeDnsAuthenticatorApi()

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

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

namespace Example
{
    public class acmeDnsAuthenticatorAuthenticatorSchemasGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AcmeDnsAuthenticatorApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.AcmeDnsAuthenticatorApi;

public class AcmeDnsAuthenticatorApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *limit = 56; //  (optional)
Integer *offset = 56; //  (optional)
Boolean *count = true; //  (optional)
String *sort = sort_example; //  (optional)

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

[apiInstance acmeDnsAuthenticatorGetWith:limit
    offset:offset
    count:count
    sort:sort
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AcmeDnsAuthenticatorApi()

var opts = { 
  'limit': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'count': true, // {Boolean} 
  'sort': sort_example // {String} 
};

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

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

namespace Example
{
    public class acmeDnsAuthenticatorGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AcmeDnsAuthenticatorApi();
            var limit = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var count = true;  // Boolean |  (optional) 
            var sort = sort_example;  // String |  (optional) 

            try
            {
                apiInstance.acmeDnsAuthenticatorGet(limit, offset, count, sort);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AcmeDnsAuthenticatorApi.acmeDnsAuthenticatorGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\AcmeDnsAuthenticatorApi();
$limit = 56; // Integer | 
$offset = 56; // Integer | 
$count = true; // Boolean | 
$sort = sort_example; // String | 

try {
    $api_instance->acmeDnsAuthenticatorGet($limit, $offset, $count, $sort);
} catch (Exception $e) {
    echo 'Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorGet: ', $e->getMessage(), PHP_EOL;
}
?>

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();
        }
    }
}

import io.swagger.client.api.AcmeDnsAuthenticatorApi;

public class AcmeDnsAuthenticatorApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // 

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AcmeDnsAuthenticatorApi()

var id = 56; // {Integer} 


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

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

namespace Example
{
    public class acmeDnsAuthenticatorIdIdDeleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AcmeDnsAuthenticatorApi();
            var id = 56;  // Integer | 

            try
            {
                apiInstance.acmeDnsAuthenticatorIdIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AcmeDnsAuthenticatorApi.acmeDnsAuthenticatorIdIdDelete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\AcmeDnsAuthenticatorApi();
$id = 56; // Integer | 

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

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();
        Integer id = 56; // Integer | 
        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();
        }
    }
}

import io.swagger.client.api.AcmeDnsAuthenticatorApi;

public class AcmeDnsAuthenticatorApiExample {

    public static void main(String[] args) {
        AcmeDnsAuthenticatorApi apiInstance = new AcmeDnsAuthenticatorApi();
        Integer id = 56; // Integer | 
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // 
Integer *limit = 56; //  (optional)
Integer *offset = 56; //  (optional)
Boolean *count = true; //  (optional)
String *sort = sort_example; //  (optional)

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

[apiInstance acmeDnsAuthenticatorIdIdGetWith:id
    limit:limit
    offset:offset
    count:count
    sort:sort
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AcmeDnsAuthenticatorApi()

var id = 56; // {Integer} 

var opts = { 
  'limit': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'count': true, // {Boolean} 
  'sort': sort_example // {String} 
};

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

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

namespace Example
{
    public class acmeDnsAuthenticatorIdIdGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AcmeDnsAuthenticatorApi();
            var id = 56;  // Integer | 
            var limit = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var count = true;  // Boolean |  (optional) 
            var sort = sort_example;  // String |  (optional) 

            try
            {
                apiInstance.acmeDnsAuthenticatorIdIdGet(id, limit, offset, count, sort);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AcmeDnsAuthenticatorApi.acmeDnsAuthenticatorIdIdGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\AcmeDnsAuthenticatorApi();
$id = 56; // Integer | 
$limit = 56; // Integer | 
$offset = 56; // Integer | 
$count = true; // Boolean | 
$sort = sort_example; // String | 

try {
    $api_instance->acmeDnsAuthenticatorIdIdGet($id, $limit, $offset, $count, $sort);
} catch (Exception $e) {
    echo 'Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorIdIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

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 $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 = 56 # Integer | 
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();
        }
    }
}

import io.swagger.client.api.AcmeDnsAuthenticatorApi;

public class AcmeDnsAuthenticatorApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // 
Acme_dns_authenticator_update_1 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AcmeDnsAuthenticatorApi()

var id = 56; // {Integer} 

var opts = { 
  'body':  // {Acme_dns_authenticator_update_1} 
};

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

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

namespace Example
{
    public class acmeDnsAuthenticatorIdIdPutExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AcmeDnsAuthenticatorApi();
            var id = 56;  // Integer | 
            var body = new Acme_dns_authenticator_update_1(); // Acme_dns_authenticator_update_1 |  (optional) 

            try
            {
                apiInstance.acmeDnsAuthenticatorIdIdPut(id, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AcmeDnsAuthenticatorApi.acmeDnsAuthenticatorIdIdPut: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\AcmeDnsAuthenticatorApi();
$id = 56; // Integer | 
$body = ; // Acme_dns_authenticator_update_1 | 

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

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();
        }
    }
}

import io.swagger.client.api.AcmeDnsAuthenticatorApi;

public class AcmeDnsAuthenticatorApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Acme_dns_authenticator_create_0 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AcmeDnsAuthenticatorApi()

var opts = { 
  'body':  // {Acme_dns_authenticator_create_0} 
};

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

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

namespace Example
{
    public class acmeDnsAuthenticatorPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AcmeDnsAuthenticatorApi();
            var body = new Acme_dns_authenticator_create_0(); // Acme_dns_authenticator_create_0 |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\AcmeDnsAuthenticatorApi();
$body = ; // Acme_dns_authenticator_create_0 | 

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

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();
        }
    }
}

import io.swagger.client.api.ActivedirectoryApi;

public class ActivedirectoryApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.ActivedirectoryApi()

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

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

namespace Example
{
    public class activedirectoryChangeTrustAccountPwGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ActivedirectoryApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.ActivedirectoryApi;

public class ActivedirectoryApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.ActivedirectoryApi()

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

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

namespace Example
{
    public class activedirectoryDomainInfoGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ActivedirectoryApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.ActivedirectoryApi;

public class ActivedirectoryApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.ActivedirectoryApi()

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

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

namespace Example
{
    public class activedirectoryGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ActivedirectoryApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.ActivedirectoryApi;

public class ActivedirectoryApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.ActivedirectoryApi()

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

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

namespace Example
{
    public class activedirectoryGetSpnListGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ActivedirectoryApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.ActivedirectoryApi;

public class ActivedirectoryApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.ActivedirectoryApi()

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

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

namespace Example
{
    public class activedirectoryGetStateGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ActivedirectoryApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.ActivedirectoryApi;

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Activedirectory_leave_0 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.ActivedirectoryApi()

var opts = { 
  'body':  // {Activedirectory_leave_0} 
};

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

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

namespace Example
{
    public class activedirectoryLeavePostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ActivedirectoryApi();
            var body = new Activedirectory_leave_0(); // Activedirectory_leave_0 |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ActivedirectoryApi();
$body = ; // Activedirectory_leave_0 | 

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

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();
        }
    }
}

import io.swagger.client.api.ActivedirectoryApi;

public class ActivedirectoryApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.ActivedirectoryApi()

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

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

namespace Example
{
    public class activedirectoryNssInfoChoicesGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ActivedirectoryApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.ActivedirectoryApi;

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Activedirectory_update_0 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.ActivedirectoryApi()

var opts = { 
  'body':  // {Activedirectory_update_0} 
};

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

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

namespace Example
{
    public class activedirectoryPutExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ActivedirectoryApi();
            var body = new Activedirectory_update_0(); // Activedirectory_update_0 |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ActivedirectoryApi();
$body = ; // Activedirectory_update_0 | 

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

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();
        }
    }
}

import io.swagger.client.api.ActivedirectoryApi;

public class ActivedirectoryApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.ActivedirectoryApi()

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

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

namespace Example
{
    public class activedirectoryStartedGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ActivedirectoryApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.AfpApi;

public class AfpApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AfpApi()

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

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

namespace Example
{
    public class afpBindipChoicesGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AfpApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.AfpApi;

public class AfpApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AfpApi()

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

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

namespace Example
{
    public class afpGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AfpApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.AfpApi;

public class AfpApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Afp_update_0 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AfpApi()

var opts = { 
  'body':  // {Afp_update_0} 
};

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

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

namespace Example
{
    public class afpPutExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AfpApi();
            var body = new Afp_update_0(); // Afp_update_0 |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\AfpApi();
$body = ; // Afp_update_0 | 

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

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();
        }
    }
}

import io.swagger.client.api.AlertApi;

public class AlertApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AlertApi()

var opts = { 
  'body':  // {String} 
};

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

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

namespace Example
{
    public class alertDismissPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AlertApi();
            var body = new String(); // String |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\AlertApi();
$body = ; // String | 

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

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();
        }
    }
}

import io.swagger.client.api.AlertApi;

public class AlertApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AlertApi()

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

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

namespace Example
{
    public class alertListCategoriesGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AlertApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.AlertApi;

public class AlertApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AlertApi()

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

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

namespace Example
{
    public class alertListGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AlertApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.AlertApi;

public class AlertApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AlertApi()

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

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

namespace Example
{
    public class alertListPoliciesGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AlertApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.AlertApi;

public class AlertApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AlertApi()

var opts = { 
  'body':  // {String} 
};

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

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

namespace Example
{
    public class alertRestorePostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AlertApi();
            var body = new String(); // String |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\AlertApi();
$body = ; // String | 

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

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();
        }
    }
}

import io.swagger.client.api.AlertclassesApi;

public class AlertclassesApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AlertclassesApi()

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

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

namespace Example
{
    public class alertclassesGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AlertclassesApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.AlertclassesApi;

public class AlertclassesApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Alertclasses_update_0 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AlertclassesApi()

var opts = { 
  'body':  // {Alertclasses_update_0} 
};

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

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

namespace Example
{
    public class alertclassesPutExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AlertclassesApi();
            var body = new Alertclasses_update_0(); // Alertclasses_update_0 |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\AlertclassesApi();
$body = ; // Alertclasses_update_0 | 

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

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();
        }
    }
}

import io.swagger.client.api.AlertserviceApi;

public class AlertserviceApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *limit = 56; //  (optional)
Integer *offset = 56; //  (optional)
Boolean *count = true; //  (optional)
String *sort = sort_example; //  (optional)

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

[apiInstance alertserviceGetWith:limit
    offset:offset
    count:count
    sort:sort
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AlertserviceApi()

var opts = { 
  'limit': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'count': true, // {Boolean} 
  'sort': sort_example // {String} 
};

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

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

namespace Example
{
    public class alertserviceGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AlertserviceApi();
            var limit = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var count = true;  // Boolean |  (optional) 
            var sort = sort_example;  // String |  (optional) 

            try
            {
                apiInstance.alertserviceGet(limit, offset, count, sort);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AlertserviceApi.alertserviceGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\AlertserviceApi();
$limit = 56; // Integer | 
$offset = 56; // Integer | 
$count = true; // Boolean | 
$sort = sort_example; // String | 

try {
    $api_instance->alertserviceGet($limit, $offset, $count, $sort);
} catch (Exception $e) {
    echo 'Exception when calling AlertserviceApi->alertserviceGet: ', $e->getMessage(), PHP_EOL;
}
?>

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();
        }
    }
}

import io.swagger.client.api.AlertserviceApi;

public class AlertserviceApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // 

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AlertserviceApi()

var id = 56; // {Integer} 


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

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

namespace Example
{
    public class alertserviceIdIdDeleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AlertserviceApi();
            var id = 56;  // Integer | 

            try
            {
                apiInstance.alertserviceIdIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AlertserviceApi.alertserviceIdIdDelete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\AlertserviceApi();
$id = 56; // Integer | 

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

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();
        Integer id = 56; // Integer | 
        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();
        }
    }
}

import io.swagger.client.api.AlertserviceApi;

public class AlertserviceApiExample {

    public static void main(String[] args) {
        AlertserviceApi apiInstance = new AlertserviceApi();
        Integer id = 56; // Integer | 
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // 
Integer *limit = 56; //  (optional)
Integer *offset = 56; //  (optional)
Boolean *count = true; //  (optional)
String *sort = sort_example; //  (optional)

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

[apiInstance alertserviceIdIdGetWith:id
    limit:limit
    offset:offset
    count:count
    sort:sort
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AlertserviceApi()

var id = 56; // {Integer} 

var opts = { 
  'limit': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'count': true, // {Boolean} 
  'sort': sort_example // {String} 
};

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

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

namespace Example
{
    public class alertserviceIdIdGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AlertserviceApi();
            var id = 56;  // Integer | 
            var limit = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var count = true;  // Boolean |  (optional) 
            var sort = sort_example;  // String |  (optional) 

            try
            {
                apiInstance.alertserviceIdIdGet(id, limit, offset, count, sort);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AlertserviceApi.alertserviceIdIdGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\AlertserviceApi();
$id = 56; // Integer | 
$limit = 56; // Integer | 
$offset = 56; // Integer | 
$count = true; // Boolean | 
$sort = sort_example; // String | 

try {
    $api_instance->alertserviceIdIdGet($id, $limit, $offset, $count, $sort);
} catch (Exception $e) {
    echo 'Exception when calling AlertserviceApi->alertserviceIdIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

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 $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 = 56 # Integer | 
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();
        }
    }
}

import io.swagger.client.api.AlertserviceApi;

public class AlertserviceApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // 
Alertservice_update_1 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AlertserviceApi()

var id = 56; // {Integer} 

var opts = { 
  'body':  // {Alertservice_update_1} 
};

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

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

namespace Example
{
    public class alertserviceIdIdPutExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AlertserviceApi();
            var id = 56;  // Integer | 
            var body = new Alertservice_update_1(); // Alertservice_update_1 |  (optional) 

            try
            {
                apiInstance.alertserviceIdIdPut(id, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AlertserviceApi.alertserviceIdIdPut: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\AlertserviceApi();
$id = 56; // Integer | 
$body = ; // Alertservice_update_1 | 

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

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();
        }
    }
}

import io.swagger.client.api.AlertserviceApi;

public class AlertserviceApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AlertserviceApi()

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

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

namespace Example
{
    public class alertserviceListTypesGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AlertserviceApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.AlertserviceApi;

public class AlertserviceApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Alertservice_create_0 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AlertserviceApi()

var opts = { 
  'body':  // {Alertservice_create_0} 
};

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

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

namespace Example
{
    public class alertservicePostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AlertserviceApi();
            var body = new Alertservice_create_0(); // Alertservice_create_0 |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\AlertserviceApi();
$body = ; // Alertservice_create_0 | 

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

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();
        }
    }
}

import io.swagger.client.api.AlertserviceApi;

public class AlertserviceApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Alertservice_test_0 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AlertserviceApi()

var opts = { 
  'body':  // {Alertservice_test_0} 
};

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

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

namespace Example
{
    public class alertserviceTestPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AlertserviceApi();
            var body = new Alertservice_test_0(); // Alertservice_test_0 |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\AlertserviceApi();
$body = ; // Alertservice_test_0 | 

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

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();
        }
    }
}

import io.swagger.client.api.ApiKeyApi;

public class ApiKeyApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *limit = 56; //  (optional)
Integer *offset = 56; //  (optional)
Boolean *count = true; //  (optional)
String *sort = sort_example; //  (optional)

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

[apiInstance apiKeyGetWith:limit
    offset:offset
    count:count
    sort:sort
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.ApiKeyApi()

var opts = { 
  'limit': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'count': true, // {Boolean} 
  'sort': sort_example // {String} 
};

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

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

namespace Example
{
    public class apiKeyGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiKeyApi();
            var limit = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var count = true;  // Boolean |  (optional) 
            var sort = sort_example;  // String |  (optional) 

            try
            {
                apiInstance.apiKeyGet(limit, offset, count, sort);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiKeyApi.apiKeyGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiKeyApi();
$limit = 56; // Integer | 
$offset = 56; // Integer | 
$count = true; // Boolean | 
$sort = sort_example; // String | 

try {
    $api_instance->apiKeyGet($limit, $offset, $count, $sort);
} catch (Exception $e) {
    echo 'Exception when calling ApiKeyApi->apiKeyGet: ', $e->getMessage(), PHP_EOL;
}
?>

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();
        }
    }
}

import io.swagger.client.api.ApiKeyApi;

public class ApiKeyApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // 

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.ApiKeyApi()

var id = 56; // {Integer} 


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

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

namespace Example
{
    public class apiKeyIdIdDeleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiKeyApi();
            var id = 56;  // Integer | 

            try
            {
                apiInstance.apiKeyIdIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiKeyApi.apiKeyIdIdDelete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiKeyApi();
$id = 56; // Integer | 

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

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();
        Integer id = 56; // Integer | 
        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();
        }
    }
}

import io.swagger.client.api.ApiKeyApi;

public class ApiKeyApiExample {

    public static void main(String[] args) {
        ApiKeyApi apiInstance = new ApiKeyApi();
        Integer id = 56; // Integer | 
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // 
Integer *limit = 56; //  (optional)
Integer *offset = 56; //  (optional)
Boolean *count = true; //  (optional)
String *sort = sort_example; //  (optional)

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

[apiInstance apiKeyIdIdGetWith:id
    limit:limit
    offset:offset
    count:count
    sort:sort
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.ApiKeyApi()

var id = 56; // {Integer} 

var opts = { 
  'limit': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'count': true, // {Boolean} 
  'sort': sort_example // {String} 
};

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

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

namespace Example
{
    public class apiKeyIdIdGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiKeyApi();
            var id = 56;  // Integer | 
            var limit = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var count = true;  // Boolean |  (optional) 
            var sort = sort_example;  // String |  (optional) 

            try
            {
                apiInstance.apiKeyIdIdGet(id, limit, offset, count, sort);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiKeyApi.apiKeyIdIdGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiKeyApi();
$id = 56; // Integer | 
$limit = 56; // Integer | 
$offset = 56; // Integer | 
$count = true; // Boolean | 
$sort = sort_example; // String | 

try {
    $api_instance->apiKeyIdIdGet($id, $limit, $offset, $count, $sort);
} catch (Exception $e) {
    echo 'Exception when calling ApiKeyApi->apiKeyIdIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

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 $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 = 56 # Integer | 
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();
        }
    }
}

import io.swagger.client.api.ApiKeyApi;

public class ApiKeyApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // 
Api_key_update_1 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.ApiKeyApi()

var id = 56; // {Integer} 

var opts = { 
  'body':  // {Api_key_update_1} 
};

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

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

namespace Example
{
    public class apiKeyIdIdPutExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiKeyApi();
            var id = 56;  // Integer | 
            var body = new Api_key_update_1(); // Api_key_update_1 |  (optional) 

            try
            {
                apiInstance.apiKeyIdIdPut(id, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiKeyApi.apiKeyIdIdPut: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiKeyApi();
$id = 56; // Integer | 
$body = ; // Api_key_update_1 | 

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

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();
        }
    }
}

import io.swagger.client.api.ApiKeyApi;

public class ApiKeyApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Api_key_create_0 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.ApiKeyApi()

var opts = { 
  'body':  // {Api_key_create_0} 
};

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

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

namespace Example
{
    public class apiKeyPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiKeyApi();
            var body = new Api_key_create_0(); // Api_key_create_0 |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiKeyApi();
$body = ; // Api_key_create_0 | 

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

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();
        }
    }
}

import io.swagger.client.api.AuthApi;

public class AuthApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Auth_check_user *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AuthApi()

var opts = { 
  'body':  // {Auth_check_user} 
};

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

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

namespace Example
{
    public class authCheckUserPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AuthApi();
            var body = new Auth_check_user(); // Auth_check_user |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\AuthApi();
$body = ; // Auth_check_user | 

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

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();
        }
    }
}

import io.swagger.client.api.AuthApi;

public class AuthApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Auth_generate_token *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AuthApi()

var opts = { 
  'body':  // {Auth_generate_token} 
};

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

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

namespace Example
{
    public class authGenerateTokenPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AuthApi();
            var body = new Auth_generate_token(); // Auth_generate_token |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\AuthApi();
$body = ; // Auth_generate_token | 

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

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();
        }
    }
}

import io.swagger.client.api.AuthApi;

public class AuthApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *limit = 56; //  (optional)
Integer *offset = 56; //  (optional)
Boolean *count = true; //  (optional)
String *sort = sort_example; //  (optional)

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

[apiInstance authSessionsGetWith:limit
    offset:offset
    count:count
    sort:sort
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AuthApi()

var opts = { 
  'limit': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'count': true, // {Boolean} 
  'sort': sort_example // {String} 
};

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

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

namespace Example
{
    public class authSessionsGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AuthApi();
            var limit = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var count = true;  // Boolean |  (optional) 
            var sort = sort_example;  // String |  (optional) 

            try
            {
                apiInstance.authSessionsGet(limit, offset, count, sort);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthApi.authSessionsGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\AuthApi();
$limit = 56; // Integer | 
$offset = 56; // Integer | 
$count = true; // Boolean | 
$sort = sort_example; // String | 

try {
    $api_instance->authSessionsGet($limit, $offset, $count, $sort);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->authSessionsGet: ', $e->getMessage(), PHP_EOL;
}
?>

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();
        }
    }
}

import io.swagger.client.api.AuthApi;

public class AuthApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AuthApi()

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

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

namespace Example
{
    public class authTwoFactorAuthGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AuthApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.AuthTwofactorApi;

public class AuthTwofactorApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AuthTwofactorApi()

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

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

namespace Example
{
    public class authTwofactorGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AuthTwofactorApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.AuthTwofactorApi;

public class AuthTwofactorApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AuthTwofactorApi()

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

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

namespace Example
{
    public class authTwofactorProvisioningUriGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AuthTwofactorApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.AuthTwofactorApi;

public class AuthTwofactorApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Auth_twofactor_update_0 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AuthTwofactorApi()

var opts = { 
  'body':  // {Auth_twofactor_update_0} 
};

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

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

namespace Example
{
    public class authTwofactorPutExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AuthTwofactorApi();
            var body = new Auth_twofactor_update_0(); // Auth_twofactor_update_0 |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\AuthTwofactorApi();
$body = ; // Auth_twofactor_update_0 | 

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

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();
        }
    }
}

import io.swagger.client.api.AuthTwofactorApi;

public class AuthTwofactorApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AuthTwofactorApi()

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

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

namespace Example
{
    public class authTwofactorRenewSecretGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AuthTwofactorApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.AuthTwofactorApi;

public class AuthTwofactorApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.AuthTwofactorApi()

var opts = { 
  'body':  // {String} 
};

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

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

namespace Example
{
    public class authTwofactorVerifyPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AuthTwofactorApi();
            var body = new String(); // String |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\AuthTwofactorApi();
$body = ; // String | 

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

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();
        }
    }
}

import io.swagger.client.api.BootApi;

public class BootApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Boot_attach *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.BootApi()

var opts = { 
  'body':  // {Boot_attach} 
};

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

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

namespace Example
{
    public class bootAttachPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new BootApi();
            var body = new Boot_attach(); // Boot_attach |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\BootApi();
$body = ; // Boot_attach | 

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

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();
        }
    }
}

import io.swagger.client.api.BootApi;

public class BootApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.BootApi()

var opts = { 
  'body':  // {String} 
};

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

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

namespace Example
{
    public class bootDetachPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new BootApi();
            var body = new String(); // String |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\BootApi();
$body = ; // String | 

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

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();
        }
    }
}

import io.swagger.client.api.BootApi;

public class BootApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.BootApi()

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

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

namespace Example
{
    public class bootGetDisksGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new BootApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.BootApi;

public class BootApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.BootApi()

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

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

namespace Example
{
    public class bootGetScrubIntervalGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new BootApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.BootApi;

public class BootApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.BootApi()

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

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

namespace Example
{
    public class bootGetStateGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new BootApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.BootApi;

public class BootApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Boot_replace *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.BootApi()

var opts = { 
  'body':  // {Boot_replace} 
};

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

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

namespace Example
{
    public class bootReplacePostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new BootApi();
            var body = new Boot_replace(); // Boot_replace |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\BootApi();
$body = ; // Boot_replace | 

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

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();
        }
    }
}

import io.swagger.client.api.BootApi;

public class BootApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.BootApi()

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

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

namespace Example
{
    public class bootScrubGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new BootApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.BootApi;

public class BootApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.BootApi()

var opts = { 
  'body':  // {Integer} 
};

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

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

namespace Example
{
    public class bootSetScrubIntervalPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new BootApi();
            var body = new Integer(); // Integer |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\BootApi();
$body = ; // Integer | 

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

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();
        }
    }
}

import io.swagger.client.api.BootenvApi;

public class BootenvApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *limit = 56; //  (optional)
Integer *offset = 56; //  (optional)
Boolean *count = true; //  (optional)
String *sort = sort_example; //  (optional)

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

[apiInstance bootenvGetWith:limit
    offset:offset
    count:count
    sort:sort
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.BootenvApi()

var opts = { 
  'limit': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'count': true, // {Boolean} 
  'sort': sort_example // {String} 
};

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

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

namespace Example
{
    public class bootenvGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new BootenvApi();
            var limit = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var count = true;  // Boolean |  (optional) 
            var sort = sort_example;  // String |  (optional) 

            try
            {
                apiInstance.bootenvGet(limit, offset, count, sort);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BootenvApi.bootenvGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\BootenvApi();
$limit = 56; // Integer | 
$offset = 56; // Integer | 
$count = true; // Boolean | 
$sort = sort_example; // String | 

try {
    $api_instance->bootenvGet($limit, $offset, $count, $sort);
} catch (Exception $e) {
    echo 'Exception when calling BootenvApi->bootenvGet: ', $e->getMessage(), PHP_EOL;
}
?>

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();
        }
    }
}

import io.swagger.client.api.BootenvApi;

public class BootenvApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 
Bootenv_activate *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.BootenvApi()

var id = id_example; // {String} 

var opts = { 
  'body':  // {Bootenv_activate} 
};

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

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

namespace Example
{
    public class bootenvIdIdActivatePostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new BootenvApi();
            var id = id_example;  // String | 
            var body = new Bootenv_activate(); // Bootenv_activate |  (optional) 

            try
            {
                apiInstance.bootenvIdIdActivatePost(id, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BootenvApi.bootenvIdIdActivatePost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\BootenvApi();
$id = id_example; // String | 
$body = ; // Bootenv_activate | 

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

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();
        }
    }
}

import io.swagger.client.api.BootenvApi;

public class BootenvApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.BootenvApi()

var id = id_example; // {String} 


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

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

namespace Example
{
    public class bootenvIdIdDeleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new BootenvApi();
            var id = id_example;  // String | 

            try
            {
                apiInstance.bootenvIdIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BootenvApi.bootenvIdIdDelete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\BootenvApi();
$id = id_example; // String | 

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

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();
        String id = id_example; // String | 
        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();
        }
    }
}

import io.swagger.client.api.BootenvApi;

public class BootenvApiExample {

    public static void main(String[] args) {
        BootenvApi apiInstance = new BootenvApi();
        String id = id_example; // String | 
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 
Integer *limit = 56; //  (optional)
Integer *offset = 56; //  (optional)
Boolean *count = true; //  (optional)
String *sort = sort_example; //  (optional)

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

[apiInstance bootenvIdIdGetWith:id
    limit:limit
    offset:offset
    count:count
    sort:sort
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.BootenvApi()

var id = id_example; // {String} 

var opts = { 
  'limit': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'count': true, // {Boolean} 
  'sort': sort_example // {String} 
};

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

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

namespace Example
{
    public class bootenvIdIdGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new BootenvApi();
            var id = id_example;  // String | 
            var limit = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var count = true;  // Boolean |  (optional) 
            var sort = sort_example;  // String |  (optional) 

            try
            {
                apiInstance.bootenvIdIdGet(id, limit, offset, count, sort);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BootenvApi.bootenvIdIdGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\BootenvApi();
$id = id_example; // String | 
$limit = 56; // Integer | 
$offset = 56; // Integer | 
$count = true; // Boolean | 
$sort = sort_example; // String | 

try {
    $api_instance->bootenvIdIdGet($id, $limit, $offset, $count, $sort);
} catch (Exception $e) {
    echo 'Exception when calling BootenvApi->bootenvIdIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

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 $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 = id_example # String | 
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();
        }
    }
}

import io.swagger.client.api.BootenvApi;

public class BootenvApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 
Bootenv_update_1 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.BootenvApi()

var id = id_example; // {String} 

var opts = { 
  'body':  // {Bootenv_update_1} 
};

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

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

namespace Example
{
    public class bootenvIdIdPutExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new BootenvApi();
            var id = id_example;  // String | 
            var body = new Bootenv_update_1(); // Bootenv_update_1 |  (optional) 

            try
            {
                apiInstance.bootenvIdIdPut(id, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BootenvApi.bootenvIdIdPut: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\BootenvApi();
$id = id_example; // String | 
$body = ; // Bootenv_update_1 | 

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

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();
        }
    }
}

import io.swagger.client.api.BootenvApi;

public class BootenvApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 
Bootenv_set_attribute_1 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.BootenvApi()

var id = id_example; // {String} 

var opts = { 
  'body':  // {Bootenv_set_attribute_1} 
};

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

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

namespace Example
{
    public class bootenvIdIdSetAttributePostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new BootenvApi();
            var id = id_example;  // String | 
            var body = new Bootenv_set_attribute_1(); // Bootenv_set_attribute_1 |  (optional) 

            try
            {
                apiInstance.bootenvIdIdSetAttributePost(id, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BootenvApi.bootenvIdIdSetAttributePost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\BootenvApi();
$id = id_example; // String | 
$body = ; // Bootenv_set_attribute_1 | 

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

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();
        }
    }
}

import io.swagger.client.api.BootenvApi;

public class BootenvApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Bootenv_create_0 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.BootenvApi()

var opts = { 
  'body':  // {Bootenv_create_0} 
};

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

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

namespace Example
{
    public class bootenvPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new BootenvApi();
            var body = new Bootenv_create_0(); // Bootenv_create_0 |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\BootenvApi();
$body = ; // Bootenv_create_0 | 

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

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();
        }
    }
}

import io.swagger.client.api.CertificateApi;

public class CertificateApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CertificateApi()

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

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

namespace Example
{
    public class certificateAcmeServerChoicesGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CertificateApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.CertificateApi;

public class CertificateApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CertificateApi()

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

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

namespace Example
{
    public class certificateCountryChoicesGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CertificateApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.CertificateApi;

public class CertificateApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CertificateApi()

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

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

namespace Example
{
    public class certificateEcCurveChoicesGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CertificateApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.CertificateApi;

public class CertificateApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CertificateApi()

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

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

namespace Example
{
    public class certificateExtendedKeyUsageChoicesGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CertificateApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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();
        }
    }
}

import io.swagger.client.api.CertificateApi;

public class CertificateApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *limit = 56; //  (optional)
Integer *offset = 56; //  (optional)
Boolean *count = true; //  (optional)
String *sort = sort_example; //  (optional)

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

[apiInstance certificateGetWith:limit
    offset:offset
    count:count
    sort:sort
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CertificateApi()

var opts = { 
  'limit': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'count': true, // {Boolean} 
  'sort': sort_example // {String} 
};

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

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

namespace Example
{
    public class certificateGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CertificateApi();
            var limit = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var count = true;  // Boolean |  (optional) 
            var sort = sort_example;  // String |  (optional) 

            try
            {
                apiInstance.certificateGet(limit, offset, count, sort);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CertificateApi.certificateGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\CertificateApi();
$limit = 56; // Integer | 
$offset = 56; // Integer | 
$count = true; // Boolean | 
$sort = sort_example; // String | 

try {
    $api_instance->certificateGet($limit, $offset, $count, $sort);
} catch (Exception $e) {
    echo 'Exception when calling CertificateApi->certificateGet: ', $e->getMessage(), PHP_EOL;
}
?>

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();
        }
    }
}

import io.swagger.client.api.CertificateApi;

public class CertificateApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // 
Boolean *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CertificateApi()

var id = 56; // {Integer} 

var opts = { 
  'body':  // {Boolean} 
};

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

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

namespace Example
{
    public class certificateIdIdDeleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CertificateApi();
            var id = 56;  // Integer | 
            var body = new Boolean(); // Boolean |  (optional) 

            try
            {
                apiInstance.certificateIdIdDelete(id, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CertificateApi.certificateIdIdDelete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\CertificateApi();
$id = 56; // Integer | 
$body = ; // Boolean | 

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

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();
        Integer id = 56; // Integer | 
        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();
        }
    }
}

import io.swagger.client.api.CertificateApi;

public class CertificateApiExample {

    public static void main(String[] args) {
        CertificateApi apiInstance = new CertificateApi();
        Integer id = 56; // Integer | 
        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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // 
Integer *limit = 56; //  (optional)
Integer *offset = 56; //  (optional)
Boolean *count = true; //  (optional)
String *sort = sort_example; //  (optional)

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

[apiInstance certificateIdIdGetWith:id
    limit:limit
    offset:offset
    count:count
    sort:sort
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CertificateApi()

var id = 56; // {Integer} 

var opts = { 
  'limit': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'count': true, // {Boolean} 
  'sort': sort_example // {String} 
};

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

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

namespace Example
{
    public class certificateIdIdGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CertificateApi();
            var id = 56;  // Integer | 
            var limit = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var count = true;  // Boolean |  (optional) 
            var sort = sort_example;  // String |  (optional) 

            try
            {
                apiInstance.certificateIdIdGet(id, limit, offset, count, sort);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CertificateApi.certificateIdIdGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\CertificateApi();
$id = 56; // Integer | 
$limit = 56; // Integer | 
$offset = 56; // Integer | 
$count = true; // Boolean | 
$sort = sort_example; // String | 

try {
    $api_instance->certificateIdIdGet($id, $limit, $offset, $count, $sort);
} catch (Exception $e) {
    echo 'Exception when calling CertificateApi->certificateIdIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

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 $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";
}

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 | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.certificate_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CertificateApi->certificateIdIdGet: %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 | 
        Certificate_update_1 body = ; // Certificate_update_1 | 
        try {
            apiInstance.certificateIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateIdIdPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CertificateApi;

public class CertificateApiExample {

    public static void main(String[] args) {
        CertificateApi apiInstance = new CertificateApi();
        Integer id = 56; // Integer | 
        Certificate_update_1 body = ; // Certificate_update_1 | 
        try {
            apiInstance.certificateIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateIdIdPut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // 
Certificate_update_1 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CertificateApi()

var id = 56; // {Integer} 

var opts = { 
  'body':  // {Certificate_update_1} 
};

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

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

namespace Example
{
    public class certificateIdIdPutExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CertificateApi();
            var id = 56;  // Integer | 
            var body = new Certificate_update_1(); // Certificate_update_1 |  (optional) 

            try
            {
                apiInstance.certificateIdIdPut(id, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CertificateApi.certificateIdIdPut: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\CertificateApi();
$id = 56; // Integer | 
$body = ; // Certificate_update_1 | 

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

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::Certificate_update_1->new(); # Certificate_update_1 | 

eval { 
    $api_instance->certificateIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateIdIdPut: $@\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 =  # Certificate_update_1 |  (optional)

try: 
    api_instance.certificate_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling CertificateApi->certificateIdIdPut: %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.certificateKeyTypeChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateKeyTypeChoicesGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CertificateApi;

public class CertificateApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CertificateApi()

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

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

namespace Example
{
    public class certificateKeyTypeChoicesGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CertificateApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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->certificateKeyTypeChoicesGet();
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateKeyTypeChoicesGet: $@\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_key_type_choices_get()
except ApiException as e:
    print("Exception when calling CertificateApi->certificateKeyTypeChoicesGet: %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();
        Certificate_create_0 body = ; // Certificate_create_0 | 
        try {
            apiInstance.certificatePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificatePost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CertificateApi;

public class CertificateApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Certificate_create_0 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CertificateApi()

var opts = { 
  'body':  // {Certificate_create_0} 
};

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

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

namespace Example
{
    public class certificatePostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CertificateApi();
            var body = new Certificate_create_0(); // Certificate_create_0 |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\CertificateApi();
$body = ; // Certificate_create_0 | 

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

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 $body = WWW::SwaggerClient::Object::Certificate_create_0->new(); # Certificate_create_0 | 

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

try: 
    api_instance.certificate_post(body=body)
except ApiException as e:
    print("Exception when calling CertificateApi->certificatePost: %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.certificateProfilesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateProfilesGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CertificateApi;

public class CertificateApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CertificateApi()

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

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

namespace Example
{
    public class certificateProfilesGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CertificateApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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->certificateProfilesGet();
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateProfilesGet: $@\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_profiles_get()
except ApiException as e:
    print("Exception when calling CertificateApi->certificateProfilesGet: %s\n" % e)

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

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

public class CertificateauthorityApiExample {

    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");

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

import io.swagger.client.api.CertificateauthorityApi;

public class CertificateauthorityApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Certificateauthority_ca_sign_csr_0 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CertificateauthorityApi()

var opts = { 
  'body':  // {Certificateauthority_ca_sign_csr_0} 
};

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

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

namespace Example
{
    public class certificateauthorityCaSignCsrPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CertificateauthorityApi();
            var body = new Certificateauthority_ca_sign_csr_0(); // Certificateauthority_ca_sign_csr_0 |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\CertificateauthorityApi();
$body = ; // Certificateauthority_ca_sign_csr_0 | 

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

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

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

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

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

try: 
    api_instance.certificateauthority_ca_sign_csr_post(body=body)
except ApiException as e:
    print("Exception when calling CertificateauthorityApi->certificateauthorityCaSignCsrPost: %s\n" % e)

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

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

public class CertificateauthorityApiExample {

    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");

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

import io.swagger.client.api.CertificateauthorityApi;

public class CertificateauthorityApiExample {

    public static void main(String[] args) {
        CertificateauthorityApi apiInstance = new CertificateauthorityApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.certificateauthorityGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateauthorityApi#certificateauthorityGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *limit = 56; //  (optional)
Integer *offset = 56; //  (optional)
Boolean *count = true; //  (optional)
String *sort = sort_example; //  (optional)

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

[apiInstance certificateauthorityGetWith:limit
    offset:offset
    count:count
    sort:sort
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CertificateauthorityApi()

var opts = { 
  'limit': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'count': true, // {Boolean} 
  'sort': sort_example // {String} 
};

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

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

namespace Example
{
    public class certificateauthorityGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CertificateauthorityApi();
            var limit = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var count = true;  // Boolean |  (optional) 
            var sort = sort_example;  // String |  (optional) 

            try
            {
                apiInstance.certificateauthorityGet(limit, offset, count, sort);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CertificateauthorityApi.certificateauthorityGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\CertificateauthorityApi();
$limit = 56; // Integer | 
$offset = 56; // Integer | 
$count = true; // Boolean | 
$sort = sort_example; // String | 

try {
    $api_instance->certificateauthorityGet($limit, $offset, $count, $sort);
} catch (Exception $e) {
    echo 'Exception when calling CertificateauthorityApi->certificateauthorityGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

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

eval { 
    $api_instance->certificateauthorityGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CertificateauthorityApi->certificateauthorityGet: $@\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.CertificateauthorityApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

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

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

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

public class CertificateauthorityApiExample {

    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");

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

import io.swagger.client.api.CertificateauthorityApi;

public class CertificateauthorityApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // 

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CertificateauthorityApi()

var id = 56; // {Integer} 


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

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

namespace Example
{
    public class certificateauthorityIdIdDeleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CertificateauthorityApi();
            var id = 56;  // Integer | 

            try
            {
                apiInstance.certificateauthorityIdIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CertificateauthorityApi.certificateauthorityIdIdDelete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\CertificateauthorityApi();
$id = 56; // Integer | 

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

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

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

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

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

try: 
    api_instance.certificateauthority_id_id_delete(id)
except ApiException as e:
    print("Exception when calling CertificateauthorityApi->certificateauthorityIdIdDelete: %s\n" % e)

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

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

public class CertificateauthorityApiExample {

    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");

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

import io.swagger.client.api.CertificateauthorityApi;

public class CertificateauthorityApiExample {

    public static void main(String[] args) {
        CertificateauthorityApi apiInstance = new CertificateauthorityApi();
        Integer id = 56; // Integer | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.certificateauthorityIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateauthorityApi#certificateauthorityIdIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // 
Integer *limit = 56; //  (optional)
Integer *offset = 56; //  (optional)
Boolean *count = true; //  (optional)
String *sort = sort_example; //  (optional)

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

[apiInstance certificateauthorityIdIdGetWith:id
    limit:limit
    offset:offset
    count:count
    sort:sort
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CertificateauthorityApi()

var id = 56; // {Integer} 

var opts = { 
  'limit': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'count': true, // {Boolean} 
  'sort': sort_example // {String} 
};

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

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

namespace Example
{
    public class certificateauthorityIdIdGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CertificateauthorityApi();
            var id = 56;  // Integer | 
            var limit = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var count = true;  // Boolean |  (optional) 
            var sort = sort_example;  // String |  (optional) 

            try
            {
                apiInstance.certificateauthorityIdIdGet(id, limit, offset, count, sort);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CertificateauthorityApi.certificateauthorityIdIdGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\CertificateauthorityApi();
$id = 56; // Integer | 
$limit = 56; // Integer | 
$offset = 56; // Integer | 
$count = true; // Boolean | 
$sort = sort_example; // String | 

try {
    $api_instance->certificateauthorityIdIdGet($id, $limit, $offset, $count, $sort);
} catch (Exception $e) {
    echo 'Exception when calling CertificateauthorityApi->certificateauthorityIdIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

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

eval { 
    $api_instance->certificateauthorityIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CertificateauthorityApi->certificateauthorityIdIdGet: $@\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.CertificateauthorityApi()
id = 56 # Integer | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

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

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

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

public class CertificateauthorityApiExample {

    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");

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

import io.swagger.client.api.CertificateauthorityApi;

public class CertificateauthorityApiExample {

    public static void main(String[] args) {
        CertificateauthorityApi apiInstance = new CertificateauthorityApi();
        Integer id = 56; // Integer | 
        Certificateauthority_update_1 body = ; // Certificateauthority_update_1 | 
        try {
            apiInstance.certificateauthorityIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateauthorityApi#certificateauthorityIdIdPut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // 
Certificateauthority_update_1 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CertificateauthorityApi()

var id = 56; // {Integer} 

var opts = { 
  'body':  // {Certificateauthority_update_1} 
};

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

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

namespace Example
{
    public class certificateauthorityIdIdPutExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CertificateauthorityApi();
            var id = 56;  // Integer | 
            var body = new Certificateauthority_update_1(); // Certificateauthority_update_1 |  (optional) 

            try
            {
                apiInstance.certificateauthorityIdIdPut(id, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CertificateauthorityApi.certificateauthorityIdIdPut: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\CertificateauthorityApi();
$id = 56; // Integer | 
$body = ; // Certificateauthority_update_1 | 

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

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

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

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

eval { 
    $api_instance->certificateauthorityIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CertificateauthorityApi->certificateauthorityIdIdPut: $@\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.CertificateauthorityApi()
id = 56 # Integer | 
body =  # Certificateauthority_update_1 |  (optional)

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

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

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

public class CertificateauthorityApiExample {

    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");

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

import io.swagger.client.api.CertificateauthorityApi;

public class CertificateauthorityApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Certificateauthority_create_0 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CertificateauthorityApi()

var opts = { 
  'body':  // {Certificateauthority_create_0} 
};

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

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

namespace Example
{
    public class certificateauthorityPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CertificateauthorityApi();
            var body = new Certificateauthority_create_0(); // Certificateauthority_create_0 |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\CertificateauthorityApi();
$body = ; // Certificateauthority_create_0 | 

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

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

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

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

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

try: 
    api_instance.certificateauthority_post(body=body)
except ApiException as e:
    print("Exception when calling CertificateauthorityApi->certificateauthorityPost: %s\n" % e)

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

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

public class CertificateauthorityApiExample {

    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");

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

import io.swagger.client.api.CertificateauthorityApi;

public class CertificateauthorityApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CertificateauthorityApi()

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

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

namespace Example
{
    public class certificateauthorityProfilesGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CertificateauthorityApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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

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

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

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

try: 
    api_instance.certificateauthority_profiles_get()
except ApiException as e:
    print("Exception when calling CertificateauthorityApi->certificateauthorityProfilesGet: %s\n" % e)

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

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

public class CloudsyncApiExample {

    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");

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

import io.swagger.client.api.CloudsyncApi;

public class CloudsyncApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CloudsyncApi()

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

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

namespace Example
{
    public class cloudsyncCommonTaskSchemaGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CloudsyncApi();

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

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

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

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

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

try: 
    api_instance.cloudsync_common_task_schema_get()
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncCommonTaskSchemaGet: %s\n" % e)

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

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

public class CloudsyncApiExample {

    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");

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

import io.swagger.client.api.CloudsyncApi;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        CloudsyncApi apiInstance = new CloudsyncApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.cloudsyncGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *limit = 56; //  (optional)
Integer *offset = 56; //  (optional)
Boolean *count = true; //  (optional)
String *sort = sort_example; //  (optional)

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

[apiInstance cloudsyncGetWith:limit
    offset:offset
    count:count
    sort:sort
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CloudsyncApi()

var opts = { 
  'limit': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'count': true, // {Boolean} 
  'sort': sort_example // {String} 
};

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

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

namespace Example
{
    public class cloudsyncGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CloudsyncApi();
            var limit = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var count = true;  // Boolean |  (optional) 
            var sort = sort_example;  // String |  (optional) 

            try
            {
                apiInstance.cloudsyncGet(limit, offset, count, sort);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CloudsyncApi.cloudsyncGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\CloudsyncApi();
$limit = 56; // Integer | 
$offset = 56; // Integer | 
$count = true; // Boolean | 
$sort = sort_example; // String | 

try {
    $api_instance->cloudsyncGet($limit, $offset, $count, $sort);
} catch (Exception $e) {
    echo 'Exception when calling CloudsyncApi->cloudsyncGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

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

eval { 
    $api_instance->cloudsyncGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncGet: $@\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.CloudsyncApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

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

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

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

public class CloudsyncApiExample {

    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");

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

import io.swagger.client.api.CloudsyncApi;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        CloudsyncApi apiInstance = new CloudsyncApi();
        Integer id = 56; // Integer | 
        Cloudsync_abort body = ; // Cloudsync_abort | 
        try {
            apiInstance.cloudsyncIdIdAbortPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncIdIdAbortPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // 
Cloudsync_abort *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CloudsyncApi()

var id = 56; // {Integer} 

var opts = { 
  'body':  // {Cloudsync_abort} 
};

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

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

namespace Example
{
    public class cloudsyncIdIdAbortPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CloudsyncApi();
            var id = 56;  // Integer | 
            var body = new Cloudsync_abort(); // Cloudsync_abort |  (optional) 

            try
            {
                apiInstance.cloudsyncIdIdAbortPost(id, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CloudsyncApi.cloudsyncIdIdAbortPost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\CloudsyncApi();
$id = 56; // Integer | 
$body = ; // Cloudsync_abort | 

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

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

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

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

eval { 
    $api_instance->cloudsyncIdIdAbortPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncIdIdAbortPost: $@\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.CloudsyncApi()
id = 56 # Integer | 
body =  # Cloudsync_abort |  (optional)

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

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

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

public class CloudsyncApiExample {

    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");

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

import io.swagger.client.api.CloudsyncApi;

public class CloudsyncApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // 

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CloudsyncApi()

var id = 56; // {Integer} 


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

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

namespace Example
{
    public class cloudsyncIdIdDeleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CloudsyncApi();
            var id = 56;  // Integer | 

            try
            {
                apiInstance.cloudsyncIdIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CloudsyncApi.cloudsyncIdIdDelete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\CloudsyncApi();
$id = 56; // Integer | 

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

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

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

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

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

try: 
    api_instance.cloudsync_id_id_delete(id)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncIdIdDelete: %s\n" % e)

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

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

public class CloudsyncApiExample {

    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");

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

import io.swagger.client.api.CloudsyncApi;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        CloudsyncApi apiInstance = new CloudsyncApi();
        Integer id = 56; // Integer | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.cloudsyncIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncIdIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // 
Integer *limit = 56; //  (optional)
Integer *offset = 56; //  (optional)
Boolean *count = true; //  (optional)
String *sort = sort_example; //  (optional)

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

[apiInstance cloudsyncIdIdGetWith:id
    limit:limit
    offset:offset
    count:count
    sort:sort
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CloudsyncApi()

var id = 56; // {Integer} 

var opts = { 
  'limit': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'count': true, // {Boolean} 
  'sort': sort_example // {String} 
};

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

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

namespace Example
{
    public class cloudsyncIdIdGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CloudsyncApi();
            var id = 56;  // Integer | 
            var limit = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var count = true;  // Boolean |  (optional) 
            var sort = sort_example;  // String |  (optional) 

            try
            {
                apiInstance.cloudsyncIdIdGet(id, limit, offset, count, sort);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CloudsyncApi.cloudsyncIdIdGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\CloudsyncApi();
$id = 56; // Integer | 
$limit = 56; // Integer | 
$offset = 56; // Integer | 
$count = true; // Boolean | 
$sort = sort_example; // String | 

try {
    $api_instance->cloudsyncIdIdGet($id, $limit, $offset, $count, $sort);
} catch (Exception $e) {
    echo 'Exception when calling CloudsyncApi->cloudsyncIdIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

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

eval { 
    $api_instance->cloudsyncIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncIdIdGet: $@\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.CloudsyncApi()
id = 56 # Integer | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

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

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

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

public class CloudsyncApiExample {

    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");

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

import io.swagger.client.api.CloudsyncApi;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        CloudsyncApi apiInstance = new CloudsyncApi();
        Integer id = 56; // Integer | 
        Cloudsync_update_1 body = ; // Cloudsync_update_1 | 
        try {
            apiInstance.cloudsyncIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncIdIdPut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // 
Cloudsync_update_1 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CloudsyncApi()

var id = 56; // {Integer} 

var opts = { 
  'body':  // {Cloudsync_update_1} 
};

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

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

namespace Example
{
    public class cloudsyncIdIdPutExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CloudsyncApi();
            var id = 56;  // Integer | 
            var body = new Cloudsync_update_1(); // Cloudsync_update_1 |  (optional) 

            try
            {
                apiInstance.cloudsyncIdIdPut(id, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CloudsyncApi.cloudsyncIdIdPut: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\CloudsyncApi();
$id = 56; // Integer | 
$body = ; // Cloudsync_update_1 | 

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

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

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

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

eval { 
    $api_instance->cloudsyncIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncIdIdPut: $@\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.CloudsyncApi()
id = 56 # Integer | 
body =  # Cloudsync_update_1 |  (optional)

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

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

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

public class CloudsyncApiExample {

    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");

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

import io.swagger.client.api.CloudsyncApi;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        CloudsyncApi apiInstance = new CloudsyncApi();
        Integer id = 56; // Integer | 
        Cloudsync_restore_1 body = ; // Cloudsync_restore_1 | 
        try {
            apiInstance.cloudsyncIdIdRestorePost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncIdIdRestorePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // 
Cloudsync_restore_1 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CloudsyncApi()

var id = 56; // {Integer} 

var opts = { 
  'body':  // {Cloudsync_restore_1} 
};

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

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

namespace Example
{
    public class cloudsyncIdIdRestorePostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CloudsyncApi();
            var id = 56;  // Integer | 
            var body = new Cloudsync_restore_1(); // Cloudsync_restore_1 |  (optional) 

            try
            {
                apiInstance.cloudsyncIdIdRestorePost(id, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CloudsyncApi.cloudsyncIdIdRestorePost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\CloudsyncApi();
$id = 56; // Integer | 
$body = ; // Cloudsync_restore_1 | 

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

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

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

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

eval { 
    $api_instance->cloudsyncIdIdRestorePost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncIdIdRestorePost: $@\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.CloudsyncApi()
id = 56 # Integer | 
body =  # Cloudsync_restore_1 |  (optional)

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

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

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

public class CloudsyncApiExample {

    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");

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

import io.swagger.client.api.CloudsyncApi;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        CloudsyncApi apiInstance = new CloudsyncApi();
        Integer id = 56; // Integer | 
        Cloudsync_sync_1 body = ; // Cloudsync_sync_1 | 
        try {
            apiInstance.cloudsyncIdIdSyncPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncIdIdSyncPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // 
Cloudsync_sync_1 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CloudsyncApi()

var id = 56; // {Integer} 

var opts = { 
  'body':  // {Cloudsync_sync_1} 
};

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

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

namespace Example
{
    public class cloudsyncIdIdSyncPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CloudsyncApi();
            var id = 56;  // Integer | 
            var body = new Cloudsync_sync_1(); // Cloudsync_sync_1 |  (optional) 

            try
            {
                apiInstance.cloudsyncIdIdSyncPost(id, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CloudsyncApi.cloudsyncIdIdSyncPost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\CloudsyncApi();
$id = 56; // Integer | 
$body = ; // Cloudsync_sync_1 | 

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

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

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

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

eval { 
    $api_instance->cloudsyncIdIdSyncPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncIdIdSyncPost: $@\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.CloudsyncApi()
id = 56 # Integer | 
body =  # Cloudsync_sync_1 |  (optional)

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

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

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

public class CloudsyncApiExample {

    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");

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

import io.swagger.client.api.CloudsyncApi;

public class CloudsyncApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CloudsyncApi()

var opts = { 
  'body':  // {Integer} 
};

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

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

namespace Example
{
    public class cloudsyncListBucketsPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CloudsyncApi();
            var body = new Integer(); // Integer |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\CloudsyncApi();
$body = ; // Integer | 

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

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

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

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

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

try: 
    api_instance.cloudsync_list_buckets_post(body=body)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncListBucketsPost: %s\n" % e)

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

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

public class CloudsyncApiExample {

    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");

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

import io.swagger.client.api.CloudsyncApi;

public class CloudsyncApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Cloudsync_list_directory_0 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CloudsyncApi()

var opts = { 
  'body':  // {Cloudsync_list_directory_0} 
};

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

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

namespace Example
{
    public class cloudsyncListDirectoryPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CloudsyncApi();
            var body = new Cloudsync_list_directory_0(); // Cloudsync_list_directory_0 |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\CloudsyncApi();
$body = ; // Cloudsync_list_directory_0 | 

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

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

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

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

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

try: 
    api_instance.cloudsync_list_directory_post(body=body)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncListDirectoryPost: %s\n" % e)

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

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

public class CloudsyncApiExample {

    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");

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

import io.swagger.client.api.CloudsyncApi;

public class CloudsyncApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Cloudsync_onedrive_list_drives_0 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CloudsyncApi()

var opts = { 
  'body':  // {Cloudsync_onedrive_list_drives_0} 
};

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

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

namespace Example
{
    public class cloudsyncOnedriveListDrivesPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CloudsyncApi();
            var body = new Cloudsync_onedrive_list_drives_0(); // Cloudsync_onedrive_list_drives_0 |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\CloudsyncApi();
$body = ; // Cloudsync_onedrive_list_drives_0 | 

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

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

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

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

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

try: 
    api_instance.cloudsync_onedrive_list_drives_post(body=body)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncOnedriveListDrivesPost: %s\n" % e)

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

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

public class CloudsyncApiExample {

    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");

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

import io.swagger.client.api.CloudsyncApi;

public class CloudsyncApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Cloudsync_create_0 *body = ; //  (optional)

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

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

var TrueNasResTfulApi = require('true_nas_res_tful_api');
var defaultClient = TrueNasResTfulApi.ApiClient.instance;

// Configure HTTP basic authorization: basic
var basic = defaultClient.authentications['basic'];
basic.username = 'YOUR USERNAME'
basic.password = 'YOUR PASSWORD'

var api = new TrueNasResTfulApi.CloudsyncApi()

var opts = { 
  'body':  // {Cloudsync_create_0} 
};

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

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

namespace Example
{
    public class cloudsyncPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new CloudsyncApi();
            var body = new Cloudsync_create_0(); // Cloudsync_create_0 |  (optional) 

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

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

// Configure HTTP basic authorization: basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\CloudsyncApi();
$body = ; // Cloudsync_create_0 | 

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

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

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

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

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

try: 
    api_instance.cloudsync_post(body=body)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncPost: %s\n" % e)

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

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

public class CloudsyncApiExample {

    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");

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

import io.swagger.client.api.CloudsyncApi;

public class CloudsyncApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

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