FreeNAS RESTful API

AcmeDnsAuthenticator

acmeDnsAuthenticatorAuthenticatorSchemasGet

Get the schemas for all DNS providers we support for ACME DNS Challenge and the respective attributes required for connecting to them while validating a DNS Challenge


/acme/dns/authenticator/authenticator_schemas

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/acme/dns/authenticator/authenticator_schemas"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AcmeDnsAuthenticatorApi;

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

public class AcmeDnsAuthenticatorApiExample {

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

        AcmeDnsAuthenticatorApi apiInstance = new AcmeDnsAuthenticatorApi();
        try {
            apiInstance.acmeDnsAuthenticatorAuthenticatorSchemasGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AcmeDnsAuthenticatorApi#acmeDnsAuthenticatorAuthenticatorSchemasGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AcmeDnsAuthenticatorApi;

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

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

eval { 
    $api_instance->acmeDnsAuthenticatorAuthenticatorSchemasGet();
};
if ($@) {
    warn "Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorAuthenticatorSchemasGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


acmeDnsAuthenticatorGet


/acme/dns/authenticator

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/acme/dns/authenticator?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AcmeDnsAuthenticatorApi;

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

public class AcmeDnsAuthenticatorApiExample {

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

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

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

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

eval { 
    $api_instance->acmeDnsAuthenticatorGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


acmeDnsAuthenticatorIdIdDelete

Delete DNS Authenticator of `id`


/acme/dns/authenticator/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/acme/dns/authenticator/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AcmeDnsAuthenticatorApi;

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

public class AcmeDnsAuthenticatorApiExample {

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

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

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

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

eval { 
    $api_instance->acmeDnsAuthenticatorIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


acmeDnsAuthenticatorIdIdGet


/acme/dns/authenticator/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/acme/dns/authenticator/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AcmeDnsAuthenticatorApi;

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

public class AcmeDnsAuthenticatorApiExample {

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

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

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

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

eval { 
    $api_instance->acmeDnsAuthenticatorIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


acmeDnsAuthenticatorIdIdPut

Update DNS Authenticator of `id`


/acme/dns/authenticator/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/acme/dns/authenticator/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AcmeDnsAuthenticatorApi;

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

public class AcmeDnsAuthenticatorApiExample {

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

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

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

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

eval { 
    $api_instance->acmeDnsAuthenticatorIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


acmeDnsAuthenticatorPost

Create a DNS Authenticator Create a specific DNS Authenticator containing required authentication details for the said provider to successfully connect with it


/acme/dns/authenticator

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/acme/dns/authenticator"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AcmeDnsAuthenticatorApi;

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

public class AcmeDnsAuthenticatorApiExample {

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

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

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

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

eval { 
    $api_instance->acmeDnsAuthenticatorPost(body => $body);
};
if ($@) {
    warn "Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Activedirectory

activedirectoryChangeTrustAccountPwGet

Force an update of the AD machine account password. This can be used to refresh the Kerberos principals in the server's system keytab.


/activedirectory/change_trust_account_pw

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/activedirectory/change_trust_account_pw"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

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

public class ActivedirectoryApiExample {

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

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        try {
            apiInstance.activedirectoryChangeTrustAccountPwGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryChangeTrustAccountPwGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

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

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

eval { 
    $api_instance->activedirectoryChangeTrustAccountPwGet();
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryChangeTrustAccountPwGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


activedirectoryDomainInfoGet

Returns the following information about the currently joined domain: `LDAP server` IP address of current LDAP server to which TrueNAS is connected. `LDAP server name` DNS name of LDAP server to which TrueNAS is connected `Realm` Kerberos realm `LDAP port` `Server time` timestamp. `KDC server` Kerberos KDC to which TrueNAS is connected `Server time offset` current time offset from DC. `Last machine account password change`. timestamp


/activedirectory/domain_info

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/activedirectory/domain_info"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

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

public class ActivedirectoryApiExample {

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

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        try {
            apiInstance.activedirectoryDomainInfoGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryDomainInfoGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

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

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

eval { 
    $api_instance->activedirectoryDomainInfoGet();
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryDomainInfoGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


activedirectoryGet


/activedirectory

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/activedirectory"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

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

public class ActivedirectoryApiExample {

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

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        try {
            apiInstance.activedirectoryGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

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

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

eval { 
    $api_instance->activedirectoryGet();
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


activedirectoryGetSpnListGet

Return list of kerberos SPN entries registered for the server's Active Directory computer account. This may not reflect the state of the server's current kerberos keytab.


/activedirectory/get_spn_list

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/activedirectory/get_spn_list"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

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

public class ActivedirectoryApiExample {

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

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        try {
            apiInstance.activedirectoryGetSpnListGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryGetSpnListGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

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

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

eval { 
    $api_instance->activedirectoryGetSpnListGet();
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryGetSpnListGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


activedirectoryGetStateGet

Wrapper function for 'directoryservices.get_state'. Returns only the state of the Active Directory service.


/activedirectory/get_state

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/activedirectory/get_state"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

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

public class ActivedirectoryApiExample {

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

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        try {
            apiInstance.activedirectoryGetStateGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryGetStateGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

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

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

eval { 
    $api_instance->activedirectoryGetStateGet();
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryGetStateGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


activedirectoryLeavePost

Leave Active Directory domain. This will remove computer object from AD and clear relevant configuration data from the NAS. This requires credentials for appropriately-privileged user. Credentials are used to obtain a kerberos ticket, which is used to perform the actual removal from the domain.


/activedirectory/leave

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/activedirectory/leave"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

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

public class ActivedirectoryApiExample {

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

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

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

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

eval { 
    $api_instance->activedirectoryLeavePost(body => $body);
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryLeavePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


activedirectoryNssInfoChoicesGet

Returns list of available LDAP schema choices.


/activedirectory/nss_info_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/activedirectory/nss_info_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

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

public class ActivedirectoryApiExample {

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

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        try {
            apiInstance.activedirectoryNssInfoChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryNssInfoChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

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

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

eval { 
    $api_instance->activedirectoryNssInfoChoicesGet();
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryNssInfoChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


activedirectoryPut

Update active directory configuration. `domainname` full DNS domain name of the Active Directory domain. `bindname` username used to perform the intial domain join. `bindpw` password used to perform the initial domain join. User- provided credentials are used to obtain a kerberos ticket, which is used to perform the actual domain join. `verbose_logging` increase logging during the domain join process. `use_default_domain` controls whether domain users and groups have the pre-windows 2000 domain name prepended to the user account. When enabled, the user appears as "administrator" rather than "EXAMPLEdministrator" `allow_trusted_doms` enable support for trusted domains. If this parameter is enabled, then separate idmap backends _must_ be configured for each trusted domain, and the idmap cache should be cleared. `allow_dns_updates` during the domain join process, automatically generate DNS entries in the AD domain for the NAS. If this is disabled, then a domain administrator must manually add appropriate DNS entries for the NAS. This parameter is recommended for TrueNAS HA servers. `disable_freenas_cache` disables active caching of AD users and groups. When disabled, only users cached in winbind's internal cache are visible in GUI dropdowns. Disabling active caching is recommended in environments with a large amount of users. `site` AD site of which the NAS is a member. This parameter is auto- detected during the domain join process. If no AD site is configured for the subnet in which the NAS is configured, then this parameter appears as 'Default-First-Site-Name'. Auto-detection is only performed during the initial domain join. `kerberos_realm` in which the server is located. This parameter is automatically populated during the initial domain join. If the NAS has an AD site configured and that site has multiple kerberos servers, then the kerberos realm is automatically updated with a site-specific configuration to use those servers. Auto-detection is only performed during initial domain join. `kerberos_principal` kerberos principal to use for AD-related operations outside of Samba. After intial domain join, this field is updated with the kerberos principal associated with the AD machine account for the NAS. `nss_info` controls how Winbind retrieves Name Service Information to construct a user's home directory and login shell. This parameter is only effective if the Active Directory Domain Controller supports the Microsoft Services for Unix (SFU) LDAP schema. `timeout` timeout value for winbind-related operations. This value may need to be increased in environments with high latencies for communications with domain controllers or a large number of domain controllers. Lowering the value may cause status checks to fail. `dns_timeout` timeout value for DNS queries during the initial domain join. This value is also set as the NETWORK_TIMEOUT in the ldap config file. `createcomputer` Active Directory Organizational Unit in which new computer accounts are created. The OU string is read from top to bottom without RDNs. Slashes ("/") are used as delimiters, like `Computers/Servers/NAS`. The backslash ("\") is used to escape characters but not as a separator. Backslashes are interpreted at multiple levels and might require doubling or even quadrupling to take effect. When this field is blank, new computer accounts are created in the Active Directory default OU. The Active Directory service is started after a configuration update if the service was initially disabled, and the updated configuration sets `enable` to `True`. The Active Directory service is stopped if `enable` is changed to `False`. If the configuration is updated, but the initial `enable` state is `True`, and remains unchanged, then the samba server is only restarted. During the domain join, a kerberos keytab for the newly-created AD machine account is generated. It is used for all future LDAP / AD interaction and the user-provided credentials are removed.


/activedirectory

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/activedirectory"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

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

public class ActivedirectoryApiExample {

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

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

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

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

eval { 
    $api_instance->activedirectoryPut(body => $body);
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


activedirectoryStartedGet

Issue a no-effect command to our DC. This checks if our secure channel connection to our domain controller is still alive. It has much less impact than wbinfo -t. Default winbind request timeout is 60 seconds, and can be adjusted by the smb4.conf parameter 'winbind request timeout ='


/activedirectory/started

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/activedirectory/started"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

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

public class ActivedirectoryApiExample {

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

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        try {
            apiInstance.activedirectoryStartedGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryStartedGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

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

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

eval { 
    $api_instance->activedirectoryStartedGet();
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryStartedGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Afp

afpBindipChoicesGet

List of valid choices for IP addresses to which to bind the AFP service.


/afp/bindip_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/afp/bindip_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AfpApi;

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

public class AfpApiExample {

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

        AfpApi apiInstance = new AfpApi();
        try {
            apiInstance.afpBindipChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AfpApi#afpBindipChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AfpApi;

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

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

eval { 
    $api_instance->afpBindipChoicesGet();
};
if ($@) {
    warn "Exception when calling AfpApi->afpBindipChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


afpGet


/afp

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/afp"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AfpApi;

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

public class AfpApiExample {

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

        AfpApi apiInstance = new AfpApi();
        try {
            apiInstance.afpGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AfpApi#afpGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AfpApi;

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

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

eval { 
    $api_instance->afpGet();
};
if ($@) {
    warn "Exception when calling AfpApi->afpGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


afpPut

Update AFP service settings. `bindip` is a list of IPs to bind AFP to. Leave blank (empty list) to bind to all available IPs. `map_acls` defines how to map the effective permissions of authenticated users. RIGHTS - Unix-style permissions MODE - ACLs NONE - Do not map `chmod_request` defines advanced permission control that deals with ACLs. PRESERVE - Preserve ZFS ACEs for named users and groups or POSIX ACL group mask SIMPLE - Change permission as requested without any extra steps IGNORE - Permission change requests are ignored


/afp

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/afp"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AfpApi;

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

public class AfpApiExample {

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

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

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

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

eval { 
    $api_instance->afpPut(body => $body);
};
if ($@) {
    warn "Exception when calling AfpApi->afpPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Alert

alertDismissPost

Dismiss `id` alert.


/alert/dismiss

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alert/dismiss"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertApi;

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

public class AlertApiExample {

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

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

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

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

eval { 
    $api_instance->alertDismissPost(body => $body);
};
if ($@) {
    warn "Exception when calling AlertApi->alertDismissPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


alertListCategoriesGet

List all types of alerts which the system can issue.


/alert/list_categories

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alert/list_categories"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertApi;

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

public class AlertApiExample {

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

        AlertApi apiInstance = new AlertApi();
        try {
            apiInstance.alertListCategoriesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#alertListCategoriesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertApi;

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

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

eval { 
    $api_instance->alertListCategoriesGet();
};
if ($@) {
    warn "Exception when calling AlertApi->alertListCategoriesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


alertListGet

List all types of alerts including active/dismissed currently in the system.


/alert/list

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alert/list"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertApi;

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

public class AlertApiExample {

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

        AlertApi apiInstance = new AlertApi();
        try {
            apiInstance.alertListGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#alertListGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertApi;

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

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

eval { 
    $api_instance->alertListGet();
};
if ($@) {
    warn "Exception when calling AlertApi->alertListGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


alertListPoliciesGet

List all alert policies which indicate the frequency of the alerts.


/alert/list_policies

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alert/list_policies"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertApi;

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

public class AlertApiExample {

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

        AlertApi apiInstance = new AlertApi();
        try {
            apiInstance.alertListPoliciesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#alertListPoliciesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertApi;

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

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

eval { 
    $api_instance->alertListPoliciesGet();
};
if ($@) {
    warn "Exception when calling AlertApi->alertListPoliciesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


alertRestorePost

Restore `id` alert which had been dismissed.


/alert/restore

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alert/restore"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertApi;

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

public class AlertApiExample {

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

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

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

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

eval { 
    $api_instance->alertRestorePost(body => $body);
};
if ($@) {
    warn "Exception when calling AlertApi->alertRestorePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Alertclasses

alertclassesGet


/alertclasses

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alertclasses"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertclassesApi;

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

public class AlertclassesApiExample {

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

        AlertclassesApi apiInstance = new AlertclassesApi();
        try {
            apiInstance.alertclassesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertclassesApi#alertclassesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertclassesApi;

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

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

eval { 
    $api_instance->alertclassesGet();
};
if ($@) {
    warn "Exception when calling AlertclassesApi->alertclassesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


alertclassesPut

Update default Alert settings.


/alertclasses

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alertclasses"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertclassesApi;

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

public class AlertclassesApiExample {

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

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

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

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

eval { 
    $api_instance->alertclassesPut(body => $body);
};
if ($@) {
    warn "Exception when calling AlertclassesApi->alertclassesPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Alertservice

alertserviceGet


/alertservice

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alertservice?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertserviceApi;

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

public class AlertserviceApiExample {

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

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

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

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

eval { 
    $api_instance->alertserviceGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertserviceGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


alertserviceIdIdDelete

Delete Alert Service of `id`.


/alertservice/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alertservice/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertserviceApi;

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

public class AlertserviceApiExample {

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

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

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

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

eval { 
    $api_instance->alertserviceIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertserviceIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


alertserviceIdIdGet


/alertservice/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alertservice/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertserviceApi;

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

public class AlertserviceApiExample {

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

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

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

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

eval { 
    $api_instance->alertserviceIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertserviceIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


alertserviceIdIdPut

Update Alert Service of `id`.


/alertservice/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alertservice/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertserviceApi;

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

public class AlertserviceApiExample {

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

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

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

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

eval { 
    $api_instance->alertserviceIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertserviceIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


alertserviceListTypesGet

List all types of supported Alert services which can be configured with the system.


/alertservice/list_types

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alertservice/list_types"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertserviceApi;

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

public class AlertserviceApiExample {

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

        AlertserviceApi apiInstance = new AlertserviceApi();
        try {
            apiInstance.alertserviceListTypesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertserviceApi#alertserviceListTypesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertserviceApi;

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

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

eval { 
    $api_instance->alertserviceListTypesGet();
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertserviceListTypesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


alertservicePost

Create an Alert Service of specified `type`. If `enabled`, it sends alerts to the configured `type` of Alert Service.


/alertservice

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alertservice"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertserviceApi;

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

public class AlertserviceApiExample {

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

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

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

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

eval { 
    $api_instance->alertservicePost(body => $body);
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertservicePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


alertserviceTestPost

Send a test alert using `type` of Alert Service.


/alertservice/test

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/alertservice/test"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertserviceApi;

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

public class AlertserviceApiExample {

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

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

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

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

eval { 
    $api_instance->alertserviceTestPost(body => $body);
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertserviceTestPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


ApiKey

apiKeyGet


/api_key

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/api_key?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiKeyApi;

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

public class ApiKeyApiExample {

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

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

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

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

eval { 
    $api_instance->apiKeyGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling ApiKeyApi->apiKeyGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


apiKeyIdIdDelete

Delete API Key `id`.


/api_key/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/api_key/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiKeyApi;

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

public class ApiKeyApiExample {

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

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

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

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

eval { 
    $api_instance->apiKeyIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling ApiKeyApi->apiKeyIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Path parameters
Name Description
id*
Integer
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


apiKeyIdIdGet


/api_key/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/api_key/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiKeyApi;

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

public class ApiKeyApiExample {

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

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

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

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

eval { 
    $api_instance->apiKeyIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling ApiKeyApi->apiKeyIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


apiKeyIdIdPut

Update API Key `id`. Specify `reset: true` to reset this API Key.


/api_key/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/api_key/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiKeyApi;

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

public class ApiKeyApiExample {

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

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

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

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

eval { 
    $api_instance->apiKeyIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling ApiKeyApi->apiKeyIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


apiKeyPost

Creates API Key. `name` is a user-readable name for key.


/api_key

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/api_key"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiKeyApi;

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

public class ApiKeyApiExample {

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

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

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

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

eval { 
    $api_instance->apiKeyPost(body => $body);
};
if ($@) {
    warn "Exception when calling ApiKeyApi->apiKeyPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Auth

authCheckUserPost

Verify username and password


/auth/check_user

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/auth/check_user"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthApi;

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

public class AuthApiExample {

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

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

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

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

eval { 
    $api_instance->authCheckUserPost(body => $body);
};
if ($@) {
    warn "Exception when calling AuthApi->authCheckUserPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


authGenerateTokenPost

Generate a token to be used for authentication. `ttl` stands for Time To Live, in seconds. The token will be invalidated if the connection has been inactive for a time greater than this. `attrs` is a general purpose object/dictionary to hold information about the token.


/auth/generate_token

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/auth/generate_token"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthApi;

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

public class AuthApiExample {

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

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

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

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

eval { 
    $api_instance->authGenerateTokenPost(body => $body);
};
if ($@) {
    warn "Exception when calling AuthApi->authGenerateTokenPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


authSessionsGet

Returns list of active auth sessions. Example of return value: [ { "id": "NyhB1J5vjPjIV82yZ6caU12HLA1boDJcZNWuVQM4hQWuiyUWMGZTz2ElDp7Yk87d", "origin": "192.168.0.3:40392", "credentials": "TOKEN", "internal": False, "created_at": {"$date": 1545842426070} } ] `credentials` can be `UNIX_SOCKET`, `ROOT_TCP_SOCKET`, `TRUENAS_NODE`, `LOGIN_PASSWORD` or `TOKEN`, depending on what authentication method was used. If you want to exclude all internal connections from the list, call this method with following arguments: [ [ ["internal", "=", True] ] ]


/auth/sessions

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/auth/sessions?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthApi;

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

public class AuthApiExample {

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

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

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

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

eval { 
    $api_instance->authSessionsGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling AuthApi->authSessionsGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


authTwoFactorAuthGet

Returns true if two factor authorization is required for authorizing user's login.


/auth/two_factor_auth

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/auth/two_factor_auth"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthApi;

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

public class AuthApiExample {

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

        AuthApi apiInstance = new AuthApi();
        try {
            apiInstance.authTwoFactorAuthGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authTwoFactorAuthGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthApi;

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

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

eval { 
    $api_instance->authTwoFactorAuthGet();
};
if ($@) {
    warn "Exception when calling AuthApi->authTwoFactorAuthGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


AuthTwofactor

authTwofactorGet


/auth/twofactor

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/auth/twofactor"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthTwofactorApi;

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

public class AuthTwofactorApiExample {

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

        AuthTwofactorApi apiInstance = new AuthTwofactorApi();
        try {
            apiInstance.authTwofactorGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthTwofactorApi#authTwofactorGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthTwofactorApi;

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

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

eval { 
    $api_instance->authTwofactorGet();
};
if ($@) {
    warn "Exception when calling AuthTwofactorApi->authTwofactorGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


authTwofactorProvisioningUriGet

Returns the provisioning URI for the OTP. This can then be encoded in a QR Code and used to provision an OTP app like Google Authenticator.


/auth/twofactor/provisioning_uri

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/auth/twofactor/provisioning_uri"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthTwofactorApi;

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

public class AuthTwofactorApiExample {

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

        AuthTwofactorApi apiInstance = new AuthTwofactorApi();
        try {
            apiInstance.authTwofactorProvisioningUriGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthTwofactorApi#authTwofactorProvisioningUriGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthTwofactorApi;

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

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

eval { 
    $api_instance->authTwofactorProvisioningUriGet();
};
if ($@) {
    warn "Exception when calling AuthTwofactorApi->authTwofactorProvisioningUriGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


authTwofactorPut

`otp_digits` represents number of allowed digits in the OTP. `window` extends the validity to `window` many counter ticks before and after the current one. `interval` is time duration in seconds specifying OTP expiration time from it's creation time.


/auth/twofactor

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/auth/twofactor"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthTwofactorApi;

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

public class AuthTwofactorApiExample {

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

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

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

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

eval { 
    $api_instance->authTwofactorPut(body => $body);
};
if ($@) {
    warn "Exception when calling AuthTwofactorApi->authTwofactorPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


authTwofactorRenewSecretGet

Generates a new secret for Two Factor Authentication. Returns boolean true on success.


/auth/twofactor/renew_secret

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/auth/twofactor/renew_secret"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthTwofactorApi;

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

public class AuthTwofactorApiExample {

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

        AuthTwofactorApi apiInstance = new AuthTwofactorApi();
        try {
            apiInstance.authTwofactorRenewSecretGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthTwofactorApi#authTwofactorRenewSecretGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthTwofactorApi;

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

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

eval { 
    $api_instance->authTwofactorRenewSecretGet();
};
if ($@) {
    warn "Exception when calling AuthTwofactorApi->authTwofactorRenewSecretGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


authTwofactorVerifyPost

Returns boolean true if provided `token` is successfully authenticated.


/auth/twofactor/verify

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/auth/twofactor/verify"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthTwofactorApi;

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

public class AuthTwofactorApiExample {

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

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

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

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

eval { 
    $api_instance->authTwofactorVerifyPost(body => $body);
};
if ($@) {
    warn "Exception when calling AuthTwofactorApi->authTwofactorVerifyPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Boot

bootAttachPost

Attach a disk to the boot pool, turning a stripe into a mirror. `expand` option will determine whether the new disk partition will be the maximum available or the same size as the current disk.


/boot/attach

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/boot/attach"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootApi;

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

public class BootApiExample {

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

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

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

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

eval { 
    $api_instance->bootAttachPost(body => $body);
};
if ($@) {
    warn "Exception when calling BootApi->bootAttachPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootDetachPost

Detach given `dev` from boot pool.


/boot/detach

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/boot/detach"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootApi;

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

public class BootApiExample {

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

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

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

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

eval { 
    $api_instance->bootDetachPost(body => $body);
};
if ($@) {
    warn "Exception when calling BootApi->bootDetachPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootGetDisksGet

Returns disks of the boot pool.


/boot/get_disks

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/boot/get_disks"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootApi;

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

public class BootApiExample {

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

        BootApi apiInstance = new BootApi();
        try {
            apiInstance.bootGetDisksGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling BootApi#bootGetDisksGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootApi;

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

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

eval { 
    $api_instance->bootGetDisksGet();
};
if ($@) {
    warn "Exception when calling BootApi->bootGetDisksGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootGetScrubIntervalGet

Get Automatic Scrub Interval value in days.


/boot/get_scrub_interval

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/boot/get_scrub_interval"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootApi;

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

public class BootApiExample {

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

        BootApi apiInstance = new BootApi();
        try {
            apiInstance.bootGetScrubIntervalGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling BootApi#bootGetScrubIntervalGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootApi;

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

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

eval { 
    $api_instance->bootGetScrubIntervalGet();
};
if ($@) {
    warn "Exception when calling BootApi->bootGetScrubIntervalGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootGetStateGet

Returns the current state of the boot pool, including all vdevs, properties and datasets.


/boot/get_state

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/boot/get_state"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootApi;

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

public class BootApiExample {

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

        BootApi apiInstance = new BootApi();
        try {
            apiInstance.bootGetStateGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling BootApi#bootGetStateGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootApi;

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

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

eval { 
    $api_instance->bootGetStateGet();
};
if ($@) {
    warn "Exception when calling BootApi->bootGetStateGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootReplacePost

Replace device `label` on boot pool with `dev`.


/boot/replace

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/boot/replace"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootApi;

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

public class BootApiExample {

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

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

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

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

eval { 
    $api_instance->bootReplacePost(body => $body);
};
if ($@) {
    warn "Exception when calling BootApi->bootReplacePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootScrubGet

Scrub on boot pool.


/boot/scrub

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/boot/scrub"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootApi;

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

public class BootApiExample {

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

        BootApi apiInstance = new BootApi();
        try {
            apiInstance.bootScrubGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling BootApi#bootScrubGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootApi;

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

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

eval { 
    $api_instance->bootScrubGet();
};
if ($@) {
    warn "Exception when calling BootApi->bootScrubGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootSetScrubIntervalPost

Set Automatic Scrub Interval value in days.


/boot/set_scrub_interval

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/boot/set_scrub_interval"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootApi;

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

public class BootApiExample {

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

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

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

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

eval { 
    $api_instance->bootSetScrubIntervalPost(body => $body);
};
if ($@) {
    warn "Exception when calling BootApi->bootSetScrubIntervalPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Bootenv

bootenvGet

Query all Boot Environments with `query-filters` and `query-options`.


/bootenv

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/bootenv?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootenvApi;

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

public class BootenvApiExample {

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

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

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

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

eval { 
    $api_instance->bootenvGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootenvIdIdActivatePost

Activates boot environment `id`.


/bootenv/id/{id}/activate

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/bootenv/id/{id}/activate"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootenvApi;

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

public class BootenvApiExample {

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

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

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

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

eval { 
    $api_instance->bootenvIdIdActivatePost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvIdIdActivatePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootenvIdIdDelete

Delete `id` boot environment. This removes the clone from the system.


/bootenv/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/bootenv/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootenvApi;

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

public class BootenvApiExample {

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

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

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

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

eval { 
    $api_instance->bootenvIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootenvIdIdGet

Query all Boot Environments with `query-filters` and `query-options`.


/bootenv/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/bootenv/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootenvApi;

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

public class BootenvApiExample {

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

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

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

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

eval { 
    $api_instance->bootenvIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvIdIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Path parameters
Name Description
id*
array[null]
Required
Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootenvIdIdPut

Update `id` boot environment name with a new provided valid `name`.


/bootenv/id/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/bootenv/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootenvApi;

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

public class BootenvApiExample {

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

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

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

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

eval { 
    $api_instance->bootenvIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvIdIdPut: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootenvIdIdSetAttributePost

Sets attributes boot environment `id`. Currently only `keep` attribute is allowed.


/bootenv/id/{id}/set_attribute

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/bootenv/id/{id}/set_attribute"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootenvApi;

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

public class BootenvApiExample {

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

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

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

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

eval { 
    $api_instance->bootenvIdIdSetAttributePost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvIdIdSetAttributePost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


bootenvPost

Create a new boot environment using `name`. If a new boot environment is desired which is a clone of another boot environment, `source` can be passed. Then, a new boot environment of `name` is created using boot environment `source` by cloning it. Ensure that `name` and `source` are valid boot environment names.


/bootenv

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/bootenv"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootenvApi;

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

public class BootenvApiExample {

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

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

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

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

eval { 
    $api_instance->bootenvPost(body => $body);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


Certificate

certificateAcmeServerChoicesGet

Dictionary of popular ACME Servers with their directory URI endpoints which we display automatically in UI


/certificate/acme_server_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificate/acme_server_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

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

public class CertificateApiExample {

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

        CertificateApi apiInstance = new CertificateApi();
        try {
            apiInstance.certificateAcmeServerChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateAcmeServerChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

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

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

eval { 
    $api_instance->certificateAcmeServerChoicesGet();
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateAcmeServerChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


certificateCountryChoicesGet

Returns country choices for creating a certificate/csr.


/certificate/country_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificate/country_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

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

public class CertificateApiExample {

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

        CertificateApi apiInstance = new CertificateApi();
        try {
            apiInstance.certificateCountryChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateCountryChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

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

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

eval { 
    $api_instance->certificateCountryChoicesGet();
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateCountryChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


certificateEcCurveChoicesGet

Dictionary of supported EC curves.


/certificate/ec_curve_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificate/ec_curve_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

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

public class CertificateApiExample {

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

        CertificateApi apiInstance = new CertificateApi();
        try {
            apiInstance.certificateEcCurveChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateEcCurveChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

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

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

eval { 
    $api_instance->certificateEcCurveChoicesGet();
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateEcCurveChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


certificateExtendedKeyUsageChoicesGet

Dictionary of choices for `ExtendedKeyUsage` extension which can be passed over to `usages` attribute.


/certificate/extended_key_usage_choices

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificate/extended_key_usage_choices"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

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

public class CertificateApiExample {

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

        CertificateApi apiInstance = new CertificateApi();
        try {
            apiInstance.certificateExtendedKeyUsageChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateExtendedKeyUsageChoicesGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

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

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

eval { 
    $api_instance->certificateExtendedKeyUsageChoicesGet();
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateExtendedKeyUsageChoicesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


certificateGet


/certificate

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificate?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

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

public class CertificateApiExample {

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

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

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

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

eval { 
    $api_instance->certificateGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
count
Boolean
sort
String

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


certificateIdIdDelete

Delete certificate of `id`. If the certificate is an ACME based certificate, certificate service will try to revoke the certificate by updating it's status with the ACME server, if it fails an exception is raised and the certificate is not deleted from the system. However, if `force` is set to True, certificate is deleted from the system even if some error occurred while revoking the certificate with the ACME Server


/certificate/id/{id}

Usage and SDK Samples

curl -X DELETE -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificate/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

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

public class CertificateApiExample {

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

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

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

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

eval { 
    $api_instance->certificateIdIdDelete(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateIdIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

Parameters

Path parameters
Name Description
id*
Integer
Required
Body parameters
Name Description
body

Responses

Status: 200 - Operation succeeded

Status: 401 - No authorization for this endpoint


certificateIdIdGet


/certificate/id/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "http://192.168.1.123/api/v2.0/certificate/id/{id}?limit=&offset=&count=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

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

public class CertificateApiExample {

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

        CertificateApi apiInstance = new CertificateApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.certificateIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateIdIdGet");
            e.printStackTrace();
        }
    }
}
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

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

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

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