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

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

public class BatchesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        BatchesApi apiInstance = new BatchesApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        BatchEntry batchEntry = ; // BatchEntry | 

        try {
            apiInstance.createBatch(id, batchEntry);
        } catch (ApiException e) {
            System.err.println("Exception when calling BatchesApi#createBatch");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.BatchesApi;

public class BatchesApiExample {
    public static void main(String[] args) {
        BatchesApi apiInstance = new BatchesApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        BatchEntry batchEntry = ; // BatchEntry | 

        try {
            apiInstance.createBatch(id, batchEntry);
        } catch (ApiException e) {
            System.err.println("Exception when calling BatchesApi#createBatch");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
BatchesApi *apiInstance = [[BatchesApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
BatchEntry *batchEntry = ; //  (optional)

// Create a single batch.
[apiInstance createBatchWith:id
    batchEntry:batchEntry
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var CertificateManagementPortal = require('certificate_management_portal');
var defaultClient = CertificateManagementPortal.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new CertificateManagementPortal.BatchesApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var opts = {
  'batchEntry':  // {BatchEntry} 
};

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

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

namespace Example
{
    public class createBatchExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new BatchesApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var batchEntry = new BatchEntry(); // BatchEntry |  (optional) 

            try {
                // Create a single batch.
                apiInstance.createBatch(id, batchEntry);
            } catch (Exception e) {
                Debug.Print("Exception when calling BatchesApi.createBatch: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BatchesApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$batchEntry = ; // BatchEntry | 

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

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

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BatchesApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $batchEntry = WWW::OPenAPIClient::Object::BatchEntry->new(); # BatchEntry | 

eval {
    $api_instance->createBatch(id => $id, batchEntry => $batchEntry);
};
if ($@) {
    warn "Exception when calling BatchesApi->createBatch: $@\n";
}

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

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.BatchesApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
batchEntry =  # BatchEntry |  (optional)

try:
    # Create a single batch.
    api_instance.create_batch(id, batchEntry=batchEntry)
except ApiException as e:
    print("Exception when calling BatchesApi->createBatch: %s\n" % e)

extern crate BatchesApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let batchEntry = ; // BatchEntry

    let mut context = BatchesApi::Context::default();
    let result = client.createBatch(id, batchEntry, &context).wait();

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

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

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

public class BatchesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        BatchesApi apiInstance = new BatchesApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            deleteCertificate_204_response result = apiInstance.deleteBatch(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BatchesApi#deleteBatch");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.BatchesApi;

public class BatchesApiExample {
    public static void main(String[] args) {
        BatchesApi apiInstance = new BatchesApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            deleteCertificate_204_response result = apiInstance.deleteBatch(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BatchesApi#deleteBatch");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
BatchesApi *apiInstance = [[BatchesApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Delete a single batch.
[apiInstance deleteBatchWith:id
              completionHandler: ^(deleteCertificate_204_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var CertificateManagementPortal = require('certificate_management_portal');
var defaultClient = CertificateManagementPortal.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new CertificateManagementPortal.BatchesApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

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

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

namespace Example
{
    public class deleteBatchExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new BatchesApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Delete a single batch.
                deleteCertificate_204_response result = apiInstance.deleteBatch(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BatchesApi.deleteBatch: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BatchesApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

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

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BatchesApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

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

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

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.BatchesApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Delete a single batch.
    api_response = api_instance.delete_batch(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BatchesApi->deleteBatch: %s\n" % e)

extern crate BatchesApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = BatchesApi::Context::default();
    let result = client.deleteBatch(id, &context).wait();

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

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

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

public class BatchesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        BatchesApi apiInstance = new BatchesApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        Boolean download = true; // Boolean | If true, the batch's certificates will be returned as a .tag.gz file

        try {
            apiInstance.getBatch(id, download);
        } catch (ApiException e) {
            System.err.println("Exception when calling BatchesApi#getBatch");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.BatchesApi;

public class BatchesApiExample {
    public static void main(String[] args) {
        BatchesApi apiInstance = new BatchesApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        Boolean download = true; // Boolean | If true, the batch's certificates will be returned as a .tag.gz file

        try {
            apiInstance.getBatch(id, download);
        } catch (ApiException e) {
            System.err.println("Exception when calling BatchesApi#getBatch");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
BatchesApi *apiInstance = [[BatchesApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
Boolean *download = true; // If true, the batch's certificates will be returned as a .tag.gz file (optional) (default to null)

// Retrieve the information for a single batch.
[apiInstance getBatchWith:id
    download:download
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var CertificateManagementPortal = require('certificate_management_portal');
var defaultClient = CertificateManagementPortal.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new CertificateManagementPortal.BatchesApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var opts = {
  'download': true // {Boolean} If true, the batch's certificates will be returned as a .tag.gz file
};

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

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

namespace Example
{
    public class getBatchExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new BatchesApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var download = true;  // Boolean | If true, the batch's certificates will be returned as a .tag.gz file (optional)  (default to null)

            try {
                // Retrieve the information for a single batch.
                apiInstance.getBatch(id, download);
            } catch (Exception e) {
                Debug.Print("Exception when calling BatchesApi.getBatch: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BatchesApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$download = true; // Boolean | If true, the batch's certificates will be returned as a .tag.gz file

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

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

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BatchesApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $download = true; # Boolean | If true, the batch's certificates will be returned as a .tag.gz file

eval {
    $api_instance->getBatch(id => $id, download => $download);
};
if ($@) {
    warn "Exception when calling BatchesApi->getBatch: $@\n";
}

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

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.BatchesApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
download = true # Boolean | If true, the batch's certificates will be returned as a .tag.gz file (optional) (default to null)

try:
    # Retrieve the information for a single batch.
    api_instance.get_batch(id, download=download)
except ApiException as e:
    print("Exception when calling BatchesApi->getBatch: %s\n" % e)

extern crate BatchesApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let download = true; // Boolean

    let mut context = BatchesApi::Context::default();
    let result = client.getBatch(id, download, &context).wait();

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

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

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

public class BatchesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        BatchesApi apiInstance = new BatchesApi();
        Long offset = 789; // Long | The numbers of items to skip, used for pagination
        Long limit = 789; // Long | The numbers of items to return, used for pagination
        String select = id1,id2,id3,id4,id5; // String | Return only the batches corresponding to the provided UUIDs.
        String entity = entity_example; // String | Return only this entity's batches

        try {
            apiInstance.getBatches(offset, limit, select, entity);
        } catch (ApiException e) {
            System.err.println("Exception when calling BatchesApi#getBatches");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.BatchesApi;

public class BatchesApiExample {
    public static void main(String[] args) {
        BatchesApi apiInstance = new BatchesApi();
        Long offset = 789; // Long | The numbers of items to skip, used for pagination
        Long limit = 789; // Long | The numbers of items to return, used for pagination
        String select = id1,id2,id3,id4,id5; // String | Return only the batches corresponding to the provided UUIDs.
        String entity = entity_example; // String | Return only this entity's batches

        try {
            apiInstance.getBatches(offset, limit, select, entity);
        } catch (ApiException e) {
            System.err.println("Exception when calling BatchesApi#getBatches");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
BatchesApi *apiInstance = [[BatchesApi alloc] init];
Long *offset = 789; // The numbers of items to skip, used for pagination (optional) (default to null)
Long *limit = 789; // The numbers of items to return, used for pagination (optional) (default to null)
String *select = id1,id2,id3,id4,id5; // Return only the batches corresponding to the provided UUIDs. (optional) (default to null)
String *entity = entity_example; // Return only this entity's batches (optional) (default to null)

// Retrieve a list of batches
[apiInstance getBatchesWith:offset
    limit:limit
    select:select
    entity:entity
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var CertificateManagementPortal = require('certificate_management_portal');
var defaultClient = CertificateManagementPortal.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new CertificateManagementPortal.BatchesApi()
var opts = {
  'offset': 789, // {Long} The numbers of items to skip, used for pagination
  'limit': 789, // {Long} The numbers of items to return, used for pagination
  'select': id1,id2,id3,id4,id5, // {String} Return only the batches corresponding to the provided UUIDs.
  'entity': entity_example // {String} Return only this entity's batches
};

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

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

namespace Example
{
    public class getBatchesExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new BatchesApi();
            var offset = 789;  // Long | The numbers of items to skip, used for pagination (optional)  (default to null)
            var limit = 789;  // Long | The numbers of items to return, used for pagination (optional)  (default to null)
            var select = id1,id2,id3,id4,id5;  // String | Return only the batches corresponding to the provided UUIDs. (optional)  (default to null)
            var entity = entity_example;  // String | Return only this entity's batches (optional)  (default to null)

            try {
                // Retrieve a list of batches
                apiInstance.getBatches(offset, limit, select, entity);
            } catch (Exception e) {
                Debug.Print("Exception when calling BatchesApi.getBatches: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BatchesApi();
$offset = 789; // Long | The numbers of items to skip, used for pagination
$limit = 789; // Long | The numbers of items to return, used for pagination
$select = id1,id2,id3,id4,id5; // String | Return only the batches corresponding to the provided UUIDs.
$entity = entity_example; // String | Return only this entity's batches

try {
    $api_instance->getBatches($offset, $limit, $select, $entity);
} catch (Exception $e) {
    echo 'Exception when calling BatchesApi->getBatches: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BatchesApi->new();
my $offset = 789; # Long | The numbers of items to skip, used for pagination
my $limit = 789; # Long | The numbers of items to return, used for pagination
my $select = id1,id2,id3,id4,id5; # String | Return only the batches corresponding to the provided UUIDs.
my $entity = entity_example; # String | Return only this entity's batches

eval {
    $api_instance->getBatches(offset => $offset, limit => $limit, select => $select, entity => $entity);
};
if ($@) {
    warn "Exception when calling BatchesApi->getBatches: $@\n";
}

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

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.BatchesApi()
offset = 789 # Long | The numbers of items to skip, used for pagination (optional) (default to null)
limit = 789 # Long | The numbers of items to return, used for pagination (optional) (default to null)
select = id1,id2,id3,id4,id5 # String | Return only the batches corresponding to the provided UUIDs. (optional) (default to null)
entity = entity_example # String | Return only this entity's batches (optional) (default to null)

try:
    # Retrieve a list of batches
    api_instance.get_batches(offset=offset, limit=limit, select=select, entity=entity)
except ApiException as e:
    print("Exception when calling BatchesApi->getBatches: %s\n" % e)

extern crate BatchesApi;

pub fn main() {
    let offset = 789; // Long
    let limit = 789; // Long
    let select = id1,id2,id3,id4,id5; // String
    let entity = entity_example; // String

    let mut context = BatchesApi::Context::default();
    let result = client.getBatches(offset, limit, select, entity, &context).wait();

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

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

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

public class BatchesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        BatchesApi apiInstance = new BatchesApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String command = command_example; // String | The command to execute on the batch
        array[String] notifyEmail = user1@example.com,user2@support.com; // array[String] | The email addresses to notify on batch operation completion, separated by commas
        array[String] notifySms = +12345678901,+122993883838,+33229948894; // array[String] | The phone numbers to notify on batch operation completion, separated by commas
        BatchEntry batchEntry = ; // BatchEntry | 

        try {
            apiInstance.updateBatch(id, command, notifyEmail, notifySms, batchEntry);
        } catch (ApiException e) {
            System.err.println("Exception when calling BatchesApi#updateBatch");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.BatchesApi;

public class BatchesApiExample {
    public static void main(String[] args) {
        BatchesApi apiInstance = new BatchesApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String command = command_example; // String | The command to execute on the batch
        array[String] notifyEmail = user1@example.com,user2@support.com; // array[String] | The email addresses to notify on batch operation completion, separated by commas
        array[String] notifySms = +12345678901,+122993883838,+33229948894; // array[String] | The phone numbers to notify on batch operation completion, separated by commas
        BatchEntry batchEntry = ; // BatchEntry | 

        try {
            apiInstance.updateBatch(id, command, notifyEmail, notifySms, batchEntry);
        } catch (ApiException e) {
            System.err.println("Exception when calling BatchesApi#updateBatch");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
BatchesApi *apiInstance = [[BatchesApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *command = command_example; // The command to execute on the batch (optional) (default to null)
array[String] *notifyEmail = user1@example.com,user2@support.com; // The email addresses to notify on batch operation completion, separated by commas (optional) (default to null)
array[String] *notifySms = +12345678901,+122993883838,+33229948894; // The phone numbers to notify on batch operation completion, separated by commas (optional) (default to null)
BatchEntry *batchEntry = ; //  (optional)

// Modify a single batch.
[apiInstance updateBatchWith:id
    command:command
    notifyEmail:notifyEmail
    notifySms:notifySms
    batchEntry:batchEntry
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var CertificateManagementPortal = require('certificate_management_portal');
var defaultClient = CertificateManagementPortal.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new CertificateManagementPortal.BatchesApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var opts = {
  'command': command_example, // {String} The command to execute on the batch
  'notifyEmail': user1@example.com,user2@support.com, // {array[String]} The email addresses to notify on batch operation completion, separated by commas
  'notifySms': +12345678901,+122993883838,+33229948894, // {array[String]} The phone numbers to notify on batch operation completion, separated by commas
  'batchEntry':  // {BatchEntry} 
};

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

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

namespace Example
{
    public class updateBatchExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new BatchesApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var command = command_example;  // String | The command to execute on the batch (optional)  (default to null)
            var notifyEmail = new array[String](); // array[String] | The email addresses to notify on batch operation completion, separated by commas (optional)  (default to null)
            var notifySms = new array[String](); // array[String] | The phone numbers to notify on batch operation completion, separated by commas (optional)  (default to null)
            var batchEntry = new BatchEntry(); // BatchEntry |  (optional) 

            try {
                // Modify a single batch.
                apiInstance.updateBatch(id, command, notifyEmail, notifySms, batchEntry);
            } catch (Exception e) {
                Debug.Print("Exception when calling BatchesApi.updateBatch: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BatchesApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$command = command_example; // String | The command to execute on the batch
$notifyEmail = user1@example.com,user2@support.com; // array[String] | The email addresses to notify on batch operation completion, separated by commas
$notifySms = +12345678901,+122993883838,+33229948894; // array[String] | The phone numbers to notify on batch operation completion, separated by commas
$batchEntry = ; // BatchEntry | 

try {
    $api_instance->updateBatch($id, $command, $notifyEmail, $notifySms, $batchEntry);
} catch (Exception $e) {
    echo 'Exception when calling BatchesApi->updateBatch: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BatchesApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $command = command_example; # String | The command to execute on the batch
my $notifyEmail = [user1@example.com,user2@support.com]; # array[String] | The email addresses to notify on batch operation completion, separated by commas
my $notifySms = [+12345678901,+122993883838,+33229948894]; # array[String] | The phone numbers to notify on batch operation completion, separated by commas
my $batchEntry = WWW::OPenAPIClient::Object::BatchEntry->new(); # BatchEntry | 

eval {
    $api_instance->updateBatch(id => $id, command => $command, notifyEmail => $notifyEmail, notifySms => $notifySms, batchEntry => $batchEntry);
};
if ($@) {
    warn "Exception when calling BatchesApi->updateBatch: $@\n";
}

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

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.BatchesApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
command = command_example # String | The command to execute on the batch (optional) (default to null)
notifyEmail = user1@example.com,user2@support.com # array[String] | The email addresses to notify on batch operation completion, separated by commas (optional) (default to null)
notifySms = +12345678901,+122993883838,+33229948894 # array[String] | The phone numbers to notify on batch operation completion, separated by commas (optional) (default to null)
batchEntry =  # BatchEntry |  (optional)

try:
    # Modify a single batch.
    api_instance.update_batch(id, command=command, notifyEmail=notifyEmail, notifySms=notifySms, batchEntry=batchEntry)
except ApiException as e:
    print("Exception when calling BatchesApi->updateBatch: %s\n" % e)

extern crate BatchesApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let command = command_example; // String
    let notifyEmail = user1@example.com,user2@support.com; // array[String]
    let notifySms = +12345678901,+122993883838,+33229948894; // array[String]
    let batchEntry = ; // BatchEntry

    let mut context = BatchesApi::Context::default();
    let result = client.updateBatch(id, command, notifyEmail, notifySms, batchEntry, &context).wait();

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

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

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

public class CertificatesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        CertificatesApi apiInstance = new CertificatesApi();
        UUID id = set to 0 when creating a certificate; // UUID | 
        String commonName = serialNumber of the device or domain name of the server; // String | 
        UUID entity = only allowed when root must create a certificate on behalf of an entity; // UUID | 
        CreateNewCertificateRequest createNewCertificateRequest = ; // CreateNewCertificateRequest | 

        try {
            apiInstance.createNewCertificate(id, commonName, entity, createNewCertificateRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificatesApi#createNewCertificate");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CertificatesApi;

public class CertificatesApiExample {
    public static void main(String[] args) {
        CertificatesApi apiInstance = new CertificatesApi();
        UUID id = set to 0 when creating a certificate; // UUID | 
        String commonName = serialNumber of the device or domain name of the server; // String | 
        UUID entity = only allowed when root must create a certificate on behalf of an entity; // UUID | 
        CreateNewCertificateRequest createNewCertificateRequest = ; // CreateNewCertificateRequest | 

        try {
            apiInstance.createNewCertificate(id, commonName, entity, createNewCertificateRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificatesApi#createNewCertificate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
CertificatesApi *apiInstance = [[CertificatesApi alloc] init];
UUID *id = set to 0 when creating a certificate; //  (default to null)
String *commonName = serialNumber of the device or domain name of the server; //  (default to null)
UUID *entity = only allowed when root must create a certificate on behalf of an entity; //  (optional) (default to null)
CreateNewCertificateRequest *createNewCertificateRequest = ; //  (optional)

// Create a single certificate
[apiInstance createNewCertificateWith:id
    commonName:commonName
    entity:entity
    createNewCertificateRequest:createNewCertificateRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var CertificateManagementPortal = require('certificate_management_portal');
var defaultClient = CertificateManagementPortal.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new CertificateManagementPortal.CertificatesApi()
var id = set to 0 when creating a certificate; // {UUID} 
var commonName = serialNumber of the device or domain name of the server; // {String} 
var opts = {
  'entity': only allowed when root must create a certificate on behalf of an entity, // {UUID} 
  'createNewCertificateRequest':  // {CreateNewCertificateRequest} 
};

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

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

namespace Example
{
    public class createNewCertificateExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new CertificatesApi();
            var id = set to 0 when creating a certificate;  // UUID |  (default to null)
            var commonName = serialNumber of the device or domain name of the server;  // String |  (default to null)
            var entity = only allowed when root must create a certificate on behalf of an entity;  // UUID |  (optional)  (default to null)
            var createNewCertificateRequest = new CreateNewCertificateRequest(); // CreateNewCertificateRequest |  (optional) 

            try {
                // Create a single certificate
                apiInstance.createNewCertificate(id, commonName, entity, createNewCertificateRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling CertificatesApi.createNewCertificate: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CertificatesApi();
$id = set to 0 when creating a certificate; // UUID | 
$commonName = serialNumber of the device or domain name of the server; // String | 
$entity = only allowed when root must create a certificate on behalf of an entity; // UUID | 
$createNewCertificateRequest = ; // CreateNewCertificateRequest | 

try {
    $api_instance->createNewCertificate($id, $commonName, $entity, $createNewCertificateRequest);
} catch (Exception $e) {
    echo 'Exception when calling CertificatesApi->createNewCertificate: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CertificatesApi->new();
my $id = set to 0 when creating a certificate; # UUID | 
my $commonName = serialNumber of the device or domain name of the server; # String | 
my $entity = only allowed when root must create a certificate on behalf of an entity; # UUID | 
my $createNewCertificateRequest = WWW::OPenAPIClient::Object::CreateNewCertificateRequest->new(); # CreateNewCertificateRequest | 

eval {
    $api_instance->createNewCertificate(id => $id, commonName => $commonName, entity => $entity, createNewCertificateRequest => $createNewCertificateRequest);
};
if ($@) {
    warn "Exception when calling CertificatesApi->createNewCertificate: $@\n";
}

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

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.CertificatesApi()
id = set to 0 when creating a certificate # UUID |  (default to null)
commonName = serialNumber of the device or domain name of the server # String |  (default to null)
entity = only allowed when root must create a certificate on behalf of an entity # UUID |  (optional) (default to null)
createNewCertificateRequest =  # CreateNewCertificateRequest |  (optional)

try:
    # Create a single certificate
    api_instance.create_new_certificate(id, commonName, entity=entity, createNewCertificateRequest=createNewCertificateRequest)
except ApiException as e:
    print("Exception when calling CertificatesApi->createNewCertificate: %s\n" % e)

extern crate CertificatesApi;

pub fn main() {
    let id = set to 0 when creating a certificate; // UUID
    let commonName = serialNumber of the device or domain name of the server; // String
    let entity = only allowed when root must create a certificate on behalf of an entity; // UUID
    let createNewCertificateRequest = ; // CreateNewCertificateRequest

    let mut context = CertificatesApi::Context::default();
    let result = client.createNewCertificate(id, commonName, entity, createNewCertificateRequest, &context).wait();

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

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

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

public class CertificatesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        CertificatesApi apiInstance = new CertificatesApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            deleteCertificate_204_response result = apiInstance.deleteCertificate(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificatesApi#deleteCertificate");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CertificatesApi;

public class CertificatesApiExample {
    public static void main(String[] args) {
        CertificatesApi apiInstance = new CertificatesApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            deleteCertificate_204_response result = apiInstance.deleteCertificate(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificatesApi#deleteCertificate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
CertificatesApi *apiInstance = [[CertificatesApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Delete a single certificate.
[apiInstance deleteCertificateWith:id
              completionHandler: ^(deleteCertificate_204_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var CertificateManagementPortal = require('certificate_management_portal');
var defaultClient = CertificateManagementPortal.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new CertificateManagementPortal.CertificatesApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

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

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

namespace Example
{
    public class deleteCertificateExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new CertificatesApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Delete a single certificate.
                deleteCertificate_204_response result = apiInstance.deleteCertificate(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CertificatesApi.deleteCertificate: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CertificatesApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

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

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CertificatesApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

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

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

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.CertificatesApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Delete a single certificate.
    api_response = api_instance.delete_certificate(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CertificatesApi->deleteCertificate: %s\n" % e)

extern crate CertificatesApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CertificatesApi::Context::default();
    let result = client.deleteCertificate(id, &context).wait();

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

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

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

public class CertificatesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        CertificatesApi apiInstance = new CertificatesApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        Boolean download = true; // Boolean | If true, the certificate's will be returned as a .tag.gz file

        try {
            apiInstance.getCertificate(id, download);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificatesApi#getCertificate");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CertificatesApi;

public class CertificatesApiExample {
    public static void main(String[] args) {
        CertificatesApi apiInstance = new CertificatesApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        Boolean download = true; // Boolean | If true, the certificate's will be returned as a .tag.gz file

        try {
            apiInstance.getCertificate(id, download);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificatesApi#getCertificate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
CertificatesApi *apiInstance = [[CertificatesApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
Boolean *download = true; // If true, the certificate's will be returned as a .tag.gz file (optional) (default to null)

// Retrieve a single certificate.
[apiInstance getCertificateWith:id
    download:download
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var CertificateManagementPortal = require('certificate_management_portal');
var defaultClient = CertificateManagementPortal.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new CertificateManagementPortal.CertificatesApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var opts = {
  'download': true // {Boolean} If true, the certificate's will be returned as a .tag.gz file
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getCertificate(id, opts, 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()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new CertificatesApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var download = true;  // Boolean | If true, the certificate's will be returned as a .tag.gz file (optional)  (default to null)

            try {
                // Retrieve a single certificate.
                apiInstance.getCertificate(id, download);
            } catch (Exception e) {
                Debug.Print("Exception when calling CertificatesApi.getCertificate: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CertificatesApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$download = true; // Boolean | If true, the certificate's will be returned as a .tag.gz file

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

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

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CertificatesApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $download = true; # Boolean | If true, the certificate's will be returned as a .tag.gz file

eval {
    $api_instance->getCertificate(id => $id, download => $download);
};
if ($@) {
    warn "Exception when calling CertificatesApi->getCertificate: $@\n";
}

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

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.CertificatesApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
download = true # Boolean | If true, the certificate's will be returned as a .tag.gz file (optional) (default to null)

try:
    # Retrieve a single certificate.
    api_instance.get_certificate(id, download=download)
except ApiException as e:
    print("Exception when calling CertificatesApi->getCertificate: %s\n" % e)

extern crate CertificatesApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let download = true; // Boolean

    let mut context = CertificatesApi::Context::default();
    let result = client.getCertificate(id, download, &context).wait();

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

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

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

public class CertificatesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        CertificatesApi apiInstance = new CertificatesApi();
        Long offset = 789; // Long | The number of items to skip before starting to collect the result set, used for pagination
        Long limit = 789; // Long | The numbers of items to return, used for pagination
        String filter = filter_example; // String | Selecting this option means the newest record will be returned. Use limit to select how many.
        String select = id1,id2,id3,id4,id5; // String | Get only the provided ids
        String type = type_example; // String | Get only certificates of this type
        UUID entity = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Get only certificates of this entity
        Boolean totalOnly = true; // Boolean | Get only the total number of records

        try {
            apiInstance.getCertificates(offset, limit, filter, select, type, entity, totalOnly);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificatesApi#getCertificates");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CertificatesApi;

public class CertificatesApiExample {
    public static void main(String[] args) {
        CertificatesApi apiInstance = new CertificatesApi();
        Long offset = 789; // Long | The number of items to skip before starting to collect the result set, used for pagination
        Long limit = 789; // Long | The numbers of items to return, used for pagination
        String filter = filter_example; // String | Selecting this option means the newest record will be returned. Use limit to select how many.
        String select = id1,id2,id3,id4,id5; // String | Get only the provided ids
        String type = type_example; // String | Get only certificates of this type
        UUID entity = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Get only certificates of this entity
        Boolean totalOnly = true; // Boolean | Get only the total number of records

        try {
            apiInstance.getCertificates(offset, limit, filter, select, type, entity, totalOnly);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificatesApi#getCertificates");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
CertificatesApi *apiInstance = [[CertificatesApi alloc] init];
Long *offset = 789; // The number of items to skip before starting to collect the result set, used for pagination (optional) (default to null)
Long *limit = 789; // The numbers of items to return, used for pagination (optional) (default to null)
String *filter = filter_example; // Selecting this option means the newest record will be returned. Use limit to select how many. (optional) (default to null)
String *select = id1,id2,id3,id4,id5; // Get only the provided ids (optional) (default to null)
String *type = type_example; // Get only certificates of this type (optional) (default to null)
UUID *entity = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Get only certificates of this entity (optional) (default to null)
Boolean *totalOnly = true; // Get only the total number of records (optional) (default to null)

// Retrieve a list of certificates.
[apiInstance getCertificatesWith:offset
    limit:limit
    filter:filter
    select:select
    type:type
    entity:entity
    totalOnly:totalOnly
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var CertificateManagementPortal = require('certificate_management_portal');
var defaultClient = CertificateManagementPortal.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new CertificateManagementPortal.CertificatesApi()
var opts = {
  'offset': 789, // {Long} The number of items to skip before starting to collect the result set, used for pagination
  'limit': 789, // {Long} The numbers of items to return, used for pagination
  'filter': filter_example, // {String} Selecting this option means the newest record will be returned. Use limit to select how many.
  'select': id1,id2,id3,id4,id5, // {String} Get only the provided ids
  'type': type_example, // {String} Get only certificates of this type
  'entity': 38400000-8cf0-11bd-b23e-10b96e4ef00d, // {UUID} Get only certificates of this entity
  'totalOnly': true // {Boolean} Get only the total number of records
};

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

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

namespace Example
{
    public class getCertificatesExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new CertificatesApi();
            var offset = 789;  // Long | The number of items to skip before starting to collect the result set, used for pagination (optional)  (default to null)
            var limit = 789;  // Long | The numbers of items to return, used for pagination (optional)  (default to null)
            var filter = filter_example;  // String | Selecting this option means the newest record will be returned. Use limit to select how many. (optional)  (default to null)
            var select = id1,id2,id3,id4,id5;  // String | Get only the provided ids (optional)  (default to null)
            var type = type_example;  // String | Get only certificates of this type (optional)  (default to null)
            var entity = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | Get only certificates of this entity (optional)  (default to null)
            var totalOnly = true;  // Boolean | Get only the total number of records (optional)  (default to null)

            try {
                // Retrieve a list of certificates.
                apiInstance.getCertificates(offset, limit, filter, select, type, entity, totalOnly);
            } catch (Exception e) {
                Debug.Print("Exception when calling CertificatesApi.getCertificates: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CertificatesApi();
$offset = 789; // Long | The number of items to skip before starting to collect the result set, used for pagination
$limit = 789; // Long | The numbers of items to return, used for pagination
$filter = filter_example; // String | Selecting this option means the newest record will be returned. Use limit to select how many.
$select = id1,id2,id3,id4,id5; // String | Get only the provided ids
$type = type_example; // String | Get only certificates of this type
$entity = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Get only certificates of this entity
$totalOnly = true; // Boolean | Get only the total number of records

try {
    $api_instance->getCertificates($offset, $limit, $filter, $select, $type, $entity, $totalOnly);
} catch (Exception $e) {
    echo 'Exception when calling CertificatesApi->getCertificates: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CertificatesApi->new();
my $offset = 789; # Long | The number of items to skip before starting to collect the result set, used for pagination
my $limit = 789; # Long | The numbers of items to return, used for pagination
my $filter = filter_example; # String | Selecting this option means the newest record will be returned. Use limit to select how many.
my $select = id1,id2,id3,id4,id5; # String | Get only the provided ids
my $type = type_example; # String | Get only certificates of this type
my $entity = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Get only certificates of this entity
my $totalOnly = true; # Boolean | Get only the total number of records

eval {
    $api_instance->getCertificates(offset => $offset, limit => $limit, filter => $filter, select => $select, type => $type, entity => $entity, totalOnly => $totalOnly);
};
if ($@) {
    warn "Exception when calling CertificatesApi->getCertificates: $@\n";
}

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

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.CertificatesApi()
offset = 789 # Long | The number of items to skip before starting to collect the result set, used for pagination (optional) (default to null)
limit = 789 # Long | The numbers of items to return, used for pagination (optional) (default to null)
filter = filter_example # String | Selecting this option means the newest record will be returned. Use limit to select how many. (optional) (default to null)
select = id1,id2,id3,id4,id5 # String | Get only the provided ids (optional) (default to null)
type = type_example # String | Get only certificates of this type (optional) (default to null)
entity = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Get only certificates of this entity (optional) (default to null)
totalOnly = true # Boolean | Get only the total number of records (optional) (default to null)

try:
    # Retrieve a list of certificates.
    api_instance.get_certificates(offset=offset, limit=limit, filter=filter, select=select, type=type, entity=entity, totalOnly=totalOnly)
except ApiException as e:
    print("Exception when calling CertificatesApi->getCertificates: %s\n" % e)

extern crate CertificatesApi;

pub fn main() {
    let offset = 789; // Long
    let limit = 789; // Long
    let filter = filter_example; // String
    let select = id1,id2,id3,id4,id5; // String
    let type = type_example; // String
    let entity = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let totalOnly = true; // Boolean

    let mut context = CertificatesApi::Context::default();
    let result = client.getCertificates(offset, limit, filter, select, type, entity, totalOnly, &context).wait();

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

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

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

public class CertificatesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        CertificatesApi apiInstance = new CertificatesApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String command = command_example; // String | Command to run on the certificate
        UUID entity = only required when root must modify a certificate on behalf of an entity; // UUID | 
        CertificateEntry certificateEntry = ; // CertificateEntry | 

        try {
            apiInstance.updateCertificate(id, command, entity, certificateEntry);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificatesApi#updateCertificate");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CertificatesApi;

public class CertificatesApiExample {
    public static void main(String[] args) {
        CertificatesApi apiInstance = new CertificatesApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String command = command_example; // String | Command to run on the certificate
        UUID entity = only required when root must modify a certificate on behalf of an entity; // UUID | 
        CertificateEntry certificateEntry = ; // CertificateEntry | 

        try {
            apiInstance.updateCertificate(id, command, entity, certificateEntry);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificatesApi#updateCertificate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
CertificatesApi *apiInstance = [[CertificatesApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *command = command_example; // Command to run on the certificate (optional) (default to null)
UUID *entity = only required when root must modify a certificate on behalf of an entity; //  (optional) (default to null)
CertificateEntry *certificateEntry = ; //  (optional)

// Modify or run a command on a single certificate.
[apiInstance updateCertificateWith:id
    command:command
    entity:entity
    certificateEntry:certificateEntry
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var CertificateManagementPortal = require('certificate_management_portal');
var defaultClient = CertificateManagementPortal.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new CertificateManagementPortal.CertificatesApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var opts = {
  'command': command_example, // {String} Command to run on the certificate
  'entity': only required when root must modify a certificate on behalf of an entity, // {UUID} 
  'certificateEntry':  // {CertificateEntry} 
};

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

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

namespace Example
{
    public class updateCertificateExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new CertificatesApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var command = command_example;  // String | Command to run on the certificate (optional)  (default to null)
            var entity = only required when root must modify a certificate on behalf of an entity;  // UUID |  (optional)  (default to null)
            var certificateEntry = new CertificateEntry(); // CertificateEntry |  (optional) 

            try {
                // Modify or run a command on a single certificate.
                apiInstance.updateCertificate(id, command, entity, certificateEntry);
            } catch (Exception e) {
                Debug.Print("Exception when calling CertificatesApi.updateCertificate: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CertificatesApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$command = command_example; // String | Command to run on the certificate
$entity = only required when root must modify a certificate on behalf of an entity; // UUID | 
$certificateEntry = ; // CertificateEntry | 

try {
    $api_instance->updateCertificate($id, $command, $entity, $certificateEntry);
} catch (Exception $e) {
    echo 'Exception when calling CertificatesApi->updateCertificate: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CertificatesApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $command = command_example; # String | Command to run on the certificate
my $entity = only required when root must modify a certificate on behalf of an entity; # UUID | 
my $certificateEntry = WWW::OPenAPIClient::Object::CertificateEntry->new(); # CertificateEntry | 

eval {
    $api_instance->updateCertificate(id => $id, command => $command, entity => $entity, certificateEntry => $certificateEntry);
};
if ($@) {
    warn "Exception when calling CertificatesApi->updateCertificate: $@\n";
}

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

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.CertificatesApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
command = command_example # String | Command to run on the certificate (optional) (default to null)
entity = only required when root must modify a certificate on behalf of an entity # UUID |  (optional) (default to null)
certificateEntry =  # CertificateEntry |  (optional)

try:
    # Modify or run a command on a single certificate.
    api_instance.update_certificate(id, command=command, entity=entity, certificateEntry=certificateEntry)
except ApiException as e:
    print("Exception when calling CertificatesApi->updateCertificate: %s\n" % e)

extern crate CertificatesApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let command = command_example; // String
    let entity = only required when root must modify a certificate on behalf of an entity; // UUID
    let certificateEntry = ; // CertificateEntry

    let mut context = CertificatesApi::Context::default();
    let result = client.updateCertificate(id, command, entity, certificateEntry, &context).wait();

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

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

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

public class EntitiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        EntitiesApi apiInstance = new EntitiesApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        EntityEntry entityEntry = ; // EntityEntry | 

        try {
            apiInstance.createEntity(id, entityEntry);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntitiesApi#createEntity");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.EntitiesApi;

public class EntitiesApiExample {
    public static void main(String[] args) {
        EntitiesApi apiInstance = new EntitiesApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        EntityEntry entityEntry = ; // EntityEntry | 

        try {
            apiInstance.createEntity(id, entityEntry);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntitiesApi#createEntity");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
EntitiesApi *apiInstance = [[EntitiesApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
EntityEntry *entityEntry = ; //  (optional)

// Create a single entity.
[apiInstance createEntityWith:id
    entityEntry:entityEntry
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var CertificateManagementPortal = require('certificate_management_portal');
var defaultClient = CertificateManagementPortal.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new CertificateManagementPortal.EntitiesApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var opts = {
  'entityEntry':  // {EntityEntry} 
};

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

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

namespace Example
{
    public class createEntityExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new EntitiesApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var entityEntry = new EntityEntry(); // EntityEntry |  (optional) 

            try {
                // Create a single entity.
                apiInstance.createEntity(id, entityEntry);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntitiesApi.createEntity: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntitiesApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$entityEntry = ; // EntityEntry | 

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

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

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntitiesApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $entityEntry = WWW::OPenAPIClient::Object::EntityEntry->new(); # EntityEntry | 

eval {
    $api_instance->createEntity(id => $id, entityEntry => $entityEntry);
};
if ($@) {
    warn "Exception when calling EntitiesApi->createEntity: $@\n";
}

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

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.EntitiesApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
entityEntry =  # EntityEntry |  (optional)

try:
    # Create a single entity.
    api_instance.create_entity(id, entityEntry=entityEntry)
except ApiException as e:
    print("Exception when calling EntitiesApi->createEntity: %s\n" % e)

extern crate EntitiesApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let entityEntry = ; // EntityEntry

    let mut context = EntitiesApi::Context::default();
    let result = client.createEntity(id, entityEntry, &context).wait();

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

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

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

public class EntitiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        EntitiesApi apiInstance = new EntitiesApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            deleteCertificate_204_response result = apiInstance.deleteEntity(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntitiesApi#deleteEntity");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.EntitiesApi;

public class EntitiesApiExample {
    public static void main(String[] args) {
        EntitiesApi apiInstance = new EntitiesApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            deleteCertificate_204_response result = apiInstance.deleteEntity(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntitiesApi#deleteEntity");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
EntitiesApi *apiInstance = [[EntitiesApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Delete a single entity.
[apiInstance deleteEntityWith:id
              completionHandler: ^(deleteCertificate_204_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var CertificateManagementPortal = require('certificate_management_portal');
var defaultClient = CertificateManagementPortal.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new CertificateManagementPortal.EntitiesApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

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

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

namespace Example
{
    public class deleteEntityExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new EntitiesApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Delete a single entity.
                deleteCertificate_204_response result = apiInstance.deleteEntity(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntitiesApi.deleteEntity: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntitiesApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

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

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntitiesApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

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

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

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.EntitiesApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Delete a single entity.
    api_response = api_instance.delete_entity(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntitiesApi->deleteEntity: %s\n" % e)

extern crate EntitiesApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = EntitiesApi::Context::default();
    let result = client.deleteEntity(id, &context).wait();

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

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

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

public class EntitiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        EntitiesApi apiInstance = new EntitiesApi();
        Long offset = 789; // Long | The numbers of items to skip, used for pagination
        Long limit = 789; // Long | The numbers of items to return, used for pagination
        String select = id1,id2,id3,id4,id5; // String | Return only the entities corresponding to the provided UUIDs.

        try {
            apiInstance.getEntities(offset, limit, select);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntitiesApi#getEntities");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.EntitiesApi;

public class EntitiesApiExample {
    public static void main(String[] args) {
        EntitiesApi apiInstance = new EntitiesApi();
        Long offset = 789; // Long | The numbers of items to skip, used for pagination
        Long limit = 789; // Long | The numbers of items to return, used for pagination
        String select = id1,id2,id3,id4,id5; // String | Return only the entities corresponding to the provided UUIDs.

        try {
            apiInstance.getEntities(offset, limit, select);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntitiesApi#getEntities");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
EntitiesApi *apiInstance = [[EntitiesApi alloc] init];
Long *offset = 789; // The numbers of items to skip, used for pagination (optional) (default to null)
Long *limit = 789; // The numbers of items to return, used for pagination (optional) (default to null)
String *select = id1,id2,id3,id4,id5; // Return only the entities corresponding to the provided UUIDs. (optional) (default to null)

// Retrieve a list of entities
[apiInstance getEntitiesWith:offset
    limit:limit
    select:select
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var CertificateManagementPortal = require('certificate_management_portal');
var defaultClient = CertificateManagementPortal.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new CertificateManagementPortal.EntitiesApi()
var opts = {
  'offset': 789, // {Long} The numbers of items to skip, used for pagination
  'limit': 789, // {Long} The numbers of items to return, used for pagination
  'select': id1,id2,id3,id4,id5 // {String} Return only the entities corresponding to the provided UUIDs.
};

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

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

namespace Example
{
    public class getEntitiesExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new EntitiesApi();
            var offset = 789;  // Long | The numbers of items to skip, used for pagination (optional)  (default to null)
            var limit = 789;  // Long | The numbers of items to return, used for pagination (optional)  (default to null)
            var select = id1,id2,id3,id4,id5;  // String | Return only the entities corresponding to the provided UUIDs. (optional)  (default to null)

            try {
                // Retrieve a list of entities
                apiInstance.getEntities(offset, limit, select);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntitiesApi.getEntities: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntitiesApi();
$offset = 789; // Long | The numbers of items to skip, used for pagination
$limit = 789; // Long | The numbers of items to return, used for pagination
$select = id1,id2,id3,id4,id5; // String | Return only the entities corresponding to the provided UUIDs.

try {
    $api_instance->getEntities($offset, $limit, $select);
} catch (Exception $e) {
    echo 'Exception when calling EntitiesApi->getEntities: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntitiesApi->new();
my $offset = 789; # Long | The numbers of items to skip, used for pagination
my $limit = 789; # Long | The numbers of items to return, used for pagination
my $select = id1,id2,id3,id4,id5; # String | Return only the entities corresponding to the provided UUIDs.

eval {
    $api_instance->getEntities(offset => $offset, limit => $limit, select => $select);
};
if ($@) {
    warn "Exception when calling EntitiesApi->getEntities: $@\n";
}

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

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.EntitiesApi()
offset = 789 # Long | The numbers of items to skip, used for pagination (optional) (default to null)
limit = 789 # Long | The numbers of items to return, used for pagination (optional) (default to null)
select = id1,id2,id3,id4,id5 # String | Return only the entities corresponding to the provided UUIDs. (optional) (default to null)

try:
    # Retrieve a list of entities
    api_instance.get_entities(offset=offset, limit=limit, select=select)
except ApiException as e:
    print("Exception when calling EntitiesApi->getEntities: %s\n" % e)

extern crate EntitiesApi;

pub fn main() {
    let offset = 789; // Long
    let limit = 789; // Long
    let select = id1,id2,id3,id4,id5; // String

    let mut context = EntitiesApi::Context::default();
    let result = client.getEntities(offset, limit, select, &context).wait();

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

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

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

public class EntitiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        EntitiesApi apiInstance = new EntitiesApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.getEntity(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntitiesApi#getEntity");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.EntitiesApi;

public class EntitiesApiExample {
    public static void main(String[] args) {
        EntitiesApi apiInstance = new EntitiesApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.getEntity(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntitiesApi#getEntity");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
EntitiesApi *apiInstance = [[EntitiesApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Retrieve an entity's information.
[apiInstance getEntityWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var CertificateManagementPortal = require('certificate_management_portal');
var defaultClient = CertificateManagementPortal.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new CertificateManagementPortal.EntitiesApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

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

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

namespace Example
{
    public class getEntityExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new EntitiesApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Retrieve an entity's information.
                apiInstance.getEntity(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntitiesApi.getEntity: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntitiesApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

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

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntitiesApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

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

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

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.EntitiesApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Retrieve an entity's information.
    api_instance.get_entity(id)
except ApiException as e:
    print("Exception when calling EntitiesApi->getEntity: %s\n" % e)

extern crate EntitiesApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = EntitiesApi::Context::default();
    let result = client.getEntity(id, &context).wait();

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

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

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

public class EntitiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        EntitiesApi apiInstance = new EntitiesApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        EntityEntry entityEntry = ; // EntityEntry | 

        try {
            apiInstance.updateEntry(id, entityEntry);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntitiesApi#updateEntry");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.EntitiesApi;

public class EntitiesApiExample {
    public static void main(String[] args) {
        EntitiesApi apiInstance = new EntitiesApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        EntityEntry entityEntry = ; // EntityEntry | 

        try {
            apiInstance.updateEntry(id, entityEntry);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntitiesApi#updateEntry");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
EntitiesApi *apiInstance = [[EntitiesApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
EntityEntry *entityEntry = ; //  (optional)

// Modify a single entity.
[apiInstance updateEntryWith:id
    entityEntry:entityEntry
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var CertificateManagementPortal = require('certificate_management_portal');
var defaultClient = CertificateManagementPortal.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new CertificateManagementPortal.EntitiesApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var opts = {
  'entityEntry':  // {EntityEntry} 
};

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

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

namespace Example
{
    public class updateEntryExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new EntitiesApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var entityEntry = new EntityEntry(); // EntityEntry |  (optional) 

            try {
                // Modify a single entity.
                apiInstance.updateEntry(id, entityEntry);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntitiesApi.updateEntry: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntitiesApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$entityEntry = ; // EntityEntry | 

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

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

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntitiesApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $entityEntry = WWW::OPenAPIClient::Object::EntityEntry->new(); # EntityEntry | 

eval {
    $api_instance->updateEntry(id => $id, entityEntry => $entityEntry);
};
if ($@) {
    warn "Exception when calling EntitiesApi->updateEntry: $@\n";
}

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

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.EntitiesApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
entityEntry =  # EntityEntry |  (optional)

try:
    # Modify a single entity.
    api_instance.update_entry(id, entityEntry=entityEntry)
except ApiException as e:
    print("Exception when calling EntitiesApi->updateEntry: %s\n" % e)

extern crate EntitiesApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let entityEntry = ; // EntityEntry

    let mut context = EntitiesApi::Context::default();
    let result = client.updateEntry(id, entityEntry, &context).wait();

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

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

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

public class JobsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        JobsApi apiInstance = new JobsApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            deleteCertificate_204_response result = apiInstance.deleteJob(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobsApi#deleteJob");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.JobsApi;

public class JobsApiExample {
    public static void main(String[] args) {
        JobsApi apiInstance = new JobsApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            deleteCertificate_204_response result = apiInstance.deleteJob(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobsApi#deleteJob");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
JobsApi *apiInstance = [[JobsApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

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

var CertificateManagementPortal = require('certificate_management_portal');
var defaultClient = CertificateManagementPortal.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new CertificateManagementPortal.JobsApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

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

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

namespace Example
{
    public class deleteJobExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new JobsApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                deleteCertificate_204_response result = apiInstance.deleteJob(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling JobsApi.deleteJob: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\JobsApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

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

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::JobsApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

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

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

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.JobsApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    api_response = api_instance.delete_job(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JobsApi->deleteJob: %s\n" % e)

extern crate JobsApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = JobsApi::Context::default();
    let result = client.deleteJob(id, &context).wait();

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

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

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

public class JobsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        JobsApi apiInstance = new JobsApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.getJob(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobsApi#getJob");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.JobsApi;

public class JobsApiExample {
    public static void main(String[] args) {
        JobsApi apiInstance = new JobsApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.getJob(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobsApi#getJob");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
JobsApi *apiInstance = [[JobsApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

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

var CertificateManagementPortal = require('certificate_management_portal');
var defaultClient = CertificateManagementPortal.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new CertificateManagementPortal.JobsApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

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

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

namespace Example
{
    public class getJobExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new JobsApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

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

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\JobsApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

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

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::JobsApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

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

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

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.JobsApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    api_instance.get_job(id)
except ApiException as e:
    print("Exception when calling JobsApi->getJob: %s\n" % e)

extern crate JobsApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = JobsApi::Context::default();
    let result = client.getJob(id, &context).wait();

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

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

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

public class JobsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        JobsApi apiInstance = new JobsApi();
        Long offset = 789; // Long | The numbers of items to skip, used for pagination
        Long limit = 789; // Long | The numbers of items to return, used for pagination
        array[UUID] select = id1,id2,id3,id4,id5; // array[UUID] | Return only the jobs corresponding to the provided UUIDs.
        UUID entity = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Return only the jobs corresponding to the provided entity.
        UUID batch = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Return only the jobs corresponding to the provided batch.

        try {
            getJobs_200_response result = apiInstance.getJobs(offset, limit, select, entity, batch);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobsApi#getJobs");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.JobsApi;

public class JobsApiExample {
    public static void main(String[] args) {
        JobsApi apiInstance = new JobsApi();
        Long offset = 789; // Long | The numbers of items to skip, used for pagination
        Long limit = 789; // Long | The numbers of items to return, used for pagination
        array[UUID] select = id1,id2,id3,id4,id5; // array[UUID] | Return only the jobs corresponding to the provided UUIDs.
        UUID entity = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Return only the jobs corresponding to the provided entity.
        UUID batch = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Return only the jobs corresponding to the provided batch.

        try {
            getJobs_200_response result = apiInstance.getJobs(offset, limit, select, entity, batch);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobsApi#getJobs");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
JobsApi *apiInstance = [[JobsApi alloc] init];
Long *offset = 789; // The numbers of items to skip, used for pagination (optional) (default to null)
Long *limit = 789; // The numbers of items to return, used for pagination (optional) (default to null)
array[UUID] *select = id1,id2,id3,id4,id5; // Return only the jobs corresponding to the provided UUIDs. (optional) (default to null)
UUID *entity = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Return only the jobs corresponding to the provided entity. (optional) (default to null)
UUID *batch = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Return only the jobs corresponding to the provided batch. (optional) (default to null)

// Retrieve the list of certificate jobs.
[apiInstance getJobsWith:offset
    limit:limit
    select:select
    entity:entity
    batch:batch
              completionHandler: ^(getJobs_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var CertificateManagementPortal = require('certificate_management_portal');
var defaultClient = CertificateManagementPortal.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new CertificateManagementPortal.JobsApi()
var opts = {
  'offset': 789, // {Long} The numbers of items to skip, used for pagination
  'limit': 789, // {Long} The numbers of items to return, used for pagination
  'select': id1,id2,id3,id4,id5, // {array[UUID]} Return only the jobs corresponding to the provided UUIDs.
  'entity': 38400000-8cf0-11bd-b23e-10b96e4ef00d, // {UUID} Return only the jobs corresponding to the provided entity.
  'batch': 38400000-8cf0-11bd-b23e-10b96e4ef00d // {UUID} Return only the jobs corresponding to the provided batch.
};

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

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

namespace Example
{
    public class getJobsExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new JobsApi();
            var offset = 789;  // Long | The numbers of items to skip, used for pagination (optional)  (default to null)
            var limit = 789;  // Long | The numbers of items to return, used for pagination (optional)  (default to null)
            var select = new array[UUID](); // array[UUID] | Return only the jobs corresponding to the provided UUIDs. (optional)  (default to null)
            var entity = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | Return only the jobs corresponding to the provided entity. (optional)  (default to null)
            var batch = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | Return only the jobs corresponding to the provided batch. (optional)  (default to null)

            try {
                // Retrieve the list of certificate jobs.
                getJobs_200_response result = apiInstance.getJobs(offset, limit, select, entity, batch);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling JobsApi.getJobs: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\JobsApi();
$offset = 789; // Long | The numbers of items to skip, used for pagination
$limit = 789; // Long | The numbers of items to return, used for pagination
$select = id1,id2,id3,id4,id5; // array[UUID] | Return only the jobs corresponding to the provided UUIDs.
$entity = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Return only the jobs corresponding to the provided entity.
$batch = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Return only the jobs corresponding to the provided batch.

try {
    $result = $api_instance->getJobs($offset, $limit, $select, $entity, $batch);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JobsApi->getJobs: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::JobsApi->new();
my $offset = 789; # Long | The numbers of items to skip, used for pagination
my $limit = 789; # Long | The numbers of items to return, used for pagination
my $select = [id1,id2,id3,id4,id5]; # array[UUID] | Return only the jobs corresponding to the provided UUIDs.
my $entity = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Return only the jobs corresponding to the provided entity.
my $batch = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Return only the jobs corresponding to the provided batch.

eval {
    my $result = $api_instance->getJobs(offset => $offset, limit => $limit, select => $select, entity => $entity, batch => $batch);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JobsApi->getJobs: $@\n";
}

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

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.JobsApi()
offset = 789 # Long | The numbers of items to skip, used for pagination (optional) (default to null)
limit = 789 # Long | The numbers of items to return, used for pagination (optional) (default to null)
select = id1,id2,id3,id4,id5 # array[UUID] | Return only the jobs corresponding to the provided UUIDs. (optional) (default to null)
entity = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Return only the jobs corresponding to the provided entity. (optional) (default to null)
batch = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Return only the jobs corresponding to the provided batch. (optional) (default to null)

try:
    # Retrieve the list of certificate jobs.
    api_response = api_instance.get_jobs(offset=offset, limit=limit, select=select, entity=entity, batch=batch)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JobsApi->getJobs: %s\n" % e)

extern crate JobsApi;

pub fn main() {
    let offset = 789; // Long
    let limit = 789; // Long
    let select = id1,id2,id3,id4,id5; // array[UUID]
    let entity = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let batch = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = JobsApi::Context::default();
    let result = client.getJobs(offset, limit, select, entity, batch, &context).wait();

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

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

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

public class TransfersApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        TransfersApi apiInstance = new TransfersApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.getTransfer(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransfersApi#getTransfer");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.TransfersApi;

public class TransfersApiExample {
    public static void main(String[] args) {
        TransfersApi apiInstance = new TransfersApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.getTransfer(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransfersApi#getTransfer");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
TransfersApi *apiInstance = [[TransfersApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get all the details of a transfer
[apiInstance getTransferWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var CertificateManagementPortal = require('certificate_management_portal');
var defaultClient = CertificateManagementPortal.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new CertificateManagementPortal.TransfersApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

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

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

namespace Example
{
    public class getTransferExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new TransfersApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get all the details of a transfer
                apiInstance.getTransfer(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling TransfersApi.getTransfer: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TransfersApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

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

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TransfersApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

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

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

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.TransfersApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get all the details of a transfer
    api_instance.get_transfer(id)
except ApiException as e:
    print("Exception when calling TransfersApi->getTransfer: %s\n" % e)

extern crate TransfersApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = TransfersApi::Context::default();
    let result = client.getTransfer(id, &context).wait();

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

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

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

public class TransfersApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        TransfersApi apiInstance = new TransfersApi();
        Integer offset = 56; // Integer | Pagination start (starts at 0. If not specified, 0 is assumed)
        Integer limit = 56; // Integer | Maximum number of entries to return (if absent, no limit is assumed)
        Long startDate = 789; // Long | return entries created after this date, can be used with endDate
        Long endDate = 789; // Long | return entries created before this date, can be used with startDate
        UUID entity = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | return entries only for this entity
        String serialNumber = serialNumber_example; // String | return entries only for this device
        Boolean inDispute = true; // Boolean | return only the transfers in dispute

        try {
            apiInstance.getTransfers(offset, limit, startDate, endDate, entity, serialNumber, inDispute);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransfersApi#getTransfers");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.TransfersApi;

public class TransfersApiExample {
    public static void main(String[] args) {
        TransfersApi apiInstance = new TransfersApi();
        Integer offset = 56; // Integer | Pagination start (starts at 0. If not specified, 0 is assumed)
        Integer limit = 56; // Integer | Maximum number of entries to return (if absent, no limit is assumed)
        Long startDate = 789; // Long | return entries created after this date, can be used with endDate
        Long endDate = 789; // Long | return entries created before this date, can be used with startDate
        UUID entity = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | return entries only for this entity
        String serialNumber = serialNumber_example; // String | return entries only for this device
        Boolean inDispute = true; // Boolean | return only the transfers in dispute

        try {
            apiInstance.getTransfers(offset, limit, startDate, endDate, entity, serialNumber, inDispute);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransfersApi#getTransfers");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
TransfersApi *apiInstance = [[TransfersApi alloc] init];
Integer *offset = 56; // Pagination start (starts at 0. If not specified, 0 is assumed) (optional) (default to null)
Integer *limit = 56; // Maximum number of entries to return (if absent, no limit is assumed) (optional) (default to null)
Long *startDate = 789; // return entries created after this date, can be used with endDate (optional) (default to null)
Long *endDate = 789; // return entries created before this date, can be used with startDate (optional) (default to null)
UUID *entity = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // return entries only for this entity (optional) (default to null)
String *serialNumber = serialNumber_example; // return entries only for this device (optional) (default to null)
Boolean *inDispute = true; // return only the transfers in dispute (optional) (default to false)

// You can request a list of current transfers for your own entity and globally
[apiInstance getTransfersWith:offset
    limit:limit
    startDate:startDate
    endDate:endDate
    entity:entity
    serialNumber:serialNumber
    inDispute:inDispute
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var CertificateManagementPortal = require('certificate_management_portal');
var defaultClient = CertificateManagementPortal.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new CertificateManagementPortal.TransfersApi()
var opts = {
  'offset': 56, // {Integer} Pagination start (starts at 0. If not specified, 0 is assumed)
  'limit': 56, // {Integer} Maximum number of entries to return (if absent, no limit is assumed)
  'startDate': 789, // {Long} return entries created after this date, can be used with endDate
  'endDate': 789, // {Long} return entries created before this date, can be used with startDate
  'entity': 38400000-8cf0-11bd-b23e-10b96e4ef00d, // {UUID} return entries only for this entity
  'serialNumber': serialNumber_example, // {String} return entries only for this device
  'inDispute': true // {Boolean} return only the transfers in dispute
};

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

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

namespace Example
{
    public class getTransfersExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new TransfersApi();
            var offset = 56;  // Integer | Pagination start (starts at 0. If not specified, 0 is assumed) (optional)  (default to null)
            var limit = 56;  // Integer | Maximum number of entries to return (if absent, no limit is assumed) (optional)  (default to null)
            var startDate = 789;  // Long | return entries created after this date, can be used with endDate (optional)  (default to null)
            var endDate = 789;  // Long | return entries created before this date, can be used with startDate (optional)  (default to null)
            var entity = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | return entries only for this entity (optional)  (default to null)
            var serialNumber = serialNumber_example;  // String | return entries only for this device (optional)  (default to null)
            var inDispute = true;  // Boolean | return only the transfers in dispute (optional)  (default to false)

            try {
                // You can request a list of current transfers for your own entity and globally
                apiInstance.getTransfers(offset, limit, startDate, endDate, entity, serialNumber, inDispute);
            } catch (Exception e) {
                Debug.Print("Exception when calling TransfersApi.getTransfers: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TransfersApi();
$offset = 56; // Integer | Pagination start (starts at 0. If not specified, 0 is assumed)
$limit = 56; // Integer | Maximum number of entries to return (if absent, no limit is assumed)
$startDate = 789; // Long | return entries created after this date, can be used with endDate
$endDate = 789; // Long | return entries created before this date, can be used with startDate
$entity = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | return entries only for this entity
$serialNumber = serialNumber_example; // String | return entries only for this device
$inDispute = true; // Boolean | return only the transfers in dispute

try {
    $api_instance->getTransfers($offset, $limit, $startDate, $endDate, $entity, $serialNumber, $inDispute);
} catch (Exception $e) {
    echo 'Exception when calling TransfersApi->getTransfers: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TransfersApi->new();
my $offset = 56; # Integer | Pagination start (starts at 0. If not specified, 0 is assumed)
my $limit = 56; # Integer | Maximum number of entries to return (if absent, no limit is assumed)
my $startDate = 789; # Long | return entries created after this date, can be used with endDate
my $endDate = 789; # Long | return entries created before this date, can be used with startDate
my $entity = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | return entries only for this entity
my $serialNumber = serialNumber_example; # String | return entries only for this device
my $inDispute = true; # Boolean | return only the transfers in dispute

eval {
    $api_instance->getTransfers(offset => $offset, limit => $limit, startDate => $startDate, endDate => $endDate, entity => $entity, serialNumber => $serialNumber, inDispute => $inDispute);
};
if ($@) {
    warn "Exception when calling TransfersApi->getTransfers: $@\n";
}

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

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.TransfersApi()
offset = 56 # Integer | Pagination start (starts at 0. If not specified, 0 is assumed) (optional) (default to null)
limit = 56 # Integer | Maximum number of entries to return (if absent, no limit is assumed) (optional) (default to null)
startDate = 789 # Long | return entries created after this date, can be used with endDate (optional) (default to null)
endDate = 789 # Long | return entries created before this date, can be used with startDate (optional) (default to null)
entity = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | return entries only for this entity (optional) (default to null)
serialNumber = serialNumber_example # String | return entries only for this device (optional) (default to null)
inDispute = true # Boolean | return only the transfers in dispute (optional) (default to false)

try:
    # You can request a list of current transfers for your own entity and globally
    api_instance.get_transfers(offset=offset, limit=limit, startDate=startDate, endDate=endDate, entity=entity, serialNumber=serialNumber, inDispute=inDispute)
except ApiException as e:
    print("Exception when calling TransfersApi->getTransfers: %s\n" % e)

extern crate TransfersApi;

pub fn main() {
    let offset = 56; // Integer
    let limit = 56; // Integer
    let startDate = 789; // Long
    let endDate = 789; // Long
    let entity = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let serialNumber = serialNumber_example; // String
    let inDispute = true; // Boolean

    let mut context = TransfersApi::Context::default();
    let result = client.getTransfers(offset, limit, startDate, endDate, entity, serialNumber, inDispute, &context).wait();

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

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

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

public class TransfersApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        TransfersApi apiInstance = new TransfersApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String operation = operation_example; // String | 
        String comment = comment_example; // String | A brief description, this is required for resolve and rollback

        try {
            apiInstance.modifyTransfer(id, operation, comment);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransfersApi#modifyTransfer");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.TransfersApi;

public class TransfersApiExample {
    public static void main(String[] args) {
        TransfersApi apiInstance = new TransfersApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String operation = operation_example; // String | 
        String comment = comment_example; // String | A brief description, this is required for resolve and rollback

        try {
            apiInstance.modifyTransfer(id, operation, comment);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransfersApi#modifyTransfer");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
TransfersApi *apiInstance = [[TransfersApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *operation = operation_example; //  (default to null)
String *comment = comment_example; // A brief description, this is required for resolve and rollback (default to null)

// Change the specified transfer
[apiInstance modifyTransferWith:id
    operation:operation
    comment:comment
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var CertificateManagementPortal = require('certificate_management_portal');
var defaultClient = CertificateManagementPortal.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new CertificateManagementPortal.TransfersApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var operation = operation_example; // {String} 
var comment = comment_example; // {String} A brief description, this is required for resolve and rollback

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

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

namespace Example
{
    public class modifyTransferExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new TransfersApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var operation = operation_example;  // String |  (default to null)
            var comment = comment_example;  // String | A brief description, this is required for resolve and rollback (default to null)

            try {
                // Change the specified transfer
                apiInstance.modifyTransfer(id, operation, comment);
            } catch (Exception e) {
                Debug.Print("Exception when calling TransfersApi.modifyTransfer: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TransfersApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$operation = operation_example; // String | 
$comment = comment_example; // String | A brief description, this is required for resolve and rollback

try {
    $api_instance->modifyTransfer($id, $operation, $comment);
} catch (Exception $e) {
    echo 'Exception when calling TransfersApi->modifyTransfer: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TransfersApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $operation = operation_example; # String | 
my $comment = comment_example; # String | A brief description, this is required for resolve and rollback

eval {
    $api_instance->modifyTransfer(id => $id, operation => $operation, comment => $comment);
};
if ($@) {
    warn "Exception when calling TransfersApi->modifyTransfer: $@\n";
}

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

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.TransfersApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
operation = operation_example # String |  (default to null)
comment = comment_example # String | A brief description, this is required for resolve and rollback (default to null)

try:
    # Change the specified transfer
    api_instance.modify_transfer(id, operation, comment)
except ApiException as e:
    print("Exception when calling TransfersApi->modifyTransfer: %s\n" % e)

extern crate TransfersApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let operation = operation_example; // String
    let comment = comment_example; // String

    let mut context = TransfersApi::Context::default();
    let result = client.modifyTransfer(id, operation, comment, &context).wait();

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

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

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

public class TransfersApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");
        
        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        TransfersApi apiInstance = new TransfersApi();
        String serialNumber = FC00991ABCDF; // String | 
        Boolean cancel = true; // Boolean | If you would like to cancel a previously filed transfer. This would be used if the transfer was filed in error.
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | The transfer UUID you wish to cancel. This must be the UUID of the transfer you wish to cancel done on the provided serial number
        TransferCertificateRequest transferCertificateRequest = ; // TransferCertificateRequest | 

        try {
            apiInstance.transferCertificate(serialNumber, cancel, id, transferCertificateRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransfersApi#transferCertificate");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.TransfersApi;

public class TransfersApiExample {
    public static void main(String[] args) {
        TransfersApi apiInstance = new TransfersApi();
        String serialNumber = FC00991ABCDF; // String | 
        Boolean cancel = true; // Boolean | If you would like to cancel a previously filed transfer. This would be used if the transfer was filed in error.
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | The transfer UUID you wish to cancel. This must be the UUID of the transfer you wish to cancel done on the provided serial number
        TransferCertificateRequest transferCertificateRequest = ; // TransferCertificateRequest | 

        try {
            apiInstance.transferCertificate(serialNumber, cancel, id, transferCertificateRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransfersApi#transferCertificate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-KEY"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-KEY"];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
TransfersApi *apiInstance = [[TransfersApi alloc] init];
String *serialNumber = FC00991ABCDF; //  (default to null)
Boolean *cancel = true; // If you would like to cancel a previously filed transfer. This would be used if the transfer was filed in error. (optional) (default to null)
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // The transfer UUID you wish to cancel. This must be the UUID of the transfer you wish to cancel done on the provided serial number (optional) (default to null)
TransferCertificateRequest *transferCertificateRequest = ; //  (optional)

// Use this API to transfer a another entity's device certificate to your own entity with a new redirector.
[apiInstance transferCertificateWith:serialNumber
    cancel:cancel
    id:id
    transferCertificateRequest:transferCertificateRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var CertificateManagementPortal = require('certificate_management_portal');
var defaultClient = CertificateManagementPortal.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-KEY'] = "Token";

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new CertificateManagementPortal.TransfersApi()
var serialNumber = FC00991ABCDF; // {String} 
var opts = {
  'cancel': true, // {Boolean} If you would like to cancel a previously filed transfer. This would be used if the transfer was filed in error.
  'id': 38400000-8cf0-11bd-b23e-10b96e4ef00d, // {UUID} The transfer UUID you wish to cancel. This must be the UUID of the transfer you wish to cancel done on the provided serial number
  'transferCertificateRequest':  // {TransferCertificateRequest} 
};

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

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

namespace Example
{
    public class transferCertificateExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-KEY", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-KEY", "Bearer");
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new TransfersApi();
            var serialNumber = FC00991ABCDF;  // String |  (default to null)
            var cancel = true;  // Boolean | If you would like to cancel a previously filed transfer. This would be used if the transfer was filed in error. (optional)  (default to null)
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | The transfer UUID you wish to cancel. This must be the UUID of the transfer you wish to cancel done on the provided serial number (optional)  (default to null)
            var transferCertificateRequest = new TransferCertificateRequest(); // TransferCertificateRequest |  (optional) 

            try {
                // Use this API to transfer a another entity's device certificate to your own entity with a new redirector.
                apiInstance.transferCertificate(serialNumber, cancel, id, transferCertificateRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling TransfersApi.transferCertificate: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-KEY', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-KEY', 'Bearer');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TransfersApi();
$serialNumber = FC00991ABCDF; // String | 
$cancel = true; // Boolean | If you would like to cancel a previously filed transfer. This would be used if the transfer was filed in error.
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | The transfer UUID you wish to cancel. This must be the UUID of the transfer you wish to cancel done on the provided serial number
$transferCertificateRequest = ; // TransferCertificateRequest | 

try {
    $api_instance->transferCertificate($serialNumber, $cancel, $id, $transferCertificateRequest);
} catch (Exception $e) {
    echo 'Exception when calling TransfersApi->transferCertificate: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-KEY'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-KEY'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TransfersApi->new();
my $serialNumber = FC00991ABCDF; # String | 
my $cancel = true; # Boolean | If you would like to cancel a previously filed transfer. This would be used if the transfer was filed in error.
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | The transfer UUID you wish to cancel. This must be the UUID of the transfer you wish to cancel done on the provided serial number
my $transferCertificateRequest = WWW::OPenAPIClient::Object::TransferCertificateRequest->new(); # TransferCertificateRequest | 

eval {
    $api_instance->transferCertificate(serialNumber => $serialNumber, cancel => $cancel, id => $id, transferCertificateRequest => $transferCertificateRequest);
};
if ($@) {
    warn "Exception when calling TransfersApi->transferCertificate: $@\n";
}

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

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-KEY'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-KEY'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.TransfersApi()
serialNumber = FC00991ABCDF # String |  (default to null)
cancel = true # Boolean | If you would like to cancel a previously filed transfer. This would be used if the transfer was filed in error. (optional) (default to null)
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | The transfer UUID you wish to cancel. This must be the UUID of the transfer you wish to cancel done on the provided serial number (optional) (default to null)
transferCertificateRequest =  # TransferCertificateRequest |  (optional)

try:
    # Use this API to transfer a another entity's device certificate to your own entity with a new redirector.
    api_instance.transfer_certificate(serialNumber, cancel=cancel, id=id, transferCertificateRequest=transferCertificateRequest)
except ApiException as e:
    print("Exception when calling TransfersApi->transferCertificate: %s\n" % e)

extern crate TransfersApi;

pub fn main() {
    let serialNumber = FC00991ABCDF; // String
    let cancel = true; // Boolean
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let transferCertificateRequest = ; // TransferCertificateRequest

    let mut context = TransfersApi::Context::default();
    let result = client.transferCertificate(serialNumber, cancel, id, transferCertificateRequest, &context).wait();

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