nevisIDM REST API documentation

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

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

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

        // Create an instance of the API class
        ApplicationRESTServiceApi apiInstance = new ApplicationRESTServiceApi();
         UNKNOWN_PARAMETER_NAME = 1001; //  | ExtID of the application
        String continuationToken = continuationToken_example; // String | 
        Integer limit = 56; // Integer | 

        try {
            ItemsWrapperForApplicationGetDTO result = apiInstance.getAllApplications(UNKNOWN_PARAMETER_NAME, continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationRESTServiceApi#getAllApplications");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final  UNKNOWN_PARAMETER_NAME = new (); //  | ExtID of the application
final String continuationToken = new String(); // String | 
final Integer limit = new Integer(); // Integer | 

try {
    final result = await api_instance.getAllApplications(UNKNOWN_PARAMETER_NAME, continuationToken, limit);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getAllApplications: $e\n');
}

import org.openapitools.client.api.ApplicationRESTServiceApi;

public class ApplicationRESTServiceApiExample {
    public static void main(String[] args) {
        ApplicationRESTServiceApi apiInstance = new ApplicationRESTServiceApi();
         UNKNOWN_PARAMETER_NAME = 1001; //  | ExtID of the application
        String continuationToken = continuationToken_example; // String | 
        Integer limit = 56; // Integer | 

        try {
            ItemsWrapperForApplicationGetDTO result = apiInstance.getAllApplications(UNKNOWN_PARAMETER_NAME, continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationRESTServiceApi#getAllApplications");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ApplicationRESTServiceApi *apiInstance = [[ApplicationRESTServiceApi alloc] init];
 *UNKNOWN_PARAMETER_NAME = 1001; // ExtID of the application
String *continuationToken = continuationToken_example; //  (optional) (default to )
Integer *limit = 56; //  (optional) (default to 0)

// Get application
[apiInstance getAllApplicationsWith:UNKNOWN_PARAMETER_NAME
    continuationToken:continuationToken
    limit:limit
              completionHandler: ^(ItemsWrapperForApplicationGetDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.ApplicationRESTServiceApi()
var UNKNOWN_PARAMETER_NAME = 1001; // {} ExtID of the application
var opts = {
  'continuationToken': continuationToken_example, // {String} 
  'limit': 56 // {Integer} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ApplicationRESTServiceApi();
            var UNKNOWN_PARAMETER_NAME = new (); //  | ExtID of the application
            var continuationToken = continuationToken_example;  // String |  (optional)  (default to )
            var limit = 56;  // Integer |  (optional)  (default to 0)

            try {
                // Get application
                ItemsWrapperForApplicationGetDTO result = apiInstance.getAllApplications(UNKNOWN_PARAMETER_NAME, continuationToken, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApplicationRESTServiceApi.getAllApplications: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ApplicationRESTServiceApi();
$UNKNOWN_PARAMETER_NAME = 1001; //  | ExtID of the application
$continuationToken = continuationToken_example; // String | 
$limit = 56; // Integer | 

try {
    $result = $api_instance->getAllApplications($UNKNOWN_PARAMETER_NAME, $continuationToken, $limit);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApplicationRESTServiceApi->getAllApplications: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ApplicationRESTServiceApi->new();
my $UNKNOWN_PARAMETER_NAME = 1001; #  | ExtID of the application
my $continuationToken = continuationToken_example; # String | 
my $limit = 56; # Integer | 

eval {
    my $result = $api_instance->getAllApplications(UNKNOWN_PARAMETER_NAME => $UNKNOWN_PARAMETER_NAME, continuationToken => $continuationToken, limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApplicationRESTServiceApi->getAllApplications: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.ApplicationRESTServiceApi()
UNKNOWN_PARAMETER_NAME = 1001 #  | ExtID of the application
continuationToken = continuationToken_example # String |  (optional) (default to )
limit = 56 # Integer |  (optional) (default to 0)

try:
    # Get application
    api_response = api_instance.get_all_applications(UNKNOWN_PARAMETER_NAME, continuationToken=continuationToken, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApplicationRESTServiceApi->getAllApplications: %s\n" % e)

extern crate ApplicationRESTServiceApi;

pub fn main() {
    let UNKNOWN_PARAMETER_NAME = 1001; // 
    let continuationToken = continuationToken_example; // String
    let limit = 56; // Integer

    let mut context = ApplicationRESTServiceApi::Context::default();
    let result = client.getAllApplications(UNKNOWN_PARAMETER_NAME, continuationToken, limit, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ApplicationRESTServiceApi apiInstance = new ApplicationRESTServiceApi();
        String extId = 1001; // String | ExtID of the application

        try {
            ApplicationGetDTO result = apiInstance.getApplication(extId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationRESTServiceApi#getApplication");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String extId = new String(); // String | ExtID of the application

try {
    final result = await api_instance.getApplication(extId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getApplication: $e\n');
}

import org.openapitools.client.api.ApplicationRESTServiceApi;

public class ApplicationRESTServiceApiExample {
    public static void main(String[] args) {
        ApplicationRESTServiceApi apiInstance = new ApplicationRESTServiceApi();
        String extId = 1001; // String | ExtID of the application

        try {
            ApplicationGetDTO result = apiInstance.getApplication(extId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationRESTServiceApi#getApplication");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ApplicationRESTServiceApi *apiInstance = [[ApplicationRESTServiceApi alloc] init];
String *extId = 1001; // ExtID of the application (default to null)

// Get application
[apiInstance getApplicationWith:extId
              completionHandler: ^(ApplicationGetDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.ApplicationRESTServiceApi()
var extId = 1001; // {String} ExtID of the application

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

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

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

            // Create an instance of the API class
            var apiInstance = new ApplicationRESTServiceApi();
            var extId = 1001;  // String | ExtID of the application (default to null)

            try {
                // Get application
                ApplicationGetDTO result = apiInstance.getApplication(extId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApplicationRESTServiceApi.getApplication: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ApplicationRESTServiceApi();
$extId = 1001; // String | ExtID of the application

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ApplicationRESTServiceApi->new();
my $extId = 1001; # String | ExtID of the application

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

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

# Create an instance of the API class
api_instance = openapi_client.ApplicationRESTServiceApi()
extId = 1001 # String | ExtID of the application (default to null)

try:
    # Get application
    api_response = api_instance.get_application(extId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApplicationRESTServiceApi->getApplication: %s\n" % e)

extern crate ApplicationRESTServiceApi;

pub fn main() {
    let extId = 1001; // String

    let mut context = ApplicationRESTServiceApi::Context::default();
    let result = client.getApplication(extId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ApplicationRESTServiceApi apiInstance = new ApplicationRESTServiceApi();
        String extId = 1001; // String | ExtID of the application

        try {
            map['String', 'String'] result = apiInstance.getProperties3(extId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationRESTServiceApi#getProperties3");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String extId = new String(); // String | ExtID of the application

try {
    final result = await api_instance.getProperties3(extId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getProperties3: $e\n');
}

import org.openapitools.client.api.ApplicationRESTServiceApi;

public class ApplicationRESTServiceApiExample {
    public static void main(String[] args) {
        ApplicationRESTServiceApi apiInstance = new ApplicationRESTServiceApi();
        String extId = 1001; // String | ExtID of the application

        try {
            map['String', 'String'] result = apiInstance.getProperties3(extId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationRESTServiceApi#getProperties3");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ApplicationRESTServiceApi *apiInstance = [[ApplicationRESTServiceApi alloc] init];
String *extId = 1001; // ExtID of the application (default to null)

// Get properties
[apiInstance getProperties3With:extId
              completionHandler: ^(map['String', 'String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.ApplicationRESTServiceApi()
var extId = 1001; // {String} ExtID of the application

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

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

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

            // Create an instance of the API class
            var apiInstance = new ApplicationRESTServiceApi();
            var extId = 1001;  // String | ExtID of the application (default to null)

            try {
                // Get properties
                map['String', 'String'] result = apiInstance.getProperties3(extId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApplicationRESTServiceApi.getProperties3: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ApplicationRESTServiceApi();
$extId = 1001; // String | ExtID of the application

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ApplicationRESTServiceApi->new();
my $extId = 1001; # String | ExtID of the application

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

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

# Create an instance of the API class
api_instance = openapi_client.ApplicationRESTServiceApi()
extId = 1001 # String | ExtID of the application (default to null)

try:
    # Get properties
    api_response = api_instance.get_properties3(extId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApplicationRESTServiceApi->getProperties3: %s\n" % e)

extern crate ApplicationRESTServiceApi;

pub fn main() {
    let extId = 1001; // String

    let mut context = ApplicationRESTServiceApi::Context::default();
    let result = client.getProperties3(extId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ApplicationRESTServiceApi apiInstance = new ApplicationRESTServiceApi();
        String extId = 1001; // String | ExtID of the application
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 100; // Integer | Pagination limit

        try {
            ItemsWrapperForRoleGetDTO result = apiInstance.getRoles(extId, continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationRESTServiceApi#getRoles");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String extId = new String(); // String | ExtID of the application
final String continuationToken = new String(); // String | Pagination continuation token
final Integer limit = new Integer(); // Integer | Pagination limit

try {
    final result = await api_instance.getRoles(extId, continuationToken, limit);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getRoles: $e\n');
}

import org.openapitools.client.api.ApplicationRESTServiceApi;

public class ApplicationRESTServiceApiExample {
    public static void main(String[] args) {
        ApplicationRESTServiceApi apiInstance = new ApplicationRESTServiceApi();
        String extId = 1001; // String | ExtID of the application
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 100; // Integer | Pagination limit

        try {
            ItemsWrapperForRoleGetDTO result = apiInstance.getRoles(extId, continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApplicationRESTServiceApi#getRoles");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ApplicationRESTServiceApi *apiInstance = [[ApplicationRESTServiceApi alloc] init];
String *extId = 1001; // ExtID of the application (default to null)
String *continuationToken = continuationToken_example; // Pagination continuation token (optional) (default to )
Integer *limit = 100; // Pagination limit (optional) (default to 0)

// Get application roles
[apiInstance getRolesWith:extId
    continuationToken:continuationToken
    limit:limit
              completionHandler: ^(ItemsWrapperForRoleGetDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.ApplicationRESTServiceApi()
var extId = 1001; // {String} ExtID of the application
var opts = {
  'continuationToken': continuationToken_example, // {String} Pagination continuation token
  'limit': 100 // {Integer} Pagination limit
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ApplicationRESTServiceApi();
            var extId = 1001;  // String | ExtID of the application (default to null)
            var continuationToken = continuationToken_example;  // String | Pagination continuation token (optional)  (default to )
            var limit = 100;  // Integer | Pagination limit (optional)  (default to 0)

            try {
                // Get application roles
                ItemsWrapperForRoleGetDTO result = apiInstance.getRoles(extId, continuationToken, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApplicationRESTServiceApi.getRoles: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ApplicationRESTServiceApi();
$extId = 1001; // String | ExtID of the application
$continuationToken = continuationToken_example; // String | Pagination continuation token
$limit = 100; // Integer | Pagination limit

try {
    $result = $api_instance->getRoles($extId, $continuationToken, $limit);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApplicationRESTServiceApi->getRoles: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ApplicationRESTServiceApi->new();
my $extId = 1001; # String | ExtID of the application
my $continuationToken = continuationToken_example; # String | Pagination continuation token
my $limit = 100; # Integer | Pagination limit

eval {
    my $result = $api_instance->getRoles(extId => $extId, continuationToken => $continuationToken, limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApplicationRESTServiceApi->getRoles: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.ApplicationRESTServiceApi()
extId = 1001 # String | ExtID of the application (default to null)
continuationToken = continuationToken_example # String | Pagination continuation token (optional) (default to )
limit = 100 # Integer | Pagination limit (optional) (default to 0)

try:
    # Get application roles
    api_response = api_instance.get_roles(extId, continuationToken=continuationToken, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApplicationRESTServiceApi->getRoles: %s\n" % e)

extern crate ApplicationRESTServiceApi;

pub fn main() {
    let extId = 1001; // String
    let continuationToken = continuationToken_example; // String
    let limit = 100; // Integer

    let mut context = ApplicationRESTServiceApi::Context::default();
    let result = client.getRoles(extId, continuationToken, limit, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AuthorizationsRESTServiceApi apiInstance = new AuthorizationsRESTServiceApi();
        String clientExtId = clientExtId_example; // String | External ID of the client
        String profileExtId = profileExtId_example; // String | External ID of the profile
        String continuationToken = continuationToken_example; // String | Continuation token for pagination
        Integer limit = 56; // Integer | Limit for pagination

        try {
            ItemsWrapperForAuthorizationGetDTO result = apiInstance.getAllAuthorizationsOfProfile(clientExtId, profileExtId, continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthorizationsRESTServiceApi#getAllAuthorizationsOfProfile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String clientExtId = new String(); // String | External ID of the client
final String profileExtId = new String(); // String | External ID of the profile
final String continuationToken = new String(); // String | Continuation token for pagination
final Integer limit = new Integer(); // Integer | Limit for pagination

try {
    final result = await api_instance.getAllAuthorizationsOfProfile(clientExtId, profileExtId, continuationToken, limit);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getAllAuthorizationsOfProfile: $e\n');
}

import org.openapitools.client.api.AuthorizationsRESTServiceApi;

public class AuthorizationsRESTServiceApiExample {
    public static void main(String[] args) {
        AuthorizationsRESTServiceApi apiInstance = new AuthorizationsRESTServiceApi();
        String clientExtId = clientExtId_example; // String | External ID of the client
        String profileExtId = profileExtId_example; // String | External ID of the profile
        String continuationToken = continuationToken_example; // String | Continuation token for pagination
        Integer limit = 56; // Integer | Limit for pagination

        try {
            ItemsWrapperForAuthorizationGetDTO result = apiInstance.getAllAuthorizationsOfProfile(clientExtId, profileExtId, continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthorizationsRESTServiceApi#getAllAuthorizationsOfProfile");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AuthorizationsRESTServiceApi *apiInstance = [[AuthorizationsRESTServiceApi alloc] init];
String *clientExtId = clientExtId_example; // External ID of the client (default to null)
String *profileExtId = profileExtId_example; // External ID of the profile (default to null)
String *continuationToken = continuationToken_example; // Continuation token for pagination (optional) (default to )
Integer *limit = 56; // Limit for pagination (optional) (default to 0)

// Get all authorizations of a profile
[apiInstance getAllAuthorizationsOfProfileWith:clientExtId
    profileExtId:profileExtId
    continuationToken:continuationToken
    limit:limit
              completionHandler: ^(ItemsWrapperForAuthorizationGetDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.AuthorizationsRESTServiceApi()
var clientExtId = clientExtId_example; // {String} External ID of the client
var profileExtId = profileExtId_example; // {String} External ID of the profile
var opts = {
  'continuationToken': continuationToken_example, // {String} Continuation token for pagination
  'limit': 56 // {Integer} Limit for pagination
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new AuthorizationsRESTServiceApi();
            var clientExtId = clientExtId_example;  // String | External ID of the client (default to null)
            var profileExtId = profileExtId_example;  // String | External ID of the profile (default to null)
            var continuationToken = continuationToken_example;  // String | Continuation token for pagination (optional)  (default to )
            var limit = 56;  // Integer | Limit for pagination (optional)  (default to 0)

            try {
                // Get all authorizations of a profile
                ItemsWrapperForAuthorizationGetDTO result = apiInstance.getAllAuthorizationsOfProfile(clientExtId, profileExtId, continuationToken, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthorizationsRESTServiceApi.getAllAuthorizationsOfProfile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthorizationsRESTServiceApi();
$clientExtId = clientExtId_example; // String | External ID of the client
$profileExtId = profileExtId_example; // String | External ID of the profile
$continuationToken = continuationToken_example; // String | Continuation token for pagination
$limit = 56; // Integer | Limit for pagination

try {
    $result = $api_instance->getAllAuthorizationsOfProfile($clientExtId, $profileExtId, $continuationToken, $limit);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthorizationsRESTServiceApi->getAllAuthorizationsOfProfile: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthorizationsRESTServiceApi->new();
my $clientExtId = clientExtId_example; # String | External ID of the client
my $profileExtId = profileExtId_example; # String | External ID of the profile
my $continuationToken = continuationToken_example; # String | Continuation token for pagination
my $limit = 56; # Integer | Limit for pagination

eval {
    my $result = $api_instance->getAllAuthorizationsOfProfile(clientExtId => $clientExtId, profileExtId => $profileExtId, continuationToken => $continuationToken, limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthorizationsRESTServiceApi->getAllAuthorizationsOfProfile: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.AuthorizationsRESTServiceApi()
clientExtId = clientExtId_example # String | External ID of the client (default to null)
profileExtId = profileExtId_example # String | External ID of the profile (default to null)
continuationToken = continuationToken_example # String | Continuation token for pagination (optional) (default to )
limit = 56 # Integer | Limit for pagination (optional) (default to 0)

try:
    # Get all authorizations of a profile
    api_response = api_instance.get_all_authorizations_of_profile(clientExtId, profileExtId, continuationToken=continuationToken, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthorizationsRESTServiceApi->getAllAuthorizationsOfProfile: %s\n" % e)

extern crate AuthorizationsRESTServiceApi;

pub fn main() {
    let clientExtId = clientExtId_example; // String
    let profileExtId = profileExtId_example; // String
    let continuationToken = continuationToken_example; // String
    let limit = 56; // Integer

    let mut context = AuthorizationsRESTServiceApi::Context::default();
    let result = client.getAllAuthorizationsOfProfile(clientExtId, profileExtId, continuationToken, limit, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AuthorizationsRESTServiceApi apiInstance = new AuthorizationsRESTServiceApi();
        String clientExtId = clientExtId_example; // String | External ID of the client
        String profileExtId = profileExtId_example; // String | External ID of the profile
        String extId = extId_example; // String | External ID of the authorization

        try {
            AuthorizationGetDTO result = apiInstance.getAuthorizationOfProfile(clientExtId, profileExtId, extId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthorizationsRESTServiceApi#getAuthorizationOfProfile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String clientExtId = new String(); // String | External ID of the client
final String profileExtId = new String(); // String | External ID of the profile
final String extId = new String(); // String | External ID of the authorization

try {
    final result = await api_instance.getAuthorizationOfProfile(clientExtId, profileExtId, extId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getAuthorizationOfProfile: $e\n');
}

import org.openapitools.client.api.AuthorizationsRESTServiceApi;

public class AuthorizationsRESTServiceApiExample {
    public static void main(String[] args) {
        AuthorizationsRESTServiceApi apiInstance = new AuthorizationsRESTServiceApi();
        String clientExtId = clientExtId_example; // String | External ID of the client
        String profileExtId = profileExtId_example; // String | External ID of the profile
        String extId = extId_example; // String | External ID of the authorization

        try {
            AuthorizationGetDTO result = apiInstance.getAuthorizationOfProfile(clientExtId, profileExtId, extId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthorizationsRESTServiceApi#getAuthorizationOfProfile");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AuthorizationsRESTServiceApi *apiInstance = [[AuthorizationsRESTServiceApi alloc] init];
String *clientExtId = clientExtId_example; // External ID of the client (default to null)
String *profileExtId = profileExtId_example; // External ID of the profile (default to null)
String *extId = extId_example; // External ID of the authorization (default to null)

// Get a specific authorization
[apiInstance getAuthorizationOfProfileWith:clientExtId
    profileExtId:profileExtId
    extId:extId
              completionHandler: ^(AuthorizationGetDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.AuthorizationsRESTServiceApi()
var clientExtId = clientExtId_example; // {String} External ID of the client
var profileExtId = profileExtId_example; // {String} External ID of the profile
var extId = extId_example; // {String} External ID of the authorization

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

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

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

            // Create an instance of the API class
            var apiInstance = new AuthorizationsRESTServiceApi();
            var clientExtId = clientExtId_example;  // String | External ID of the client (default to null)
            var profileExtId = profileExtId_example;  // String | External ID of the profile (default to null)
            var extId = extId_example;  // String | External ID of the authorization (default to null)

            try {
                // Get a specific authorization
                AuthorizationGetDTO result = apiInstance.getAuthorizationOfProfile(clientExtId, profileExtId, extId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthorizationsRESTServiceApi.getAuthorizationOfProfile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthorizationsRESTServiceApi();
$clientExtId = clientExtId_example; // String | External ID of the client
$profileExtId = profileExtId_example; // String | External ID of the profile
$extId = extId_example; // String | External ID of the authorization

try {
    $result = $api_instance->getAuthorizationOfProfile($clientExtId, $profileExtId, $extId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthorizationsRESTServiceApi->getAuthorizationOfProfile: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthorizationsRESTServiceApi->new();
my $clientExtId = clientExtId_example; # String | External ID of the client
my $profileExtId = profileExtId_example; # String | External ID of the profile
my $extId = extId_example; # String | External ID of the authorization

eval {
    my $result = $api_instance->getAuthorizationOfProfile(clientExtId => $clientExtId, profileExtId => $profileExtId, extId => $extId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthorizationsRESTServiceApi->getAuthorizationOfProfile: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.AuthorizationsRESTServiceApi()
clientExtId = clientExtId_example # String | External ID of the client (default to null)
profileExtId = profileExtId_example # String | External ID of the profile (default to null)
extId = extId_example # String | External ID of the authorization (default to null)

try:
    # Get a specific authorization
    api_response = api_instance.get_authorization_of_profile(clientExtId, profileExtId, extId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthorizationsRESTServiceApi->getAuthorizationOfProfile: %s\n" % e)

extern crate AuthorizationsRESTServiceApi;

pub fn main() {
    let clientExtId = clientExtId_example; // String
    let profileExtId = profileExtId_example; // String
    let extId = extId_example; // String

    let mut context = AuthorizationsRESTServiceApi::Context::default();
    let result = client.getAuthorizationOfProfile(clientExtId, profileExtId, extId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AuthorizationsRESTServiceApi apiInstance = new AuthorizationsRESTServiceApi();
        String clientExtId = clientExtId_example; // String | External ID of the client
        String profileExtId = profileExtId_example; // String | External ID of the profile
        String extId = extId_example; // String | External ID of the authorization

        try {
            map['String', 'String'] result = apiInstance.getAuthorizationProperties(clientExtId, profileExtId, extId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthorizationsRESTServiceApi#getAuthorizationProperties");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String clientExtId = new String(); // String | External ID of the client
final String profileExtId = new String(); // String | External ID of the profile
final String extId = new String(); // String | External ID of the authorization

try {
    final result = await api_instance.getAuthorizationProperties(clientExtId, profileExtId, extId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getAuthorizationProperties: $e\n');
}

import org.openapitools.client.api.AuthorizationsRESTServiceApi;

public class AuthorizationsRESTServiceApiExample {
    public static void main(String[] args) {
        AuthorizationsRESTServiceApi apiInstance = new AuthorizationsRESTServiceApi();
        String clientExtId = clientExtId_example; // String | External ID of the client
        String profileExtId = profileExtId_example; // String | External ID of the profile
        String extId = extId_example; // String | External ID of the authorization

        try {
            map['String', 'String'] result = apiInstance.getAuthorizationProperties(clientExtId, profileExtId, extId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthorizationsRESTServiceApi#getAuthorizationProperties");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AuthorizationsRESTServiceApi *apiInstance = [[AuthorizationsRESTServiceApi alloc] init];
String *clientExtId = clientExtId_example; // External ID of the client (default to null)
String *profileExtId = profileExtId_example; // External ID of the profile (default to null)
String *extId = extId_example; // External ID of the authorization (default to null)

// Get authorization properties
[apiInstance getAuthorizationPropertiesWith:clientExtId
    profileExtId:profileExtId
    extId:extId
              completionHandler: ^(map['String', 'String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.AuthorizationsRESTServiceApi()
var clientExtId = clientExtId_example; // {String} External ID of the client
var profileExtId = profileExtId_example; // {String} External ID of the profile
var extId = extId_example; // {String} External ID of the authorization

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

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

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

            // Create an instance of the API class
            var apiInstance = new AuthorizationsRESTServiceApi();
            var clientExtId = clientExtId_example;  // String | External ID of the client (default to null)
            var profileExtId = profileExtId_example;  // String | External ID of the profile (default to null)
            var extId = extId_example;  // String | External ID of the authorization (default to null)

            try {
                // Get authorization properties
                map['String', 'String'] result = apiInstance.getAuthorizationProperties(clientExtId, profileExtId, extId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthorizationsRESTServiceApi.getAuthorizationProperties: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthorizationsRESTServiceApi();
$clientExtId = clientExtId_example; // String | External ID of the client
$profileExtId = profileExtId_example; // String | External ID of the profile
$extId = extId_example; // String | External ID of the authorization

try {
    $result = $api_instance->getAuthorizationProperties($clientExtId, $profileExtId, $extId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthorizationsRESTServiceApi->getAuthorizationProperties: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthorizationsRESTServiceApi->new();
my $clientExtId = clientExtId_example; # String | External ID of the client
my $profileExtId = profileExtId_example; # String | External ID of the profile
my $extId = extId_example; # String | External ID of the authorization

eval {
    my $result = $api_instance->getAuthorizationProperties(clientExtId => $clientExtId, profileExtId => $profileExtId, extId => $extId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthorizationsRESTServiceApi->getAuthorizationProperties: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.AuthorizationsRESTServiceApi()
clientExtId = clientExtId_example # String | External ID of the client (default to null)
profileExtId = profileExtId_example # String | External ID of the profile (default to null)
extId = extId_example # String | External ID of the authorization (default to null)

try:
    # Get authorization properties
    api_response = api_instance.get_authorization_properties(clientExtId, profileExtId, extId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthorizationsRESTServiceApi->getAuthorizationProperties: %s\n" % e)

extern crate AuthorizationsRESTServiceApi;

pub fn main() {
    let clientExtId = clientExtId_example; // String
    let profileExtId = profileExtId_example; // String
    let extId = extId_example; // String

    let mut context = AuthorizationsRESTServiceApi::Context::default();
    let result = client.getAuthorizationProperties(clientExtId, profileExtId, extId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        CertificateRESTServiceApi apiInstance = new CertificateRESTServiceApi();
        String clientExtId = 1000; // String | ExtID of the client
        String userExtId = 1234; // String | ExtID of the user
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 1000; // Integer | Pagination limit

        try {
            ItemsWrapperForCertificateInfoGetDTO result = apiInstance.getAllCertificates(clientExtId, userExtId, continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateRESTServiceApi#getAllCertificates");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String clientExtId = new String(); // String | ExtID of the client
final String userExtId = new String(); // String | ExtID of the user
final String continuationToken = new String(); // String | Pagination continuation token
final Integer limit = new Integer(); // Integer | Pagination limit

try {
    final result = await api_instance.getAllCertificates(clientExtId, userExtId, continuationToken, limit);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getAllCertificates: $e\n');
}

import org.openapitools.client.api.CertificateRESTServiceApi;

public class CertificateRESTServiceApiExample {
    public static void main(String[] args) {
        CertificateRESTServiceApi apiInstance = new CertificateRESTServiceApi();
        String clientExtId = 1000; // String | ExtID of the client
        String userExtId = 1234; // String | ExtID of the user
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 1000; // Integer | Pagination limit

        try {
            ItemsWrapperForCertificateInfoGetDTO result = apiInstance.getAllCertificates(clientExtId, userExtId, continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateRESTServiceApi#getAllCertificates");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CertificateRESTServiceApi *apiInstance = [[CertificateRESTServiceApi alloc] init];
String *clientExtId = 1000; // ExtID of the client (default to null)
String *userExtId = 1234; // ExtID of the user (default to null)
String *continuationToken = continuationToken_example; // Pagination continuation token (optional) (default to )
Integer *limit = 1000; // Pagination limit (optional) (default to 0)

// Get all certificates
[apiInstance getAllCertificatesWith:clientExtId
    userExtId:userExtId
    continuationToken:continuationToken
    limit:limit
              completionHandler: ^(ItemsWrapperForCertificateInfoGetDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.CertificateRESTServiceApi()
var clientExtId = 1000; // {String} ExtID of the client
var userExtId = 1234; // {String} ExtID of the user
var opts = {
  'continuationToken': continuationToken_example, // {String} Pagination continuation token
  'limit': 1000 // {Integer} Pagination limit
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new CertificateRESTServiceApi();
            var clientExtId = 1000;  // String | ExtID of the client (default to null)
            var userExtId = 1234;  // String | ExtID of the user (default to null)
            var continuationToken = continuationToken_example;  // String | Pagination continuation token (optional)  (default to )
            var limit = 1000;  // Integer | Pagination limit (optional)  (default to 0)

            try {
                // Get all certificates
                ItemsWrapperForCertificateInfoGetDTO result = apiInstance.getAllCertificates(clientExtId, userExtId, continuationToken, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CertificateRESTServiceApi.getAllCertificates: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CertificateRESTServiceApi();
$clientExtId = 1000; // String | ExtID of the client
$userExtId = 1234; // String | ExtID of the user
$continuationToken = continuationToken_example; // String | Pagination continuation token
$limit = 1000; // Integer | Pagination limit

try {
    $result = $api_instance->getAllCertificates($clientExtId, $userExtId, $continuationToken, $limit);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CertificateRESTServiceApi->getAllCertificates: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CertificateRESTServiceApi->new();
my $clientExtId = 1000; # String | ExtID of the client
my $userExtId = 1234; # String | ExtID of the user
my $continuationToken = continuationToken_example; # String | Pagination continuation token
my $limit = 1000; # Integer | Pagination limit

eval {
    my $result = $api_instance->getAllCertificates(clientExtId => $clientExtId, userExtId => $userExtId, continuationToken => $continuationToken, limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CertificateRESTServiceApi->getAllCertificates: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CertificateRESTServiceApi()
clientExtId = 1000 # String | ExtID of the client (default to null)
userExtId = 1234 # String | ExtID of the user (default to null)
continuationToken = continuationToken_example # String | Pagination continuation token (optional) (default to )
limit = 1000 # Integer | Pagination limit (optional) (default to 0)

try:
    # Get all certificates
    api_response = api_instance.get_all_certificates(clientExtId, userExtId, continuationToken=continuationToken, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CertificateRESTServiceApi->getAllCertificates: %s\n" % e)

extern crate CertificateRESTServiceApi;

pub fn main() {
    let clientExtId = 1000; // String
    let userExtId = 1234; // String
    let continuationToken = continuationToken_example; // String
    let limit = 1000; // Integer

    let mut context = CertificateRESTServiceApi::Context::default();
    let result = client.getAllCertificates(clientExtId, userExtId, continuationToken, limit, &context).wait();

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

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

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

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

        // Create an instance of the API class
        CertificateRESTServiceApi apiInstance = new CertificateRESTServiceApi();
        String clientExtId = 1000; // String | ExtID of the client
        String userExtId = 1234; // String | ExtID of the user
        String extId = 28000033; // String | ExtID of the certificate credential

        try {
            CertificateGetDTO result = apiInstance.getCertificate(clientExtId, userExtId, extId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateRESTServiceApi#getCertificate");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String clientExtId = new String(); // String | ExtID of the client
final String userExtId = new String(); // String | ExtID of the user
final String extId = new String(); // String | ExtID of the certificate credential

try {
    final result = await api_instance.getCertificate(clientExtId, userExtId, extId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getCertificate: $e\n');
}

import org.openapitools.client.api.CertificateRESTServiceApi;

public class CertificateRESTServiceApiExample {
    public static void main(String[] args) {
        CertificateRESTServiceApi apiInstance = new CertificateRESTServiceApi();
        String clientExtId = 1000; // String | ExtID of the client
        String userExtId = 1234; // String | ExtID of the user
        String extId = 28000033; // String | ExtID of the certificate credential

        try {
            CertificateGetDTO result = apiInstance.getCertificate(clientExtId, userExtId, extId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateRESTServiceApi#getCertificate");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CertificateRESTServiceApi *apiInstance = [[CertificateRESTServiceApi alloc] init];
String *clientExtId = 1000; // ExtID of the client (default to null)
String *userExtId = 1234; // ExtID of the user (default to null)
String *extId = 28000033; // ExtID of the certificate credential (default to null)

// Get certificate
[apiInstance getCertificateWith:clientExtId
    userExtId:userExtId
    extId:extId
              completionHandler: ^(CertificateGetDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.CertificateRESTServiceApi()
var clientExtId = 1000; // {String} ExtID of the client
var userExtId = 1234; // {String} ExtID of the user
var extId = 28000033; // {String} ExtID of the certificate credential

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

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

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

            // Create an instance of the API class
            var apiInstance = new CertificateRESTServiceApi();
            var clientExtId = 1000;  // String | ExtID of the client (default to null)
            var userExtId = 1234;  // String | ExtID of the user (default to null)
            var extId = 28000033;  // String | ExtID of the certificate credential (default to null)

            try {
                // Get certificate
                CertificateGetDTO result = apiInstance.getCertificate(clientExtId, userExtId, extId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CertificateRESTServiceApi.getCertificate: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CertificateRESTServiceApi();
$clientExtId = 1000; // String | ExtID of the client
$userExtId = 1234; // String | ExtID of the user
$extId = 28000033; // String | ExtID of the certificate credential

try {
    $result = $api_instance->getCertificate($clientExtId, $userExtId, $extId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CertificateRESTServiceApi->getCertificate: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CertificateRESTServiceApi->new();
my $clientExtId = 1000; # String | ExtID of the client
my $userExtId = 1234; # String | ExtID of the user
my $extId = 28000033; # String | ExtID of the certificate credential

eval {
    my $result = $api_instance->getCertificate(clientExtId => $clientExtId, userExtId => $userExtId, extId => $extId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CertificateRESTServiceApi->getCertificate: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CertificateRESTServiceApi()
clientExtId = 1000 # String | ExtID of the client (default to null)
userExtId = 1234 # String | ExtID of the user (default to null)
extId = 28000033 # String | ExtID of the certificate credential (default to null)

try:
    # Get certificate
    api_response = api_instance.get_certificate(clientExtId, userExtId, extId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CertificateRESTServiceApi->getCertificate: %s\n" % e)

extern crate CertificateRESTServiceApi;

pub fn main() {
    let clientExtId = 1000; // String
    let userExtId = 1234; // String
    let extId = 28000033; // String

    let mut context = CertificateRESTServiceApi::Context::default();
    let result = client.getCertificate(clientExtId, userExtId, extId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        CertificateRESTServiceApi apiInstance = new CertificateRESTServiceApi();
        String clientExtId = 1000; // String | ExtID of the client
        String userExtId = 1234; // String | ExtID of the user
        String extId = 28000033; // String | ExtID of the certificate credential

        try {
            map['String', 'String'] result = apiInstance.getCertificateProperties(clientExtId, userExtId, extId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateRESTServiceApi#getCertificateProperties");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String clientExtId = new String(); // String | ExtID of the client
final String userExtId = new String(); // String | ExtID of the user
final String extId = new String(); // String | ExtID of the certificate credential

try {
    final result = await api_instance.getCertificateProperties(clientExtId, userExtId, extId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getCertificateProperties: $e\n');
}

import org.openapitools.client.api.CertificateRESTServiceApi;

public class CertificateRESTServiceApiExample {
    public static void main(String[] args) {
        CertificateRESTServiceApi apiInstance = new CertificateRESTServiceApi();
        String clientExtId = 1000; // String | ExtID of the client
        String userExtId = 1234; // String | ExtID of the user
        String extId = 28000033; // String | ExtID of the certificate credential

        try {
            map['String', 'String'] result = apiInstance.getCertificateProperties(clientExtId, userExtId, extId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateRESTServiceApi#getCertificateProperties");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CertificateRESTServiceApi *apiInstance = [[CertificateRESTServiceApi alloc] init];
String *clientExtId = 1000; // ExtID of the client (default to null)
String *userExtId = 1234; // ExtID of the user (default to null)
String *extId = 28000033; // ExtID of the certificate credential (default to null)

// Get certificate properties
[apiInstance getCertificatePropertiesWith:clientExtId
    userExtId:userExtId
    extId:extId
              completionHandler: ^(map['String', 'String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.CertificateRESTServiceApi()
var clientExtId = 1000; // {String} ExtID of the client
var userExtId = 1234; // {String} ExtID of the user
var extId = 28000033; // {String} ExtID of the certificate credential

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

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

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

            // Create an instance of the API class
            var apiInstance = new CertificateRESTServiceApi();
            var clientExtId = 1000;  // String | ExtID of the client (default to null)
            var userExtId = 1234;  // String | ExtID of the user (default to null)
            var extId = 28000033;  // String | ExtID of the certificate credential (default to null)

            try {
                // Get certificate properties
                map['String', 'String'] result = apiInstance.getCertificateProperties(clientExtId, userExtId, extId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CertificateRESTServiceApi.getCertificateProperties: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CertificateRESTServiceApi();
$clientExtId = 1000; // String | ExtID of the client
$userExtId = 1234; // String | ExtID of the user
$extId = 28000033; // String | ExtID of the certificate credential

try {
    $result = $api_instance->getCertificateProperties($clientExtId, $userExtId, $extId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CertificateRESTServiceApi->getCertificateProperties: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CertificateRESTServiceApi->new();
my $clientExtId = 1000; # String | ExtID of the client
my $userExtId = 1234; # String | ExtID of the user
my $extId = 28000033; # String | ExtID of the certificate credential

eval {
    my $result = $api_instance->getCertificateProperties(clientExtId => $clientExtId, userExtId => $userExtId, extId => $extId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CertificateRESTServiceApi->getCertificateProperties: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CertificateRESTServiceApi()
clientExtId = 1000 # String | ExtID of the client (default to null)
userExtId = 1234 # String | ExtID of the user (default to null)
extId = 28000033 # String | ExtID of the certificate credential (default to null)

try:
    # Get certificate properties
    api_response = api_instance.get_certificate_properties(clientExtId, userExtId, extId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CertificateRESTServiceApi->getCertificateProperties: %s\n" % e)

extern crate CertificateRESTServiceApi;

pub fn main() {
    let clientExtId = 1000; // String
    let userExtId = 1234; // String
    let extId = 28000033; // String

    let mut context = CertificateRESTServiceApi::Context::default();
    let result = client.getCertificateProperties(clientExtId, userExtId, extId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ClientRESTServiceApi apiInstance = new ClientRESTServiceApi();
        String clientExtId = 1000; // String | ExtID of the client
        map[String, String] allParams = Object; // map[String, String] | 

        try {
            CountDto result = apiInstance.countUsers(clientExtId, allParams);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClientRESTServiceApi#countUsers");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String clientExtId = new String(); // String | ExtID of the client
final map[String, String] allParams = new map[String, String](); // map[String, String] | 

try {
    final result = await api_instance.countUsers(clientExtId, allParams);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->countUsers: $e\n');
}

import org.openapitools.client.api.ClientRESTServiceApi;

public class ClientRESTServiceApiExample {
    public static void main(String[] args) {
        ClientRESTServiceApi apiInstance = new ClientRESTServiceApi();
        String clientExtId = 1000; // String | ExtID of the client
        map[String, String] allParams = Object; // map[String, String] | 

        try {
            CountDto result = apiInstance.countUsers(clientExtId, allParams);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClientRESTServiceApi#countUsers");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ClientRESTServiceApi *apiInstance = [[ClientRESTServiceApi alloc] init];
String *clientExtId = 1000; // ExtID of the client (default to null)
map[String, String] *allParams = Object; //  (default to null)

// Count client users
[apiInstance countUsersWith:clientExtId
    allParams:allParams
              completionHandler: ^(CountDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.ClientRESTServiceApi()
var clientExtId = 1000; // {String} ExtID of the client
var allParams = Object; // {map[String, String]} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ClientRESTServiceApi();
            var clientExtId = 1000;  // String | ExtID of the client (default to null)
            var allParams = new map[String, String](); // map[String, String] |  (default to null)

            try {
                // Count client users
                CountDto result = apiInstance.countUsers(clientExtId, allParams);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ClientRESTServiceApi.countUsers: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ClientRESTServiceApi();
$clientExtId = 1000; // String | ExtID of the client
$allParams = Object; // map[String, String] | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ClientRESTServiceApi->new();
my $clientExtId = 1000; # String | ExtID of the client
my $allParams = Object; # map[String, String] | 

eval {
    my $result = $api_instance->countUsers(clientExtId => $clientExtId, allParams => $allParams);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClientRESTServiceApi->countUsers: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.ClientRESTServiceApi()
clientExtId = 1000 # String | ExtID of the client (default to null)
allParams = Object # map[String, String] |  (default to null)

try:
    # Count client users
    api_response = api_instance.count_users(clientExtId, allParams)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClientRESTServiceApi->countUsers: %s\n" % e)

extern crate ClientRESTServiceApi;

pub fn main() {
    let clientExtId = 1000; // String
    let allParams = Object; // map[String, String]

    let mut context = ClientRESTServiceApi::Context::default();
    let result = client.countUsers(clientExtId, allParams, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ClientRESTServiceApi apiInstance = new ClientRESTServiceApi();
        String extId = 1000; // String | ExtID of the client
        map[String, String] allParams = Object; // map[String, String] | 
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 1000; // Integer | Pagination limit
        String sortBy = sortBy_example; // String | Sort by field
        Integer offset = 56; // Integer | Offset for pagination
        Boolean returnTotalResultCount = true; // Boolean | Return total result count

        try {
            ItemsWrapperForGenericCredentialGetDTO result = apiInstance.findAllGenericCredential(extId, allParams, continuationToken, limit, sortBy, offset, returnTotalResultCount);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClientRESTServiceApi#findAllGenericCredential");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String extId = new String(); // String | ExtID of the client
final map[String, String] allParams = new map[String, String](); // map[String, String] | 
final String continuationToken = new String(); // String | Pagination continuation token
final Integer limit = new Integer(); // Integer | Pagination limit
final String sortBy = new String(); // String | Sort by field
final Integer offset = new Integer(); // Integer | Offset for pagination
final Boolean returnTotalResultCount = new Boolean(); // Boolean | Return total result count

try {
    final result = await api_instance.findAllGenericCredential(extId, allParams, continuationToken, limit, sortBy, offset, returnTotalResultCount);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->findAllGenericCredential: $e\n');
}

import org.openapitools.client.api.ClientRESTServiceApi;

public class ClientRESTServiceApiExample {
    public static void main(String[] args) {
        ClientRESTServiceApi apiInstance = new ClientRESTServiceApi();
        String extId = 1000; // String | ExtID of the client
        map[String, String] allParams = Object; // map[String, String] | 
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 1000; // Integer | Pagination limit
        String sortBy = sortBy_example; // String | Sort by field
        Integer offset = 56; // Integer | Offset for pagination
        Boolean returnTotalResultCount = true; // Boolean | Return total result count

        try {
            ItemsWrapperForGenericCredentialGetDTO result = apiInstance.findAllGenericCredential(extId, allParams, continuationToken, limit, sortBy, offset, returnTotalResultCount);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClientRESTServiceApi#findAllGenericCredential");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ClientRESTServiceApi *apiInstance = [[ClientRESTServiceApi alloc] init];
String *extId = 1000; // ExtID of the client (default to null)
map[String, String] *allParams = Object; //  (default to null)
String *continuationToken = continuationToken_example; // Pagination continuation token (optional) (default to )
Integer *limit = 1000; // Pagination limit (optional) (default to 0)
String *sortBy = sortBy_example; // Sort by field (optional) (default to )
Integer *offset = 56; // Offset for pagination (optional) (default to null)
Boolean *returnTotalResultCount = true; // Return total result count (optional) (default to false)

// Get client generic credentials
[apiInstance findAllGenericCredentialWith:extId
    allParams:allParams
    continuationToken:continuationToken
    limit:limit
    sortBy:sortBy
    offset:offset
    returnTotalResultCount:returnTotalResultCount
              completionHandler: ^(ItemsWrapperForGenericCredentialGetDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.ClientRESTServiceApi()
var extId = 1000; // {String} ExtID of the client
var allParams = Object; // {map[String, String]} 
var opts = {
  'continuationToken': continuationToken_example, // {String} Pagination continuation token
  'limit': 1000, // {Integer} Pagination limit
  'sortBy': sortBy_example, // {String} Sort by field
  'offset': 56, // {Integer} Offset for pagination
  'returnTotalResultCount': true // {Boolean} Return total result count
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ClientRESTServiceApi();
            var extId = 1000;  // String | ExtID of the client (default to null)
            var allParams = new map[String, String](); // map[String, String] |  (default to null)
            var continuationToken = continuationToken_example;  // String | Pagination continuation token (optional)  (default to )
            var limit = 1000;  // Integer | Pagination limit (optional)  (default to 0)
            var sortBy = sortBy_example;  // String | Sort by field (optional)  (default to )
            var offset = 56;  // Integer | Offset for pagination (optional)  (default to null)
            var returnTotalResultCount = true;  // Boolean | Return total result count (optional)  (default to false)

            try {
                // Get client generic credentials
                ItemsWrapperForGenericCredentialGetDTO result = apiInstance.findAllGenericCredential(extId, allParams, continuationToken, limit, sortBy, offset, returnTotalResultCount);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ClientRESTServiceApi.findAllGenericCredential: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ClientRESTServiceApi();
$extId = 1000; // String | ExtID of the client
$allParams = Object; // map[String, String] | 
$continuationToken = continuationToken_example; // String | Pagination continuation token
$limit = 1000; // Integer | Pagination limit
$sortBy = sortBy_example; // String | Sort by field
$offset = 56; // Integer | Offset for pagination
$returnTotalResultCount = true; // Boolean | Return total result count

try {
    $result = $api_instance->findAllGenericCredential($extId, $allParams, $continuationToken, $limit, $sortBy, $offset, $returnTotalResultCount);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ClientRESTServiceApi->findAllGenericCredential: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ClientRESTServiceApi->new();
my $extId = 1000; # String | ExtID of the client
my $allParams = Object; # map[String, String] | 
my $continuationToken = continuationToken_example; # String | Pagination continuation token
my $limit = 1000; # Integer | Pagination limit
my $sortBy = sortBy_example; # String | Sort by field
my $offset = 56; # Integer | Offset for pagination
my $returnTotalResultCount = true; # Boolean | Return total result count

eval {
    my $result = $api_instance->findAllGenericCredential(extId => $extId, allParams => $allParams, continuationToken => $continuationToken, limit => $limit, sortBy => $sortBy, offset => $offset, returnTotalResultCount => $returnTotalResultCount);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClientRESTServiceApi->findAllGenericCredential: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.ClientRESTServiceApi()
extId = 1000 # String | ExtID of the client (default to null)
allParams = Object # map[String, String] |  (default to null)
continuationToken = continuationToken_example # String | Pagination continuation token (optional) (default to )
limit = 1000 # Integer | Pagination limit (optional) (default to 0)
sortBy = sortBy_example # String | Sort by field (optional) (default to )
offset = 56 # Integer | Offset for pagination (optional) (default to null)
returnTotalResultCount = true # Boolean | Return total result count (optional) (default to false)

try:
    # Get client generic credentials
    api_response = api_instance.find_all_generic_credential(extId, allParams, continuationToken=continuationToken, limit=limit, sortBy=sortBy, offset=offset, returnTotalResultCount=returnTotalResultCount)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClientRESTServiceApi->findAllGenericCredential: %s\n" % e)

extern crate ClientRESTServiceApi;

pub fn main() {
    let extId = 1000; // String
    let allParams = Object; // map[String, String]
    let continuationToken = continuationToken_example; // String
    let limit = 1000; // Integer
    let sortBy = sortBy_example; // String
    let offset = 56; // Integer
    let returnTotalResultCount = true; // Boolean

    let mut context = ClientRESTServiceApi::Context::default();
    let result = client.findAllGenericCredential(extId, allParams, continuationToken, limit, sortBy, offset, returnTotalResultCount, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ClientRESTServiceApi apiInstance = new ClientRESTServiceApi();
        String extId = 1000; // String | ExtID of the client
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 100; // Integer | Pagination limit

        try {
            ItemsWrapperDTO result = apiInstance.getApplications1(extId, continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClientRESTServiceApi#getApplications1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String extId = new String(); // String | ExtID of the client
final String continuationToken = new String(); // String | Pagination continuation token
final Integer limit = new Integer(); // Integer | Pagination limit

try {
    final result = await api_instance.getApplications1(extId, continuationToken, limit);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getApplications1: $e\n');
}

import org.openapitools.client.api.ClientRESTServiceApi;

public class ClientRESTServiceApiExample {
    public static void main(String[] args) {
        ClientRESTServiceApi apiInstance = new ClientRESTServiceApi();
        String extId = 1000; // String | ExtID of the client
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 100; // Integer | Pagination limit

        try {
            ItemsWrapperDTO result = apiInstance.getApplications1(extId, continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClientRESTServiceApi#getApplications1");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ClientRESTServiceApi *apiInstance = [[ClientRESTServiceApi alloc] init];
String *extId = 1000; // ExtID of the client (default to null)
String *continuationToken = continuationToken_example; // Pagination continuation token (optional) (default to )
Integer *limit = 100; // Pagination limit (optional) (default to 0)

// Get client applications
[apiInstance getApplications1With:extId
    continuationToken:continuationToken
    limit:limit
              completionHandler: ^(ItemsWrapperDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.ClientRESTServiceApi()
var extId = 1000; // {String} ExtID of the client
var opts = {
  'continuationToken': continuationToken_example, // {String} Pagination continuation token
  'limit': 100 // {Integer} Pagination limit
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ClientRESTServiceApi();
            var extId = 1000;  // String | ExtID of the client (default to null)
            var continuationToken = continuationToken_example;  // String | Pagination continuation token (optional)  (default to )
            var limit = 100;  // Integer | Pagination limit (optional)  (default to 0)

            try {
                // Get client applications
                ItemsWrapperDTO result = apiInstance.getApplications1(extId, continuationToken, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ClientRESTServiceApi.getApplications1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ClientRESTServiceApi();
$extId = 1000; // String | ExtID of the client
$continuationToken = continuationToken_example; // String | Pagination continuation token
$limit = 100; // Integer | Pagination limit

try {
    $result = $api_instance->getApplications1($extId, $continuationToken, $limit);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ClientRESTServiceApi->getApplications1: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ClientRESTServiceApi->new();
my $extId = 1000; # String | ExtID of the client
my $continuationToken = continuationToken_example; # String | Pagination continuation token
my $limit = 100; # Integer | Pagination limit

eval {
    my $result = $api_instance->getApplications1(extId => $extId, continuationToken => $continuationToken, limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClientRESTServiceApi->getApplications1: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.ClientRESTServiceApi()
extId = 1000 # String | ExtID of the client (default to null)
continuationToken = continuationToken_example # String | Pagination continuation token (optional) (default to )
limit = 100 # Integer | Pagination limit (optional) (default to 0)

try:
    # Get client applications
    api_response = api_instance.get_applications1(extId, continuationToken=continuationToken, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClientRESTServiceApi->getApplications1: %s\n" % e)

extern crate ClientRESTServiceApi;

pub fn main() {
    let extId = 1000; // String
    let continuationToken = continuationToken_example; // String
    let limit = 100; // Integer

    let mut context = ClientRESTServiceApi::Context::default();
    let result = client.getApplications1(extId, continuationToken, limit, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ClientRESTServiceApi apiInstance = new ClientRESTServiceApi();
        String extId = 1000; // String | ExtID of the client

        try {
            ClientGetDTO result = apiInstance.getClient(extId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClientRESTServiceApi#getClient");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String extId = new String(); // String | ExtID of the client

try {
    final result = await api_instance.getClient(extId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getClient: $e\n');
}

import org.openapitools.client.api.ClientRESTServiceApi;

public class ClientRESTServiceApiExample {
    public static void main(String[] args) {
        ClientRESTServiceApi apiInstance = new ClientRESTServiceApi();
        String extId = 1000; // String | ExtID of the client

        try {
            ClientGetDTO result = apiInstance.getClient(extId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClientRESTServiceApi#getClient");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ClientRESTServiceApi *apiInstance = [[ClientRESTServiceApi alloc] init];
String *extId = 1000; // ExtID of the client (default to null)

// Get client
[apiInstance getClientWith:extId
              completionHandler: ^(ClientGetDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.ClientRESTServiceApi()
var extId = 1000; // {String} ExtID of the client

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

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

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

            // Create an instance of the API class
            var apiInstance = new ClientRESTServiceApi();
            var extId = 1000;  // String | ExtID of the client (default to null)

            try {
                // Get client
                ClientGetDTO result = apiInstance.getClient(extId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ClientRESTServiceApi.getClient: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ClientRESTServiceApi();
$extId = 1000; // String | ExtID of the client

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ClientRESTServiceApi->new();
my $extId = 1000; # String | ExtID of the client

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

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

# Create an instance of the API class
api_instance = openapi_client.ClientRESTServiceApi()
extId = 1000 # String | ExtID of the client (default to null)

try:
    # Get client
    api_response = api_instance.get_client(extId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClientRESTServiceApi->getClient: %s\n" % e)

extern crate ClientRESTServiceApi;

pub fn main() {
    let extId = 1000; // String

    let mut context = ClientRESTServiceApi::Context::default();
    let result = client.getClient(extId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ClientRESTServiceApi apiInstance = new ClientRESTServiceApi();
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 1000; // Integer | Pagination limit

        try {
            ItemsWrapperForClientGetDTO result = apiInstance.getClients(continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClientRESTServiceApi#getClients");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String continuationToken = new String(); // String | Pagination continuation token
final Integer limit = new Integer(); // Integer | Pagination limit

try {
    final result = await api_instance.getClients(continuationToken, limit);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getClients: $e\n');
}

import org.openapitools.client.api.ClientRESTServiceApi;

public class ClientRESTServiceApiExample {
    public static void main(String[] args) {
        ClientRESTServiceApi apiInstance = new ClientRESTServiceApi();
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 1000; // Integer | Pagination limit

        try {
            ItemsWrapperForClientGetDTO result = apiInstance.getClients(continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClientRESTServiceApi#getClients");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ClientRESTServiceApi *apiInstance = [[ClientRESTServiceApi alloc] init];
String *continuationToken = continuationToken_example; // Pagination continuation token (optional) (default to )
Integer *limit = 1000; // Pagination limit (optional) (default to 0)

// Get clients
[apiInstance getClientsWith:continuationToken
    limit:limit
              completionHandler: ^(ItemsWrapperForClientGetDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.ClientRESTServiceApi()
var opts = {
  'continuationToken': continuationToken_example, // {String} Pagination continuation token
  'limit': 1000 // {Integer} Pagination limit
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ClientRESTServiceApi();
            var continuationToken = continuationToken_example;  // String | Pagination continuation token (optional)  (default to )
            var limit = 1000;  // Integer | Pagination limit (optional)  (default to 0)

            try {
                // Get clients
                ItemsWrapperForClientGetDTO result = apiInstance.getClients(continuationToken, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ClientRESTServiceApi.getClients: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ClientRESTServiceApi();
$continuationToken = continuationToken_example; // String | Pagination continuation token
$limit = 1000; // Integer | Pagination limit

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ClientRESTServiceApi->new();
my $continuationToken = continuationToken_example; # String | Pagination continuation token
my $limit = 1000; # Integer | Pagination limit

eval {
    my $result = $api_instance->getClients(continuationToken => $continuationToken, limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClientRESTServiceApi->getClients: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.ClientRESTServiceApi()
continuationToken = continuationToken_example # String | Pagination continuation token (optional) (default to )
limit = 1000 # Integer | Pagination limit (optional) (default to 0)

try:
    # Get clients
    api_response = api_instance.get_clients(continuationToken=continuationToken, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClientRESTServiceApi->getClients: %s\n" % e)

extern crate ClientRESTServiceApi;

pub fn main() {
    let continuationToken = continuationToken_example; // String
    let limit = 1000; // Integer

    let mut context = ClientRESTServiceApi::Context::default();
    let result = client.getClients(continuationToken, limit, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ClientRESTServiceApi apiInstance = new ClientRESTServiceApi();
        String extId = 1000; // String | ExtID of the client
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 100; // Integer | Pagination limit

        try {
            ItemsWrapperDTO result = apiInstance.getEnterpriseRoles1(extId, continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClientRESTServiceApi#getEnterpriseRoles1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String extId = new String(); // String | ExtID of the client
final String continuationToken = new String(); // String | Pagination continuation token
final Integer limit = new Integer(); // Integer | Pagination limit

try {
    final result = await api_instance.getEnterpriseRoles1(extId, continuationToken, limit);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getEnterpriseRoles1: $e\n');
}

import org.openapitools.client.api.ClientRESTServiceApi;

public class ClientRESTServiceApiExample {
    public static void main(String[] args) {
        ClientRESTServiceApi apiInstance = new ClientRESTServiceApi();
        String extId = 1000; // String | ExtID of the client
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 100; // Integer | Pagination limit

        try {
            ItemsWrapperDTO result = apiInstance.getEnterpriseRoles1(extId, continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClientRESTServiceApi#getEnterpriseRoles1");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ClientRESTServiceApi *apiInstance = [[ClientRESTServiceApi alloc] init];
String *extId = 1000; // ExtID of the client (default to null)
String *continuationToken = continuationToken_example; // Pagination continuation token (optional) (default to )
Integer *limit = 100; // Pagination limit (optional) (default to 0)

// Get client eroles
[apiInstance getEnterpriseRoles1With:extId
    continuationToken:continuationToken
    limit:limit
              completionHandler: ^(ItemsWrapperDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.ClientRESTServiceApi()
var extId = 1000; // {String} ExtID of the client
var opts = {
  'continuationToken': continuationToken_example, // {String} Pagination continuation token
  'limit': 100 // {Integer} Pagination limit
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ClientRESTServiceApi();
            var extId = 1000;  // String | ExtID of the client (default to null)
            var continuationToken = continuationToken_example;  // String | Pagination continuation token (optional)  (default to )
            var limit = 100;  // Integer | Pagination limit (optional)  (default to 0)

            try {
                // Get client eroles
                ItemsWrapperDTO result = apiInstance.getEnterpriseRoles1(extId, continuationToken, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ClientRESTServiceApi.getEnterpriseRoles1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ClientRESTServiceApi();
$extId = 1000; // String | ExtID of the client
$continuationToken = continuationToken_example; // String | Pagination continuation token
$limit = 100; // Integer | Pagination limit

try {
    $result = $api_instance->getEnterpriseRoles1($extId, $continuationToken, $limit);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ClientRESTServiceApi->getEnterpriseRoles1: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ClientRESTServiceApi->new();
my $extId = 1000; # String | ExtID of the client
my $continuationToken = continuationToken_example; # String | Pagination continuation token
my $limit = 100; # Integer | Pagination limit

eval {
    my $result = $api_instance->getEnterpriseRoles1(extId => $extId, continuationToken => $continuationToken, limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClientRESTServiceApi->getEnterpriseRoles1: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.ClientRESTServiceApi()
extId = 1000 # String | ExtID of the client (default to null)
continuationToken = continuationToken_example # String | Pagination continuation token (optional) (default to )
limit = 100 # Integer | Pagination limit (optional) (default to 0)

try:
    # Get client eroles
    api_response = api_instance.get_enterprise_roles1(extId, continuationToken=continuationToken, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClientRESTServiceApi->getEnterpriseRoles1: %s\n" % e)

extern crate ClientRESTServiceApi;

pub fn main() {
    let extId = 1000; // String
    let continuationToken = continuationToken_example; // String
    let limit = 100; // Integer

    let mut context = ClientRESTServiceApi::Context::default();
    let result = client.getEnterpriseRoles1(extId, continuationToken, limit, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ClientRESTServiceApi apiInstance = new ClientRESTServiceApi();
        String extId = 1000; // String | ExtID of the client
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 100; // Integer | Pagination limit

        try {
            ItemsWrapperForPolicyConfigurationGetDTO result = apiInstance.getPolicyConfigurations(extId, continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClientRESTServiceApi#getPolicyConfigurations");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String extId = new String(); // String | ExtID of the client
final String continuationToken = new String(); // String | Pagination continuation token
final Integer limit = new Integer(); // Integer | Pagination limit

try {
    final result = await api_instance.getPolicyConfigurations(extId, continuationToken, limit);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getPolicyConfigurations: $e\n');
}

import org.openapitools.client.api.ClientRESTServiceApi;

public class ClientRESTServiceApiExample {
    public static void main(String[] args) {
        ClientRESTServiceApi apiInstance = new ClientRESTServiceApi();
        String extId = 1000; // String | ExtID of the client
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 100; // Integer | Pagination limit

        try {
            ItemsWrapperForPolicyConfigurationGetDTO result = apiInstance.getPolicyConfigurations(extId, continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClientRESTServiceApi#getPolicyConfigurations");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ClientRESTServiceApi *apiInstance = [[ClientRESTServiceApi alloc] init];
String *extId = 1000; // ExtID of the client (default to null)
String *continuationToken = continuationToken_example; // Pagination continuation token (optional) (default to )
Integer *limit = 100; // Pagination limit (optional) (default to 0)

// Get client policies
[apiInstance getPolicyConfigurationsWith:extId
    continuationToken:continuationToken
    limit:limit
              completionHandler: ^(ItemsWrapperForPolicyConfigurationGetDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.ClientRESTServiceApi()
var extId = 1000; // {String} ExtID of the client
var opts = {
  'continuationToken': continuationToken_example, // {String} Pagination continuation token
  'limit': 100 // {Integer} Pagination limit
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ClientRESTServiceApi();
            var extId = 1000;  // String | ExtID of the client (default to null)
            var continuationToken = continuationToken_example;  // String | Pagination continuation token (optional)  (default to )
            var limit = 100;  // Integer | Pagination limit (optional)  (default to 0)

            try {
                // Get client policies
                ItemsWrapperForPolicyConfigurationGetDTO result = apiInstance.getPolicyConfigurations(extId, continuationToken, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ClientRESTServiceApi.getPolicyConfigurations: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ClientRESTServiceApi();
$extId = 1000; // String | ExtID of the client
$continuationToken = continuationToken_example; // String | Pagination continuation token
$limit = 100; // Integer | Pagination limit

try {
    $result = $api_instance->getPolicyConfigurations($extId, $continuationToken, $limit);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ClientRESTServiceApi->getPolicyConfigurations: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ClientRESTServiceApi->new();
my $extId = 1000; # String | ExtID of the client
my $continuationToken = continuationToken_example; # String | Pagination continuation token
my $limit = 100; # Integer | Pagination limit

eval {
    my $result = $api_instance->getPolicyConfigurations(extId => $extId, continuationToken => $continuationToken, limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClientRESTServiceApi->getPolicyConfigurations: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.ClientRESTServiceApi()
extId = 1000 # String | ExtID of the client (default to null)
continuationToken = continuationToken_example # String | Pagination continuation token (optional) (default to )
limit = 100 # Integer | Pagination limit (optional) (default to 0)

try:
    # Get client policies
    api_response = api_instance.get_policy_configurations(extId, continuationToken=continuationToken, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClientRESTServiceApi->getPolicyConfigurations: %s\n" % e)

extern crate ClientRESTServiceApi;

pub fn main() {
    let extId = 1000; // String
    let continuationToken = continuationToken_example; // String
    let limit = 100; // Integer

    let mut context = ClientRESTServiceApi::Context::default();
    let result = client.getPolicyConfigurations(extId, continuationToken, limit, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ClientRESTServiceApi apiInstance = new ClientRESTServiceApi();
        String extId = 1000; // String | ExtID of the client
        map[String, String] allParams = Object; // map[String, String] | 
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 100; // Integer | Pagination limit

        try {
            ItemsWrapperDTO result = apiInstance.getUnits(extId, allParams, continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClientRESTServiceApi#getUnits");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String extId = new String(); // String | ExtID of the client
final map[String, String] allParams = new map[String, String](); // map[String, String] | 
final String continuationToken = new String(); // String | Pagination continuation token
final Integer limit = new Integer(); // Integer | Pagination limit

try {
    final result = await api_instance.getUnits(extId, allParams, continuationToken, limit);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getUnits: $e\n');
}

import org.openapitools.client.api.ClientRESTServiceApi;

public class ClientRESTServiceApiExample {
    public static void main(String[] args) {
        ClientRESTServiceApi apiInstance = new ClientRESTServiceApi();
        String extId = 1000; // String | ExtID of the client
        map[String, String] allParams = Object; // map[String, String] | 
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 100; // Integer | Pagination limit

        try {
            ItemsWrapperDTO result = apiInstance.getUnits(extId, allParams, continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClientRESTServiceApi#getUnits");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ClientRESTServiceApi *apiInstance = [[ClientRESTServiceApi alloc] init];
String *extId = 1000; // ExtID of the client (default to null)
map[String, String] *allParams = Object; //  (default to null)
String *continuationToken = continuationToken_example; // Pagination continuation token (optional) (default to )
Integer *limit = 100; // Pagination limit (optional) (default to 0)

// Get client units
[apiInstance getUnitsWith:extId
    allParams:allParams
    continuationToken:continuationToken
    limit:limit
              completionHandler: ^(ItemsWrapperDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.ClientRESTServiceApi()
var extId = 1000; // {String} ExtID of the client
var allParams = Object; // {map[String, String]} 
var opts = {
  'continuationToken': continuationToken_example, // {String} Pagination continuation token
  'limit': 100 // {Integer} Pagination limit
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ClientRESTServiceApi();
            var extId = 1000;  // String | ExtID of the client (default to null)
            var allParams = new map[String, String](); // map[String, String] |  (default to null)
            var continuationToken = continuationToken_example;  // String | Pagination continuation token (optional)  (default to )
            var limit = 100;  // Integer | Pagination limit (optional)  (default to 0)

            try {
                // Get client units
                ItemsWrapperDTO result = apiInstance.getUnits(extId, allParams, continuationToken, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ClientRESTServiceApi.getUnits: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ClientRESTServiceApi();
$extId = 1000; // String | ExtID of the client
$allParams = Object; // map[String, String] | 
$continuationToken = continuationToken_example; // String | Pagination continuation token
$limit = 100; // Integer | Pagination limit

try {
    $result = $api_instance->getUnits($extId, $allParams, $continuationToken, $limit);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ClientRESTServiceApi->getUnits: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ClientRESTServiceApi->new();
my $extId = 1000; # String | ExtID of the client
my $allParams = Object; # map[String, String] | 
my $continuationToken = continuationToken_example; # String | Pagination continuation token
my $limit = 100; # Integer | Pagination limit

eval {
    my $result = $api_instance->getUnits(extId => $extId, allParams => $allParams, continuationToken => $continuationToken, limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClientRESTServiceApi->getUnits: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.ClientRESTServiceApi()
extId = 1000 # String | ExtID of the client (default to null)
allParams = Object # map[String, String] |  (default to null)
continuationToken = continuationToken_example # String | Pagination continuation token (optional) (default to )
limit = 100 # Integer | Pagination limit (optional) (default to 0)

try:
    # Get client units
    api_response = api_instance.get_units(extId, allParams, continuationToken=continuationToken, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClientRESTServiceApi->getUnits: %s\n" % e)

extern crate ClientRESTServiceApi;

pub fn main() {
    let extId = 1000; // String
    let allParams = Object; // map[String, String]
    let continuationToken = continuationToken_example; // String
    let limit = 100; // Integer

    let mut context = ClientRESTServiceApi::Context::default();
    let result = client.getUnits(extId, allParams, continuationToken, limit, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ClientRESTServiceApi apiInstance = new ClientRESTServiceApi();
        String extId = 1000; // String | ExtID of the client
        map[String, String] allParams = Object; // map[String, String] | 
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 100; // Integer | Pagination limit
        String sortBy = sortBy_example; // String | Sort by field
        Boolean returnTotalResultCount = true; // Boolean | Return total result count
        Integer offset = 56; // Integer | Offset for pagination

        try {
            ItemsWrapperForUserGetDTO result = apiInstance.getUsers(extId, allParams, continuationToken, limit, sortBy, returnTotalResultCount, offset);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClientRESTServiceApi#getUsers");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String extId = new String(); // String | ExtID of the client
final map[String, String] allParams = new map[String, String](); // map[String, String] | 
final String continuationToken = new String(); // String | Pagination continuation token
final Integer limit = new Integer(); // Integer | Pagination limit
final String sortBy = new String(); // String | Sort by field
final Boolean returnTotalResultCount = new Boolean(); // Boolean | Return total result count
final Integer offset = new Integer(); // Integer | Offset for pagination

try {
    final result = await api_instance.getUsers(extId, allParams, continuationToken, limit, sortBy, returnTotalResultCount, offset);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getUsers: $e\n');
}

import org.openapitools.client.api.ClientRESTServiceApi;

public class ClientRESTServiceApiExample {
    public static void main(String[] args) {
        ClientRESTServiceApi apiInstance = new ClientRESTServiceApi();
        String extId = 1000; // String | ExtID of the client
        map[String, String] allParams = Object; // map[String, String] | 
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 100; // Integer | Pagination limit
        String sortBy = sortBy_example; // String | Sort by field
        Boolean returnTotalResultCount = true; // Boolean | Return total result count
        Integer offset = 56; // Integer | Offset for pagination

        try {
            ItemsWrapperForUserGetDTO result = apiInstance.getUsers(extId, allParams, continuationToken, limit, sortBy, returnTotalResultCount, offset);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClientRESTServiceApi#getUsers");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ClientRESTServiceApi *apiInstance = [[ClientRESTServiceApi alloc] init];
String *extId = 1000; // ExtID of the client (default to null)
map[String, String] *allParams = Object; //  (default to null)
String *continuationToken = continuationToken_example; // Pagination continuation token (optional) (default to )
Integer *limit = 100; // Pagination limit (optional) (default to 0)
String *sortBy = sortBy_example; // Sort by field (optional) (default to )
Boolean *returnTotalResultCount = true; // Return total result count (optional) (default to false)
Integer *offset = 56; // Offset for pagination (optional) (default to null)

// Get client users
[apiInstance getUsersWith:extId
    allParams:allParams
    continuationToken:continuationToken
    limit:limit
    sortBy:sortBy
    returnTotalResultCount:returnTotalResultCount
    offset:offset
              completionHandler: ^(ItemsWrapperForUserGetDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.ClientRESTServiceApi()
var extId = 1000; // {String} ExtID of the client
var allParams = Object; // {map[String, String]} 
var opts = {
  'continuationToken': continuationToken_example, // {String} Pagination continuation token
  'limit': 100, // {Integer} Pagination limit
  'sortBy': sortBy_example, // {String} Sort by field
  'returnTotalResultCount': true, // {Boolean} Return total result count
  'offset': 56 // {Integer} Offset for pagination
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ClientRESTServiceApi();
            var extId = 1000;  // String | ExtID of the client (default to null)
            var allParams = new map[String, String](); // map[String, String] |  (default to null)
            var continuationToken = continuationToken_example;  // String | Pagination continuation token (optional)  (default to )
            var limit = 100;  // Integer | Pagination limit (optional)  (default to 0)
            var sortBy = sortBy_example;  // String | Sort by field (optional)  (default to )
            var returnTotalResultCount = true;  // Boolean | Return total result count (optional)  (default to false)
            var offset = 56;  // Integer | Offset for pagination (optional)  (default to null)

            try {
                // Get client users
                ItemsWrapperForUserGetDTO result = apiInstance.getUsers(extId, allParams, continuationToken, limit, sortBy, returnTotalResultCount, offset);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ClientRESTServiceApi.getUsers: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ClientRESTServiceApi();
$extId = 1000; // String | ExtID of the client
$allParams = Object; // map[String, String] | 
$continuationToken = continuationToken_example; // String | Pagination continuation token
$limit = 100; // Integer | Pagination limit
$sortBy = sortBy_example; // String | Sort by field
$returnTotalResultCount = true; // Boolean | Return total result count
$offset = 56; // Integer | Offset for pagination

try {
    $result = $api_instance->getUsers($extId, $allParams, $continuationToken, $limit, $sortBy, $returnTotalResultCount, $offset);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ClientRESTServiceApi->getUsers: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ClientRESTServiceApi->new();
my $extId = 1000; # String | ExtID of the client
my $allParams = Object; # map[String, String] | 
my $continuationToken = continuationToken_example; # String | Pagination continuation token
my $limit = 100; # Integer | Pagination limit
my $sortBy = sortBy_example; # String | Sort by field
my $returnTotalResultCount = true; # Boolean | Return total result count
my $offset = 56; # Integer | Offset for pagination

eval {
    my $result = $api_instance->getUsers(extId => $extId, allParams => $allParams, continuationToken => $continuationToken, limit => $limit, sortBy => $sortBy, returnTotalResultCount => $returnTotalResultCount, offset => $offset);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClientRESTServiceApi->getUsers: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.ClientRESTServiceApi()
extId = 1000 # String | ExtID of the client (default to null)
allParams = Object # map[String, String] |  (default to null)
continuationToken = continuationToken_example # String | Pagination continuation token (optional) (default to )
limit = 100 # Integer | Pagination limit (optional) (default to 0)
sortBy = sortBy_example # String | Sort by field (optional) (default to )
returnTotalResultCount = true # Boolean | Return total result count (optional) (default to false)
offset = 56 # Integer | Offset for pagination (optional) (default to null)

try:
    # Get client users
    api_response = api_instance.get_users(extId, allParams, continuationToken=continuationToken, limit=limit, sortBy=sortBy, returnTotalResultCount=returnTotalResultCount, offset=offset)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClientRESTServiceApi->getUsers: %s\n" % e)

extern crate ClientRESTServiceApi;

pub fn main() {
    let extId = 1000; // String
    let allParams = Object; // map[String, String]
    let continuationToken = continuationToken_example; // String
    let limit = 100; // Integer
    let sortBy = sortBy_example; // String
    let returnTotalResultCount = true; // Boolean
    let offset = 56; // Integer

    let mut context = ClientRESTServiceApi::Context::default();
    let result = client.getUsers(extId, allParams, continuationToken, limit, sortBy, returnTotalResultCount, offset, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ClientRESTServiceApi apiInstance = new ClientRESTServiceApi();
        String extId = 1000; // String | ExtID of the client
        map[String, String] allParams = Object; // map[String, String] | 
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 1000; // Integer | Pagination limit
        String sortBy = sortBy_example; // String | Sort by field
        Boolean returnTotalResultCount = true; // Boolean | Return total result count
        Integer offset = 56; // Integer | Offset for pagination
         UNKNOWN_PARAMETER_NAME = ; //  | Filtering parameters are documented in the description

        try {
            ItemsWrapperForFido2GetDTO result = apiInstance.listAllFido2Credential(extId, allParams, continuationToken, limit, sortBy, returnTotalResultCount, offset, UNKNOWN_PARAMETER_NAME);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClientRESTServiceApi#listAllFido2Credential");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String extId = new String(); // String | ExtID of the client
final map[String, String] allParams = new map[String, String](); // map[String, String] | 
final String continuationToken = new String(); // String | Pagination continuation token
final Integer limit = new Integer(); // Integer | Pagination limit
final String sortBy = new String(); // String | Sort by field
final Boolean returnTotalResultCount = new Boolean(); // Boolean | Return total result count
final Integer offset = new Integer(); // Integer | Offset for pagination
final  UNKNOWN_PARAMETER_NAME = new (); //  | Filtering parameters are documented in the description

try {
    final result = await api_instance.listAllFido2Credential(extId, allParams, continuationToken, limit, sortBy, returnTotalResultCount, offset, UNKNOWN_PARAMETER_NAME);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listAllFido2Credential: $e\n');
}

import org.openapitools.client.api.ClientRESTServiceApi;

public class ClientRESTServiceApiExample {
    public static void main(String[] args) {
        ClientRESTServiceApi apiInstance = new ClientRESTServiceApi();
        String extId = 1000; // String | ExtID of the client
        map[String, String] allParams = Object; // map[String, String] | 
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 1000; // Integer | Pagination limit
        String sortBy = sortBy_example; // String | Sort by field
        Boolean returnTotalResultCount = true; // Boolean | Return total result count
        Integer offset = 56; // Integer | Offset for pagination
         UNKNOWN_PARAMETER_NAME = ; //  | Filtering parameters are documented in the description

        try {
            ItemsWrapperForFido2GetDTO result = apiInstance.listAllFido2Credential(extId, allParams, continuationToken, limit, sortBy, returnTotalResultCount, offset, UNKNOWN_PARAMETER_NAME);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClientRESTServiceApi#listAllFido2Credential");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ClientRESTServiceApi *apiInstance = [[ClientRESTServiceApi alloc] init];
String *extId = 1000; // ExtID of the client (default to null)
map[String, String] *allParams = Object; //  (default to null)
String *continuationToken = continuationToken_example; // Pagination continuation token (optional) (default to )
Integer *limit = 1000; // Pagination limit (optional) (default to 0)
String *sortBy = sortBy_example; // Sort by field (optional) (default to )
Boolean *returnTotalResultCount = true; // Return total result count (optional) (default to false)
Integer *offset = 56; // Offset for pagination (optional) (default to null)
 *UNKNOWN_PARAMETER_NAME = ; // Filtering parameters are documented in the description (optional)

// Get client FIDO2 credentials
[apiInstance listAllFido2CredentialWith:extId
    allParams:allParams
    continuationToken:continuationToken
    limit:limit
    sortBy:sortBy
    returnTotalResultCount:returnTotalResultCount
    offset:offset
    UNKNOWN_PARAMETER_NAME:UNKNOWN_PARAMETER_NAME
              completionHandler: ^(ItemsWrapperForFido2GetDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.ClientRESTServiceApi()
var extId = 1000; // {String} ExtID of the client
var allParams = Object; // {map[String, String]} 
var opts = {
  'continuationToken': continuationToken_example, // {String} Pagination continuation token
  'limit': 1000, // {Integer} Pagination limit
  'sortBy': sortBy_example, // {String} Sort by field
  'returnTotalResultCount': true, // {Boolean} Return total result count
  'offset': 56, // {Integer} Offset for pagination
  'UNKNOWN_PARAMETER_NAME':  // {} Filtering parameters are documented in the description
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ClientRESTServiceApi();
            var extId = 1000;  // String | ExtID of the client (default to null)
            var allParams = new map[String, String](); // map[String, String] |  (default to null)
            var continuationToken = continuationToken_example;  // String | Pagination continuation token (optional)  (default to )
            var limit = 1000;  // Integer | Pagination limit (optional)  (default to 0)
            var sortBy = sortBy_example;  // String | Sort by field (optional)  (default to )
            var returnTotalResultCount = true;  // Boolean | Return total result count (optional)  (default to false)
            var offset = 56;  // Integer | Offset for pagination (optional)  (default to null)
            var UNKNOWN_PARAMETER_NAME = new (); //  | Filtering parameters are documented in the description (optional) 

            try {
                // Get client FIDO2 credentials
                ItemsWrapperForFido2GetDTO result = apiInstance.listAllFido2Credential(extId, allParams, continuationToken, limit, sortBy, returnTotalResultCount, offset, UNKNOWN_PARAMETER_NAME);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ClientRESTServiceApi.listAllFido2Credential: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ClientRESTServiceApi();
$extId = 1000; // String | ExtID of the client
$allParams = Object; // map[String, String] | 
$continuationToken = continuationToken_example; // String | Pagination continuation token
$limit = 1000; // Integer | Pagination limit
$sortBy = sortBy_example; // String | Sort by field
$returnTotalResultCount = true; // Boolean | Return total result count
$offset = 56; // Integer | Offset for pagination
$UNKNOWN_PARAMETER_NAME = ; //  | Filtering parameters are documented in the description

try {
    $result = $api_instance->listAllFido2Credential($extId, $allParams, $continuationToken, $limit, $sortBy, $returnTotalResultCount, $offset, $UNKNOWN_PARAMETER_NAME);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ClientRESTServiceApi->listAllFido2Credential: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ClientRESTServiceApi->new();
my $extId = 1000; # String | ExtID of the client
my $allParams = Object; # map[String, String] | 
my $continuationToken = continuationToken_example; # String | Pagination continuation token
my $limit = 1000; # Integer | Pagination limit
my $sortBy = sortBy_example; # String | Sort by field
my $returnTotalResultCount = true; # Boolean | Return total result count
my $offset = 56; # Integer | Offset for pagination
my $UNKNOWN_PARAMETER_NAME = ; #  | Filtering parameters are documented in the description

eval {
    my $result = $api_instance->listAllFido2Credential(extId => $extId, allParams => $allParams, continuationToken => $continuationToken, limit => $limit, sortBy => $sortBy, returnTotalResultCount => $returnTotalResultCount, offset => $offset, UNKNOWN_PARAMETER_NAME => $UNKNOWN_PARAMETER_NAME);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClientRESTServiceApi->listAllFido2Credential: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.ClientRESTServiceApi()
extId = 1000 # String | ExtID of the client (default to null)
allParams = Object # map[String, String] |  (default to null)
continuationToken = continuationToken_example # String | Pagination continuation token (optional) (default to )
limit = 1000 # Integer | Pagination limit (optional) (default to 0)
sortBy = sortBy_example # String | Sort by field (optional) (default to )
returnTotalResultCount = true # Boolean | Return total result count (optional) (default to false)
offset = 56 # Integer | Offset for pagination (optional) (default to null)
UNKNOWN_PARAMETER_NAME =  #  | Filtering parameters are documented in the description (optional)

try:
    # Get client FIDO2 credentials
    api_response = api_instance.list_all_fido2_credential(extId, allParams, continuationToken=continuationToken, limit=limit, sortBy=sortBy, returnTotalResultCount=returnTotalResultCount, offset=offset, UNKNOWN_PARAMETER_NAME=UNKNOWN_PARAMETER_NAME)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClientRESTServiceApi->listAllFido2Credential: %s\n" % e)

extern crate ClientRESTServiceApi;

pub fn main() {
    let extId = 1000; // String
    let allParams = Object; // map[String, String]
    let continuationToken = continuationToken_example; // String
    let limit = 1000; // Integer
    let sortBy = sortBy_example; // String
    let returnTotalResultCount = true; // Boolean
    let offset = 56; // Integer
    let UNKNOWN_PARAMETER_NAME = ; // 

    let mut context = ClientRESTServiceApi::Context::default();
    let result = client.listAllFido2Credential(extId, allParams, continuationToken, limit, sortBy, returnTotalResultCount, offset, UNKNOWN_PARAMETER_NAME, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ClientRESTServiceApi apiInstance = new ClientRESTServiceApi();
        String extId = 1000; // String | ExtID of the client
        map[String, String] allParams = Object; // map[String, String] | 
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 1000; // Integer | Pagination limit

        try {
            ItemsWrapperForFidoUafGetDTO result = apiInstance.listAllFidoUafCredential(extId, allParams, continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClientRESTServiceApi#listAllFidoUafCredential");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String extId = new String(); // String | ExtID of the client
final map[String, String] allParams = new map[String, String](); // map[String, String] | 
final String continuationToken = new String(); // String | Pagination continuation token
final Integer limit = new Integer(); // Integer | Pagination limit

try {
    final result = await api_instance.listAllFidoUafCredential(extId, allParams, continuationToken, limit);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listAllFidoUafCredential: $e\n');
}

import org.openapitools.client.api.ClientRESTServiceApi;

public class ClientRESTServiceApiExample {
    public static void main(String[] args) {
        ClientRESTServiceApi apiInstance = new ClientRESTServiceApi();
        String extId = 1000; // String | ExtID of the client
        map[String, String] allParams = Object; // map[String, String] | 
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 1000; // Integer | Pagination limit

        try {
            ItemsWrapperForFidoUafGetDTO result = apiInstance.listAllFidoUafCredential(extId, allParams, continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClientRESTServiceApi#listAllFidoUafCredential");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ClientRESTServiceApi *apiInstance = [[ClientRESTServiceApi alloc] init];
String *extId = 1000; // ExtID of the client (default to null)
map[String, String] *allParams = Object; //  (default to null)
String *continuationToken = continuationToken_example; // Pagination continuation token (optional) (default to )
Integer *limit = 1000; // Pagination limit (optional) (default to 0)

// Get client FIDO UAF credentials
[apiInstance listAllFidoUafCredentialWith:extId
    allParams:allParams
    continuationToken:continuationToken
    limit:limit
              completionHandler: ^(ItemsWrapperForFidoUafGetDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.ClientRESTServiceApi()
var extId = 1000; // {String} ExtID of the client
var allParams = Object; // {map[String, String]} 
var opts = {
  'continuationToken': continuationToken_example, // {String} Pagination continuation token
  'limit': 1000 // {Integer} Pagination limit
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ClientRESTServiceApi();
            var extId = 1000;  // String | ExtID of the client (default to null)
            var allParams = new map[String, String](); // map[String, String] |  (default to null)
            var continuationToken = continuationToken_example;  // String | Pagination continuation token (optional)  (default to )
            var limit = 1000;  // Integer | Pagination limit (optional)  (default to 0)

            try {
                // Get client FIDO UAF credentials
                ItemsWrapperForFidoUafGetDTO result = apiInstance.listAllFidoUafCredential(extId, allParams, continuationToken, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ClientRESTServiceApi.listAllFidoUafCredential: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ClientRESTServiceApi();
$extId = 1000; // String | ExtID of the client
$allParams = Object; // map[String, String] | 
$continuationToken = continuationToken_example; // String | Pagination continuation token
$limit = 1000; // Integer | Pagination limit

try {
    $result = $api_instance->listAllFidoUafCredential($extId, $allParams, $continuationToken, $limit);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ClientRESTServiceApi->listAllFidoUafCredential: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ClientRESTServiceApi->new();
my $extId = 1000; # String | ExtID of the client
my $allParams = Object; # map[String, String] | 
my $continuationToken = continuationToken_example; # String | Pagination continuation token
my $limit = 1000; # Integer | Pagination limit

eval {
    my $result = $api_instance->listAllFidoUafCredential(extId => $extId, allParams => $allParams, continuationToken => $continuationToken, limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClientRESTServiceApi->listAllFidoUafCredential: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.ClientRESTServiceApi()
extId = 1000 # String | ExtID of the client (default to null)
allParams = Object # map[String, String] |  (default to null)
continuationToken = continuationToken_example # String | Pagination continuation token (optional) (default to )
limit = 1000 # Integer | Pagination limit (optional) (default to 0)

try:
    # Get client FIDO UAF credentials
    api_response = api_instance.list_all_fido_uaf_credential(extId, allParams, continuationToken=continuationToken, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClientRESTServiceApi->listAllFidoUafCredential: %s\n" % e)

extern crate ClientRESTServiceApi;

pub fn main() {
    let extId = 1000; // String
    let allParams = Object; // map[String, String]
    let continuationToken = continuationToken_example; // String
    let limit = 1000; // Integer

    let mut context = ClientRESTServiceApi::Context::default();
    let result = client.listAllFidoUafCredential(extId, allParams, continuationToken, limit, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ClientRESTServiceApi apiInstance = new ClientRESTServiceApi();
        String extId = 1000; // String | ExtID of the client
        map[String, String] allParams = Object; // map[String, String] | 

        try {
            ItemsWrapperDTO result = apiInstance.listAllPropertiesForClient(extId, allParams);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClientRESTServiceApi#listAllPropertiesForClient");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String extId = new String(); // String | ExtID of the client
final map[String, String] allParams = new map[String, String](); // map[String, String] | 

try {
    final result = await api_instance.listAllPropertiesForClient(extId, allParams);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listAllPropertiesForClient: $e\n');
}

import org.openapitools.client.api.ClientRESTServiceApi;

public class ClientRESTServiceApiExample {
    public static void main(String[] args) {
        ClientRESTServiceApi apiInstance = new ClientRESTServiceApi();
        String extId = 1000; // String | ExtID of the client
        map[String, String] allParams = Object; // map[String, String] | 

        try {
            ItemsWrapperDTO result = apiInstance.listAllPropertiesForClient(extId, allParams);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClientRESTServiceApi#listAllPropertiesForClient");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ClientRESTServiceApi *apiInstance = [[ClientRESTServiceApi alloc] init];
String *extId = 1000; // ExtID of the client (default to null)
map[String, String] *allParams = Object; //  (default to null)

// Get all the properties for a client
[apiInstance listAllPropertiesForClientWith:extId
    allParams:allParams
              completionHandler: ^(ItemsWrapperDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.ClientRESTServiceApi()
var extId = 1000; // {String} ExtID of the client
var allParams = Object; // {map[String, String]} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ClientRESTServiceApi();
            var extId = 1000;  // String | ExtID of the client (default to null)
            var allParams = new map[String, String](); // map[String, String] |  (default to null)

            try {
                // Get all the properties for a client
                ItemsWrapperDTO result = apiInstance.listAllPropertiesForClient(extId, allParams);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ClientRESTServiceApi.listAllPropertiesForClient: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ClientRESTServiceApi();
$extId = 1000; // String | ExtID of the client
$allParams = Object; // map[String, String] | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ClientRESTServiceApi->new();
my $extId = 1000; # String | ExtID of the client
my $allParams = Object; # map[String, String] | 

eval {
    my $result = $api_instance->listAllPropertiesForClient(extId => $extId, allParams => $allParams);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClientRESTServiceApi->listAllPropertiesForClient: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.ClientRESTServiceApi()
extId = 1000 # String | ExtID of the client (default to null)
allParams = Object # map[String, String] |  (default to null)

try:
    # Get all the properties for a client
    api_response = api_instance.list_all_properties_for_client(extId, allParams)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClientRESTServiceApi->listAllPropertiesForClient: %s\n" % e)

extern crate ClientRESTServiceApi;

pub fn main() {
    let extId = 1000; // String
    let allParams = Object; // map[String, String]

    let mut context = ClientRESTServiceApi::Context::default();
    let result = client.listAllPropertiesForClient(extId, allParams, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ContextPasswordRESTServiceApi apiInstance = new ContextPasswordRESTServiceApi();
        String clientExtId = 1000; // String | ExtID of the client
        String userExtId = 1234; // String | ExtID of the user
        String extId = 27000029; // String | ExtID of the context password credential

        try {
            ContextPasswordGetDTO result = apiInstance.getContextPassword(clientExtId, userExtId, extId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContextPasswordRESTServiceApi#getContextPassword");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String clientExtId = new String(); // String | ExtID of the client
final String userExtId = new String(); // String | ExtID of the user
final String extId = new String(); // String | ExtID of the context password credential

try {
    final result = await api_instance.getContextPassword(clientExtId, userExtId, extId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getContextPassword: $e\n');
}

import org.openapitools.client.api.ContextPasswordRESTServiceApi;

public class ContextPasswordRESTServiceApiExample {
    public static void main(String[] args) {
        ContextPasswordRESTServiceApi apiInstance = new ContextPasswordRESTServiceApi();
        String clientExtId = 1000; // String | ExtID of the client
        String userExtId = 1234; // String | ExtID of the user
        String extId = 27000029; // String | ExtID of the context password credential

        try {
            ContextPasswordGetDTO result = apiInstance.getContextPassword(clientExtId, userExtId, extId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContextPasswordRESTServiceApi#getContextPassword");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ContextPasswordRESTServiceApi *apiInstance = [[ContextPasswordRESTServiceApi alloc] init];
String *clientExtId = 1000; // ExtID of the client (default to null)
String *userExtId = 1234; // ExtID of the user (default to null)
String *extId = 27000029; // ExtID of the context password credential (default to null)

// Get context password
[apiInstance getContextPasswordWith:clientExtId
    userExtId:userExtId
    extId:extId
              completionHandler: ^(ContextPasswordGetDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.ContextPasswordRESTServiceApi()
var clientExtId = 1000; // {String} ExtID of the client
var userExtId = 1234; // {String} ExtID of the user
var extId = 27000029; // {String} ExtID of the context password credential

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

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

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

            // Create an instance of the API class
            var apiInstance = new ContextPasswordRESTServiceApi();
            var clientExtId = 1000;  // String | ExtID of the client (default to null)
            var userExtId = 1234;  // String | ExtID of the user (default to null)
            var extId = 27000029;  // String | ExtID of the context password credential (default to null)

            try {
                // Get context password
                ContextPasswordGetDTO result = apiInstance.getContextPassword(clientExtId, userExtId, extId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ContextPasswordRESTServiceApi.getContextPassword: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ContextPasswordRESTServiceApi();
$clientExtId = 1000; // String | ExtID of the client
$userExtId = 1234; // String | ExtID of the user
$extId = 27000029; // String | ExtID of the context password credential

try {
    $result = $api_instance->getContextPassword($clientExtId, $userExtId, $extId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ContextPasswordRESTServiceApi->getContextPassword: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ContextPasswordRESTServiceApi->new();
my $clientExtId = 1000; # String | ExtID of the client
my $userExtId = 1234; # String | ExtID of the user
my $extId = 27000029; # String | ExtID of the context password credential

eval {
    my $result = $api_instance->getContextPassword(clientExtId => $clientExtId, userExtId => $userExtId, extId => $extId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContextPasswordRESTServiceApi->getContextPassword: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.ContextPasswordRESTServiceApi()
clientExtId = 1000 # String | ExtID of the client (default to null)
userExtId = 1234 # String | ExtID of the user (default to null)
extId = 27000029 # String | ExtID of the context password credential (default to null)

try:
    # Get context password
    api_response = api_instance.get_context_password(clientExtId, userExtId, extId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContextPasswordRESTServiceApi->getContextPassword: %s\n" % e)

extern crate ContextPasswordRESTServiceApi;

pub fn main() {
    let clientExtId = 1000; // String
    let userExtId = 1234; // String
    let extId = 27000029; // String

    let mut context = ContextPasswordRESTServiceApi::Context::default();
    let result = client.getContextPassword(clientExtId, userExtId, extId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ContextPasswordRESTServiceApi apiInstance = new ContextPasswordRESTServiceApi();
        String clientExtId = 1000; // String | ExtID of the client
        String userExtId = 1234; // String | ExtID of the user
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 1000; // Integer | Pagination limit

        try {
            ItemsWrapperForContextPasswordGetDTO result = apiInstance.getContextPasswords(clientExtId, userExtId, continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContextPasswordRESTServiceApi#getContextPasswords");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String clientExtId = new String(); // String | ExtID of the client
final String userExtId = new String(); // String | ExtID of the user
final String continuationToken = new String(); // String | Pagination continuation token
final Integer limit = new Integer(); // Integer | Pagination limit

try {
    final result = await api_instance.getContextPasswords(clientExtId, userExtId, continuationToken, limit);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getContextPasswords: $e\n');
}

import org.openapitools.client.api.ContextPasswordRESTServiceApi;

public class ContextPasswordRESTServiceApiExample {
    public static void main(String[] args) {
        ContextPasswordRESTServiceApi apiInstance = new ContextPasswordRESTServiceApi();
        String clientExtId = 1000; // String | ExtID of the client
        String userExtId = 1234; // String | ExtID of the user
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 1000; // Integer | Pagination limit

        try {
            ItemsWrapperForContextPasswordGetDTO result = apiInstance.getContextPasswords(clientExtId, userExtId, continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContextPasswordRESTServiceApi#getContextPasswords");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ContextPasswordRESTServiceApi *apiInstance = [[ContextPasswordRESTServiceApi alloc] init];
String *clientExtId = 1000; // ExtID of the client (default to null)
String *userExtId = 1234; // ExtID of the user (default to null)
String *continuationToken = continuationToken_example; // Pagination continuation token (optional) (default to )
Integer *limit = 1000; // Pagination limit (optional) (default to 0)

// Get all context passwords
[apiInstance getContextPasswordsWith:clientExtId
    userExtId:userExtId
    continuationToken:continuationToken
    limit:limit
              completionHandler: ^(ItemsWrapperForContextPasswordGetDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.ContextPasswordRESTServiceApi()
var clientExtId = 1000; // {String} ExtID of the client
var userExtId = 1234; // {String} ExtID of the user
var opts = {
  'continuationToken': continuationToken_example, // {String} Pagination continuation token
  'limit': 1000 // {Integer} Pagination limit
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ContextPasswordRESTServiceApi();
            var clientExtId = 1000;  // String | ExtID of the client (default to null)
            var userExtId = 1234;  // String | ExtID of the user (default to null)
            var continuationToken = continuationToken_example;  // String | Pagination continuation token (optional)  (default to )
            var limit = 1000;  // Integer | Pagination limit (optional)  (default to 0)

            try {
                // Get all context passwords
                ItemsWrapperForContextPasswordGetDTO result = apiInstance.getContextPasswords(clientExtId, userExtId, continuationToken, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ContextPasswordRESTServiceApi.getContextPasswords: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ContextPasswordRESTServiceApi();
$clientExtId = 1000; // String | ExtID of the client
$userExtId = 1234; // String | ExtID of the user
$continuationToken = continuationToken_example; // String | Pagination continuation token
$limit = 1000; // Integer | Pagination limit

try {
    $result = $api_instance->getContextPasswords($clientExtId, $userExtId, $continuationToken, $limit);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ContextPasswordRESTServiceApi->getContextPasswords: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ContextPasswordRESTServiceApi->new();
my $clientExtId = 1000; # String | ExtID of the client
my $userExtId = 1234; # String | ExtID of the user
my $continuationToken = continuationToken_example; # String | Pagination continuation token
my $limit = 1000; # Integer | Pagination limit

eval {
    my $result = $api_instance->getContextPasswords(clientExtId => $clientExtId, userExtId => $userExtId, continuationToken => $continuationToken, limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContextPasswordRESTServiceApi->getContextPasswords: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.ContextPasswordRESTServiceApi()
clientExtId = 1000 # String | ExtID of the client (default to null)
userExtId = 1234 # String | ExtID of the user (default to null)
continuationToken = continuationToken_example # String | Pagination continuation token (optional) (default to )
limit = 1000 # Integer | Pagination limit (optional) (default to 0)

try:
    # Get all context passwords
    api_response = api_instance.get_context_passwords(clientExtId, userExtId, continuationToken=continuationToken, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContextPasswordRESTServiceApi->getContextPasswords: %s\n" % e)

extern crate ContextPasswordRESTServiceApi;

pub fn main() {
    let clientExtId = 1000; // String
    let userExtId = 1234; // String
    let continuationToken = continuationToken_example; // String
    let limit = 1000; // Integer

    let mut context = ContextPasswordRESTServiceApi::Context::default();
    let result = client.getContextPasswords(clientExtId, userExtId, continuationToken, limit, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DevicePasswordRESTServiceApi apiInstance = new DevicePasswordRESTServiceApi();
        String clientExtId = 1000; // String | ExtID of the client
        String userExtId = 1234; // String | ExtID of the user
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 1000; // Integer | Pagination limit

        try {
            ItemsWrapperForDevicePasswordGetDTO result = apiInstance.getAllDevicePasswords(clientExtId, userExtId, continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicePasswordRESTServiceApi#getAllDevicePasswords");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String clientExtId = new String(); // String | ExtID of the client
final String userExtId = new String(); // String | ExtID of the user
final String continuationToken = new String(); // String | Pagination continuation token
final Integer limit = new Integer(); // Integer | Pagination limit

try {
    final result = await api_instance.getAllDevicePasswords(clientExtId, userExtId, continuationToken, limit);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getAllDevicePasswords: $e\n');
}

import org.openapitools.client.api.DevicePasswordRESTServiceApi;

public class DevicePasswordRESTServiceApiExample {
    public static void main(String[] args) {
        DevicePasswordRESTServiceApi apiInstance = new DevicePasswordRESTServiceApi();
        String clientExtId = 1000; // String | ExtID of the client
        String userExtId = 1234; // String | ExtID of the user
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 1000; // Integer | Pagination limit

        try {
            ItemsWrapperForDevicePasswordGetDTO result = apiInstance.getAllDevicePasswords(clientExtId, userExtId, continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicePasswordRESTServiceApi#getAllDevicePasswords");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DevicePasswordRESTServiceApi *apiInstance = [[DevicePasswordRESTServiceApi alloc] init];
String *clientExtId = 1000; // ExtID of the client (default to null)
String *userExtId = 1234; // ExtID of the user (default to null)
String *continuationToken = continuationToken_example; // Pagination continuation token (optional) (default to )
Integer *limit = 1000; // Pagination limit (optional) (default to 0)

// Get user Device password credentials
[apiInstance getAllDevicePasswordsWith:clientExtId
    userExtId:userExtId
    continuationToken:continuationToken
    limit:limit
              completionHandler: ^(ItemsWrapperForDevicePasswordGetDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.DevicePasswordRESTServiceApi()
var clientExtId = 1000; // {String} ExtID of the client
var userExtId = 1234; // {String} ExtID of the user
var opts = {
  'continuationToken': continuationToken_example, // {String} Pagination continuation token
  'limit': 1000 // {Integer} Pagination limit
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DevicePasswordRESTServiceApi();
            var clientExtId = 1000;  // String | ExtID of the client (default to null)
            var userExtId = 1234;  // String | ExtID of the user (default to null)
            var continuationToken = continuationToken_example;  // String | Pagination continuation token (optional)  (default to )
            var limit = 1000;  // Integer | Pagination limit (optional)  (default to 0)

            try {
                // Get user Device password credentials
                ItemsWrapperForDevicePasswordGetDTO result = apiInstance.getAllDevicePasswords(clientExtId, userExtId, continuationToken, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DevicePasswordRESTServiceApi.getAllDevicePasswords: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DevicePasswordRESTServiceApi();
$clientExtId = 1000; // String | ExtID of the client
$userExtId = 1234; // String | ExtID of the user
$continuationToken = continuationToken_example; // String | Pagination continuation token
$limit = 1000; // Integer | Pagination limit

try {
    $result = $api_instance->getAllDevicePasswords($clientExtId, $userExtId, $continuationToken, $limit);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DevicePasswordRESTServiceApi->getAllDevicePasswords: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DevicePasswordRESTServiceApi->new();
my $clientExtId = 1000; # String | ExtID of the client
my $userExtId = 1234; # String | ExtID of the user
my $continuationToken = continuationToken_example; # String | Pagination continuation token
my $limit = 1000; # Integer | Pagination limit

eval {
    my $result = $api_instance->getAllDevicePasswords(clientExtId => $clientExtId, userExtId => $userExtId, continuationToken => $continuationToken, limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DevicePasswordRESTServiceApi->getAllDevicePasswords: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DevicePasswordRESTServiceApi()
clientExtId = 1000 # String | ExtID of the client (default to null)
userExtId = 1234 # String | ExtID of the user (default to null)
continuationToken = continuationToken_example # String | Pagination continuation token (optional) (default to )
limit = 1000 # Integer | Pagination limit (optional) (default to 0)

try:
    # Get user Device password credentials
    api_response = api_instance.get_all_device_passwords(clientExtId, userExtId, continuationToken=continuationToken, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DevicePasswordRESTServiceApi->getAllDevicePasswords: %s\n" % e)

extern crate DevicePasswordRESTServiceApi;

pub fn main() {
    let clientExtId = 1000; // String
    let userExtId = 1234; // String
    let continuationToken = continuationToken_example; // String
    let limit = 1000; // Integer

    let mut context = DevicePasswordRESTServiceApi::Context::default();
    let result = client.getAllDevicePasswords(clientExtId, userExtId, continuationToken, limit, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DevicePasswordRESTServiceApi apiInstance = new DevicePasswordRESTServiceApi();
        String clientExtId = 1000; // String | ExtID of the client
        String userExtId = 1234; // String | ExtID of the user
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 1000; // Integer | Pagination limit

        try {
            ItemsWrapperForDevicePasswordGetDTO result = apiInstance.getAllDevicePasswords1(clientExtId, userExtId, continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicePasswordRESTServiceApi#getAllDevicePasswords1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String clientExtId = new String(); // String | ExtID of the client
final String userExtId = new String(); // String | ExtID of the user
final String continuationToken = new String(); // String | Pagination continuation token
final Integer limit = new Integer(); // Integer | Pagination limit

try {
    final result = await api_instance.getAllDevicePasswords1(clientExtId, userExtId, continuationToken, limit);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getAllDevicePasswords1: $e\n');
}

import org.openapitools.client.api.DevicePasswordRESTServiceApi;

public class DevicePasswordRESTServiceApiExample {
    public static void main(String[] args) {
        DevicePasswordRESTServiceApi apiInstance = new DevicePasswordRESTServiceApi();
        String clientExtId = 1000; // String | ExtID of the client
        String userExtId = 1234; // String | ExtID of the user
        String continuationToken = continuationToken_example; // String | Pagination continuation token
        Integer limit = 1000; // Integer | Pagination limit

        try {
            ItemsWrapperForDevicePasswordGetDTO result = apiInstance.getAllDevicePasswords1(clientExtId, userExtId, continuationToken, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicePasswordRESTServiceApi#getAllDevicePasswords1");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DevicePasswordRESTServiceApi *apiInstance = [[DevicePasswordRESTServiceApi alloc] init];
String *clientExtId = 1000; // ExtID of the client (default to null)
String *userExtId = 1234; // ExtID of the user (default to null)
String *continuationToken = continuationToken_example; // Pagination continuation token (optional) (default to )
Integer *limit = 1000; // Pagination limit (optional) (default to 0)

// Get user Device password credentials
[apiInstance getAllDevicePasswords1With:clientExtId
    userExtId:userExtId
    continuationToken:continuationToken
    limit:limit
              completionHandler: ^(ItemsWrapperForDevicePasswordGetDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.DevicePasswordRESTServiceApi()
var clientExtId = 1000; // {String} ExtID of the client
var userExtId = 1234; // {String} ExtID of the user
var opts = {
  'continuationToken': continuationToken_example, // {String} Pagination continuation token
  'limit': 1000 // {Integer} Pagination limit
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DevicePasswordRESTServiceApi();
            var clientExtId = 1000;  // String | ExtID of the client (default to null)
            var userExtId = 1234;  // String | ExtID of the user (default to null)
            var continuationToken = continuationToken_example;  // String | Pagination continuation token (optional)  (default to )
            var limit = 1000;  // Integer | Pagination limit (optional)  (default to 0)

            try {
                // Get user Device password credentials
                ItemsWrapperForDevicePasswordGetDTO result = apiInstance.getAllDevicePasswords1(clientExtId, userExtId, continuationToken, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DevicePasswordRESTServiceApi.getAllDevicePasswords1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DevicePasswordRESTServiceApi();
$clientExtId = 1000; // String | ExtID of the client
$userExtId = 1234; // String | ExtID of the user
$continuationToken = continuationToken_example; // String | Pagination continuation token
$limit = 1000; // Integer | Pagination limit

try {
    $result = $api_instance->getAllDevicePasswords1($clientExtId, $userExtId, $continuationToken, $limit);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DevicePasswordRESTServiceApi->getAllDevicePasswords1: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DevicePasswordRESTServiceApi->new();
my $clientExtId = 1000; # String | ExtID of the client
my $userExtId = 1234; # String | ExtID of the user
my $continuationToken = continuationToken_example; # String | Pagination continuation token
my $limit = 1000; # Integer | Pagination limit

eval {
    my $result = $api_instance->getAllDevicePasswords1(clientExtId => $clientExtId, userExtId => $userExtId, continuationToken => $continuationToken, limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DevicePasswordRESTServiceApi->getAllDevicePasswords1: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DevicePasswordRESTServiceApi()
clientExtId = 1000 # String | ExtID of the client (default to null)
userExtId = 1234 # String | ExtID of the user (default to null)
continuationToken = continuationToken_example # String | Pagination continuation token (optional) (default to )
limit = 1000 # Integer | Pagination limit (optional) (default to 0)

try:
    # Get user Device password credentials
    api_response = api_instance.get_all_device_passwords1(clientExtId, userExtId, continuationToken=continuationToken, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DevicePasswordRESTServiceApi->getAllDevicePasswords1: %s\n" % e)

extern crate DevicePasswordRESTServiceApi;

pub fn main() {
    let clientExtId = 1000; // String
    let userExtId = 1234; // String
    let continuationToken = continuationToken_example; // String
    let limit = 1000; // Integer

    let mut context = DevicePasswordRESTServiceApi::Context::default();
    let result = client.getAllDevicePasswords1(clientExtId, userExtId, continuationToken, limit, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DevicePasswordRESTServiceApi apiInstance = new DevicePasswordRESTServiceApi();
        String clientExtId = 1000; // String | ExtID of the client
        String userExtId = 1234; // String | ExtID of the user
        String extId = 28000002; // String | ExtID of the credential

        try {
            DevicePasswordGetDTO result = apiInstance.getDevicePassword(clientExtId, userExtId, extId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicePasswordRESTServiceApi#getDevicePassword");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String clientExtId = new String(); // String | ExtID of the client
final String userExtId = new String(); // String | ExtID of the user
final String extId = new String(); // String | ExtID of the credential

try {
    final result = await api_instance.getDevicePassword(clientExtId, userExtId, extId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getDevicePassword: $e\n');
}

import org.openapitools.client.api.DevicePasswordRESTServiceApi;

public class DevicePasswordRESTServiceApiExample {
    public static void main(String[] args) {
        DevicePasswordRESTServiceApi apiInstance = new DevicePasswordRESTServiceApi();
        String clientExtId = 1000; // String | ExtID of the client
        String userExtId = 1234; // String | ExtID of the user
        String extId = 28000002; // String | ExtID of the credential

        try {
            DevicePasswordGetDTO result = apiInstance.getDevicePassword(clientExtId, userExtId, extId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicePasswordRESTServiceApi#getDevicePassword");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DevicePasswordRESTServiceApi *apiInstance = [[DevicePasswordRESTServiceApi alloc] init];
String *clientExtId = 1000; // ExtID of the client (default to null)
String *userExtId = 1234; // ExtID of the user (default to null)
String *extId = 28000002; // ExtID of the credential (default to null)

// Get Device password
[apiInstance getDevicePasswordWith:clientExtId
    userExtId:userExtId
    extId:extId
              completionHandler: ^(DevicePasswordGetDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.DevicePasswordRESTServiceApi()
var clientExtId = 1000; // {String} ExtID of the client
var userExtId = 1234; // {String} ExtID of the user
var extId = 28000002; // {String} ExtID of the credential

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

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

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

            // Create an instance of the API class
            var apiInstance = new DevicePasswordRESTServiceApi();
            var clientExtId = 1000;  // String | ExtID of the client (default to null)
            var userExtId = 1234;  // String | ExtID of the user (default to null)
            var extId = 28000002;  // String | ExtID of the credential (default to null)

            try {
                // Get Device password
                DevicePasswordGetDTO result = apiInstance.getDevicePassword(clientExtId, userExtId, extId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DevicePasswordRESTServiceApi.getDevicePassword: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DevicePasswordRESTServiceApi();
$clientExtId = 1000; // String | ExtID of the client
$userExtId = 1234; // String | ExtID of the user
$extId = 28000002; // String | ExtID of the credential

try {
    $result = $api_instance->getDevicePassword($clientExtId, $userExtId, $extId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DevicePasswordRESTServiceApi->getDevicePassword: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DevicePasswordRESTServiceApi->new();
my $clientExtId = 1000; # String | ExtID of the client
my $userExtId = 1234; # String | ExtID of the user
my $extId = 28000002; # String | ExtID of the credential

eval {
    my $result = $api_instance->getDevicePassword(clientExtId => $clientExtId, userExtId => $userExtId, extId => $extId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DevicePasswordRESTServiceApi->getDevicePassword: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DevicePasswordRESTServiceApi()
clientExtId = 1000 # String | ExtID of the client (default to null)
userExtId = 1234 # String | ExtID of the user (default to null)
extId = 28000002 # String | ExtID of the credential (default to null)

try:
    # Get Device password
    api_response = api_instance.get_device_password(clientExtId, userExtId, extId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DevicePasswordRESTServiceApi->getDevicePassword: %s\n" % e)

extern crate DevicePasswordRESTServiceApi;

pub fn main() {
    let clientExtId = 1000; // String
    let userExtId = 1234; // String
    let extId = 28000002; // String

    let mut context = DevicePasswordRESTServiceApi::Context::default();
    let result = client.getDevicePassword(clientExtId, userExtId, extId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DevicePasswordRESTServiceApi apiInstance = new DevicePasswordRESTServiceApi();
        String clientExtId = 1000; // String | ExtID of the client
        String userExtId = 1234; // String | ExtID of the user
        String extId = 28000002; // String | ExtID of the credential

        try {
            DevicePasswordGetDTO result = apiInstance.getDevicePassword1(clientExtId, userExtId, extId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicePasswordRESTServiceApi#getDevicePassword1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String clientExtId = new String(); // String | ExtID of the client
final String userExtId = new String(); // String | ExtID of the user
final String extId = new String(); // String | ExtID of the credential

try {
    final result = await api_instance.getDevicePassword1(clientExtId, userExtId, extId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getDevicePassword1: $e\n');
}

import org.openapitools.client.api.DevicePasswordRESTServiceApi;

public class DevicePasswordRESTServiceApiExample {
    public static void main(String[] args) {
        DevicePasswordRESTServiceApi apiInstance = new DevicePasswordRESTServiceApi();
        String clientExtId = 1000; // String | ExtID of the client
        String userExtId = 1234; // String | ExtID of the user
        String extId = 28000002; // String | ExtID of the credential

        try {
            DevicePasswordGetDTO result = apiInstance.getDevicePassword1(clientExtId, userExtId, extId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicePasswordRESTServiceApi#getDevicePassword1");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DevicePasswordRESTServiceApi *apiInstance = [[DevicePasswordRESTServiceApi alloc] init];
String *clientExtId = 1000; // ExtID of the client (default to null)
String *userExtId = 1234; // ExtID of the user (default to null)
String *extId = 28000002; // ExtID of the credential (default to null)

// Get Device password
[apiInstance getDevicePassword1With:clientExtId
    userExtId:userExtId
    extId:extId
              completionHandler: ^(DevicePasswordGetDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisIdmRestApiDocumentation = require('nevis_idm_rest_api_documentation');

// Create an instance of the API class
var api = new NevisIdmRestApiDocumentation.DevicePasswordRESTServiceApi()
var clientExtId = 1000; // {String} ExtID of the client
var userExtId = 1234; // {String} ExtID of the user
var extId = 28000002; // {String} ExtID of the credential

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

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

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

            // Create an instance of the API class
            var apiInstance = new DevicePasswordRESTServiceApi();
            var clientExtId = 1000;  // String | ExtID of the client (default to null)
            var userExtId = 1234;  // String | ExtID of the user (default to null)
            var extId = 28000002;  // String | ExtID of the credential (default to null)

            try {
                // Get Device password
                DevicePasswordGetDTO result = apiInstance.getDevicePassword1(clientExtId, userExtId, extId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DevicePasswordRESTServiceApi.getDevicePassword1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DevicePasswordRESTServiceApi();
$clientExtId = 1000; // String | ExtID of the client
$userExtId = 1234; // String | ExtID of the user
$extId = 28000002; // String | ExtID of the credential

try {
    $result = $api_instance->getDevicePassword1($clientExtId, $userExtId, $extId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DevicePasswordRESTServiceApi->getDevicePassword1: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DevicePasswordRESTServiceApi->new();
my $clientExtId = 1000; # String | ExtID of the client
my $userExtId = 1234; # String | ExtID of the user
my $extId = 28000002; # String | ExtID of the credential

eval {
    my $result = $api_instance->getDevicePassword1(clientExtId => $clientExtId, userExtId => $userExtId, extId => $extId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DevicePasswordRESTServiceApi->getDevicePassword1: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DevicePasswordRESTServiceApi()
clientExtId = 1000 # String | ExtID of the client (default to null)
userExtId = 1234 # String | ExtID of the user (default to null)
extId = 28000002 # String | ExtID of the credential (default to null)

try:
    # Get Device password
    api_response = api_instance.get_device_password1(clientExtId, userExtId, extId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DevicePasswordRESTServiceApi->getDevicePassword1: %s\n" % e)

extern crate DevicePasswordRESTServiceApi;

pub fn main() {
    let clientExtId = 1000; // String
    let userExtId = 1234; // String
    let extId = 28000002; // String

    let mut context = DevicePasswordRESTServiceApi::Context::default();
    let result = client.getDevicePassword1(clientExtId, userExtId, extId, &context).wait();

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