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

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

public class AccountProvisioningServiceApiExample {

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

import io.swagger.client.api.AccountProvisioningServiceApi;

public class AccountProvisioningServiceApiExample {

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

V1CreateAccountsRequest *body = ; // 

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

// No longer supported since version 2.7.
[apiInstance accountProvisioningServiceCreateAccountsWith:body
              completionHandler: ^(v1CreateAccountsResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.AccountProvisioningServiceApi()

var body = ; // {V1CreateAccountsRequest} 


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

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

namespace Example
{
    public class accountProvisioningServiceCreateAccountsExample
    {
        public void main()
        {
            
            var apiInstance = new AccountProvisioningServiceApi();
            var body = new V1CreateAccountsRequest(); // V1CreateAccountsRequest | 

            try
            {
                // No longer supported since version 2.7.
                v1CreateAccountsResponse result = apiInstance.accountProvisioningServiceCreateAccounts(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountProvisioningServiceApi.accountProvisioningServiceCreateAccounts: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AccountProvisioningServiceApi();
$body = ; // V1CreateAccountsRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.AccountProvisioningServiceApi()
body =  # V1CreateAccountsRequest | 

try: 
    # No longer supported since version 2.7.
    api_response = api_instance.account_provisioning_service_create_accounts(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountProvisioningServiceApi->accountProvisioningServiceCreateAccounts: %s\n" % e)

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

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

public class AccountProvisioningServiceApiExample {

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

import io.swagger.client.api.AccountProvisioningServiceApi;

public class AccountProvisioningServiceApiExample {

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

V1UpdateAccountStatusesRequest *body = ; // 

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

// No longer supported since version 2.7.
[apiInstance accountProvisioningServiceUpdateAccountStatusesWith:body
              completionHandler: ^(v1UpdateAccountStatusesResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.AccountProvisioningServiceApi()

var body = ; // {V1UpdateAccountStatusesRequest} 


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

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

namespace Example
{
    public class accountProvisioningServiceUpdateAccountStatusesExample
    {
        public void main()
        {
            
            var apiInstance = new AccountProvisioningServiceApi();
            var body = new V1UpdateAccountStatusesRequest(); // V1UpdateAccountStatusesRequest | 

            try
            {
                // No longer supported since version 2.7.
                v1UpdateAccountStatusesResponse result = apiInstance.accountProvisioningServiceUpdateAccountStatuses(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountProvisioningServiceApi.accountProvisioningServiceUpdateAccountStatuses: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AccountProvisioningServiceApi();
$body = ; // V1UpdateAccountStatusesRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.AccountProvisioningServiceApi()
body =  # V1UpdateAccountStatusesRequest | 

try: 
    # No longer supported since version 2.7.
    api_response = api_instance.account_provisioning_service_update_account_statuses(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountProvisioningServiceApi->accountProvisioningServiceUpdateAccountStatuses: %s\n" % e)

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

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

public class AccountServiceApiExample {

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

import io.swagger.client.api.AccountServiceApi;

public class AccountServiceApiExample {

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

V1ListAccountsRequest *body = ; // 

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

// No longer supported since version 2.7.
[apiInstance accountServiceListAccountsWith:body
              completionHandler: ^(v1ListAccountsResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.AccountServiceApi()

var body = ; // {V1ListAccountsRequest} 


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

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

namespace Example
{
    public class accountServiceListAccountsExample
    {
        public void main()
        {
            
            var apiInstance = new AccountServiceApi();
            var body = new V1ListAccountsRequest(); // V1ListAccountsRequest | 

            try
            {
                // No longer supported since version 2.7.
                v1ListAccountsResponse result = apiInstance.accountServiceListAccounts(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountServiceApi.accountServiceListAccounts: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AccountServiceApi();
$body = ; // V1ListAccountsRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.AccountServiceApi()
body =  # V1ListAccountsRequest | 

try: 
    # No longer supported since version 2.7.
    api_response = api_instance.account_service_list_accounts(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountServiceApi->accountServiceListAccounts: %s\n" % e)

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

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

public class AccountServiceApiExample {

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

import io.swagger.client.api.AccountServiceApi;

public class AccountServiceApiExample {

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

V1UpdateAccountsRequest *body = ; // 

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

// No longer supported since version 2.7.
[apiInstance accountServiceUpdateAccountsWith:body
              completionHandler: ^(v1UpdateAccountsResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.AccountServiceApi()

var body = ; // {V1UpdateAccountsRequest} 


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

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

namespace Example
{
    public class accountServiceUpdateAccountsExample
    {
        public void main()
        {
            
            var apiInstance = new AccountServiceApi();
            var body = new V1UpdateAccountsRequest(); // V1UpdateAccountsRequest | 

            try
            {
                // No longer supported since version 2.7.
                v1UpdateAccountsResponse result = apiInstance.accountServiceUpdateAccounts(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountServiceApi.accountServiceUpdateAccounts: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AccountServiceApi();
$body = ; // V1UpdateAccountsRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.AccountServiceApi()
body =  # V1UpdateAccountsRequest | 

try: 
    # No longer supported since version 2.7.
    api_response = api_instance.account_service_update_accounts(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountServiceApi->accountServiceUpdateAccounts: %s\n" % e)

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

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

public class AccountUsersServiceApiExample {

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

import io.swagger.client.api.AccountUsersServiceApi;

public class AccountUsersServiceApiExample {

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

V1AddUsersRequest *body = ; // 

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

// * Add users uses email to create or look up a user and add them to the specified
account. As of version 2.7, it no longer creates inactive users.
[apiInstance accountUsersServiceAddUsersWith:body
              completionHandler: ^(v1AddUsersResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.AccountUsersServiceApi()

var body = ; // {V1AddUsersRequest} 


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

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

namespace Example
{
    public class accountUsersServiceAddUsersExample
    {
        public void main()
        {
            
            var apiInstance = new AccountUsersServiceApi();
            var body = new V1AddUsersRequest(); // V1AddUsersRequest | 

            try
            {
                // * Add users uses email to create or look up a user and add them to the specified
account. As of version 2.7, it no longer creates inactive users.
                v1AddUsersResponse result = apiInstance.accountUsersServiceAddUsers(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountUsersServiceApi.accountUsersServiceAddUsers: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AccountUsersServiceApi();
$body = ; // V1AddUsersRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.AccountUsersServiceApi()
body =  # V1AddUsersRequest | 

try: 
    # * Add users uses email to create or look up a user and add them to the specified
account. As of version 2.7, it no longer creates inactive users.
    api_response = api_instance.account_users_service_add_users(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountUsersServiceApi->accountUsersServiceAddUsers: %s\n" % e)

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

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

public class AccountUsersServiceApiExample {

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

import io.swagger.client.api.AccountUsersServiceApi;

public class AccountUsersServiceApiExample {

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

V1ListUsersRequest *body = ; // 

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

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

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.AccountUsersServiceApi()

var body = ; // {V1ListUsersRequest} 


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

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

namespace Example
{
    public class accountUsersServiceListUsersExample
    {
        public void main()
        {
            
            var apiInstance = new AccountUsersServiceApi();
            var body = new V1ListUsersRequest(); // V1ListUsersRequest | 

            try
            {
                v1ListUsersResponse result = apiInstance.accountUsersServiceListUsers(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountUsersServiceApi.accountUsersServiceListUsers: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AccountUsersServiceApi();
$body = ; // V1ListUsersRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.AccountUsersServiceApi()
body =  # V1ListUsersRequest | 

try: 
    api_response = api_instance.account_users_service_list_users(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountUsersServiceApi->accountUsersServiceListUsers: %s\n" % e)

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

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

public class AccountUsersServiceApiExample {

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

import io.swagger.client.api.AccountUsersServiceApi;

public class AccountUsersServiceApiExample {

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

V1UpdateUserStatusesRequest *body = ; // 

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

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

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.AccountUsersServiceApi()

var body = ; // {V1UpdateUserStatusesRequest} 


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

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

namespace Example
{
    public class accountUsersServiceUpdateUserStatusesExample
    {
        public void main()
        {
            
            var apiInstance = new AccountUsersServiceApi();
            var body = new V1UpdateUserStatusesRequest(); // V1UpdateUserStatusesRequest | 

            try
            {
                v1UpdateUserStatusesResponse result = apiInstance.accountUsersServiceUpdateUserStatuses(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountUsersServiceApi.accountUsersServiceUpdateUserStatuses: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AccountUsersServiceApi();
$body = ; // V1UpdateUserStatusesRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.AccountUsersServiceApi()
body =  # V1UpdateUserStatusesRequest | 

try: 
    api_response = api_instance.account_users_service_update_user_statuses(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountUsersServiceApi->accountUsersServiceUpdateUserStatuses: %s\n" % e)

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

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

public class AccountUsersServiceApiExample {

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

import io.swagger.client.api.AccountUsersServiceApi;

public class AccountUsersServiceApiExample {

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

V1UpdateUsersRequest *body = ; // 

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

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

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.AccountUsersServiceApi()

var body = ; // {V1UpdateUsersRequest} 


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

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

namespace Example
{
    public class accountUsersServiceUpdateUsersExample
    {
        public void main()
        {
            
            var apiInstance = new AccountUsersServiceApi();
            var body = new V1UpdateUsersRequest(); // V1UpdateUsersRequest | 

            try
            {
                v1UpdateUsersResponse result = apiInstance.accountUsersServiceUpdateUsers(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountUsersServiceApi.accountUsersServiceUpdateUsers: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AccountUsersServiceApi();
$body = ; // V1UpdateUsersRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.AccountUsersServiceApi()
body =  # V1UpdateUsersRequest | 

try: 
    api_response = api_instance.account_users_service_update_users(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountUsersServiceApi->accountUsersServiceUpdateUsers: %s\n" % e)

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

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

public class AssetServiceApiExample {

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

import io.swagger.client.api.AssetServiceApi;

public class AssetServiceApiExample {

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

V1AddAssetPhotoRequest *body = ; // 

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

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

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.AssetServiceApi()

var body = ; // {V1AddAssetPhotoRequest} 


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

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

namespace Example
{
    public class assetServiceAddAssetPhotoExample
    {
        public void main()
        {
            
            var apiInstance = new AssetServiceApi();
            var body = new V1AddAssetPhotoRequest(); // V1AddAssetPhotoRequest | 

            try
            {
                v1AddAssetPhotoResponse result = apiInstance.assetServiceAddAssetPhoto(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetServiceApi.assetServiceAddAssetPhoto: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AssetServiceApi();
$body = ; // V1AddAssetPhotoRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.AssetServiceApi()
body =  # V1AddAssetPhotoRequest | 

try: 
    api_response = api_instance.asset_service_add_asset_photo(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetServiceApi->assetServiceAddAssetPhoto: %s\n" % e)

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

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

public class AssetServiceApiExample {

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

import io.swagger.client.api.AssetServiceApi;

public class AssetServiceApiExample {

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

V1SetAssetsArchivedRequest *body = ; // 

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

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

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.AssetServiceApi()

var body = ; // {V1SetAssetsArchivedRequest} 


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

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

namespace Example
{
    public class assetServiceArchiveAssetsExample
    {
        public void main()
        {
            
            var apiInstance = new AssetServiceApi();
            var body = new V1SetAssetsArchivedRequest(); // V1SetAssetsArchivedRequest | 

            try
            {
                v1SetAssetsArchivedResponse result = apiInstance.assetServiceArchiveAssets(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetServiceApi.assetServiceArchiveAssets: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AssetServiceApi();
$body = ; // V1SetAssetsArchivedRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.AssetServiceApi()
body =  # V1SetAssetsArchivedRequest | 

try: 
    api_response = api_instance.asset_service_archive_assets(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetServiceApi->assetServiceArchiveAssets: %s\n" % e)

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

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

public class AssetServiceApiExample {

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

import io.swagger.client.api.AssetServiceApi;

public class AssetServiceApiExample {

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

V1CreateAssetsRequest *body = ; // 

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

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

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.AssetServiceApi()

var body = ; // {V1CreateAssetsRequest} 


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

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

namespace Example
{
    public class assetServiceCreateAssetsExample
    {
        public void main()
        {
            
            var apiInstance = new AssetServiceApi();
            var body = new V1CreateAssetsRequest(); // V1CreateAssetsRequest | 

            try
            {
                v1CreateAssetsResponse result = apiInstance.assetServiceCreateAssets(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetServiceApi.assetServiceCreateAssets: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AssetServiceApi();
$body = ; // V1CreateAssetsRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.AssetServiceApi()
body =  # V1CreateAssetsRequest | 

try: 
    api_response = api_instance.asset_service_create_assets(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetServiceApi->assetServiceCreateAssets: %s\n" % e)

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

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

public class AssetServiceApiExample {

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

import io.swagger.client.api.AssetServiceApi;

public class AssetServiceApiExample {

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

V1ListAssetsRequest *body = ; // 

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

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

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.AssetServiceApi()

var body = ; // {V1ListAssetsRequest} 


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

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

namespace Example
{
    public class assetServiceListAssetsExample
    {
        public void main()
        {
            
            var apiInstance = new AssetServiceApi();
            var body = new V1ListAssetsRequest(); // V1ListAssetsRequest | 

            try
            {
                v1ListAssetsResponse result = apiInstance.assetServiceListAssets(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetServiceApi.assetServiceListAssets: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AssetServiceApi();
$body = ; // V1ListAssetsRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.AssetServiceApi()
body =  # V1ListAssetsRequest | 

try: 
    api_response = api_instance.asset_service_list_assets(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetServiceApi->assetServiceListAssets: %s\n" % e)

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

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

public class AssetServiceApiExample {

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

import io.swagger.client.api.AssetServiceApi;

public class AssetServiceApiExample {

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

V1SetAssetsArchivedRequest *body = ; // 

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

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

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.AssetServiceApi()

var body = ; // {V1SetAssetsArchivedRequest} 


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

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

namespace Example
{
    public class assetServiceUnarchiveAssetsExample
    {
        public void main()
        {
            
            var apiInstance = new AssetServiceApi();
            var body = new V1SetAssetsArchivedRequest(); // V1SetAssetsArchivedRequest | 

            try
            {
                v1SetAssetsArchivedResponse result = apiInstance.assetServiceUnarchiveAssets(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetServiceApi.assetServiceUnarchiveAssets: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AssetServiceApi();
$body = ; // V1SetAssetsArchivedRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.AssetServiceApi()
body =  # V1SetAssetsArchivedRequest | 

try: 
    api_response = api_instance.asset_service_unarchive_assets(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetServiceApi->assetServiceUnarchiveAssets: %s\n" % e)

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

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

public class AssetServiceApiExample {

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

import io.swagger.client.api.AssetServiceApi;

public class AssetServiceApiExample {

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

V1UpdateAssetsRequest *body = ; // 

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

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

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.AssetServiceApi()

var body = ; // {V1UpdateAssetsRequest} 


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

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

namespace Example
{
    public class assetServiceUpdateAssetsExample
    {
        public void main()
        {
            
            var apiInstance = new AssetServiceApi();
            var body = new V1UpdateAssetsRequest(); // V1UpdateAssetsRequest | 

            try
            {
                v1UpdateAssetsResponse result = apiInstance.assetServiceUpdateAssets(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetServiceApi.assetServiceUpdateAssets: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AssetServiceApi();
$body = ; // V1UpdateAssetsRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.AssetServiceApi()
body =  # V1UpdateAssetsRequest | 

try: 
    api_response = api_instance.asset_service_update_assets(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetServiceApi->assetServiceUpdateAssets: %s\n" % e)

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

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

public class FolderServiceApiExample {

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

import io.swagger.client.api.FolderServiceApi;

public class FolderServiceApiExample {

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

V1CreateFoldersRequest *body = ; // 

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

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

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.FolderServiceApi()

var body = ; // {V1CreateFoldersRequest} 


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

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

namespace Example
{
    public class folderServiceCreateFoldersExample
    {
        public void main()
        {
            
            var apiInstance = new FolderServiceApi();
            var body = new V1CreateFoldersRequest(); // V1CreateFoldersRequest | 

            try
            {
                v1CreateFoldersResponse result = apiInstance.folderServiceCreateFolders(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FolderServiceApi.folderServiceCreateFolders: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\FolderServiceApi();
$body = ; // V1CreateFoldersRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.FolderServiceApi()
body =  # V1CreateFoldersRequest | 

try: 
    api_response = api_instance.folder_service_create_folders(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FolderServiceApi->folderServiceCreateFolders: %s\n" % e)

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

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

public class FolderServiceApiExample {

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

import io.swagger.client.api.FolderServiceApi;

public class FolderServiceApiExample {

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

V1ListFoldersRequest *body = ; // 

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

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

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.FolderServiceApi()

var body = ; // {V1ListFoldersRequest} 


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

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

namespace Example
{
    public class folderServiceListFoldersExample
    {
        public void main()
        {
            
            var apiInstance = new FolderServiceApi();
            var body = new V1ListFoldersRequest(); // V1ListFoldersRequest | 

            try
            {
                v1ListFoldersResponse result = apiInstance.folderServiceListFolders(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FolderServiceApi.folderServiceListFolders: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\FolderServiceApi();
$body = ; // V1ListFoldersRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.FolderServiceApi()
body =  # V1ListFoldersRequest | 

try: 
    api_response = api_instance.folder_service_list_folders(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FolderServiceApi->folderServiceListFolders: %s\n" % e)

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

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

public class FolderServiceApiExample {

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

import io.swagger.client.api.FolderServiceApi;

public class FolderServiceApiExample {

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

V1UpdateFolderStatusesRequest *body = ; // 

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

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

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.FolderServiceApi()

var body = ; // {V1UpdateFolderStatusesRequest} 


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

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

namespace Example
{
    public class folderServiceUpdateFolderStatusesExample
    {
        public void main()
        {
            
            var apiInstance = new FolderServiceApi();
            var body = new V1UpdateFolderStatusesRequest(); // V1UpdateFolderStatusesRequest | 

            try
            {
                v1UpdateFolderStatusesResponse result = apiInstance.folderServiceUpdateFolderStatuses(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FolderServiceApi.folderServiceUpdateFolderStatuses: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\FolderServiceApi();
$body = ; // V1UpdateFolderStatusesRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.FolderServiceApi()
body =  # V1UpdateFolderStatusesRequest | 

try: 
    api_response = api_instance.folder_service_update_folder_statuses(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FolderServiceApi->folderServiceUpdateFolderStatuses: %s\n" % e)

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

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

public class FolderServiceApiExample {

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

import io.swagger.client.api.FolderServiceApi;

public class FolderServiceApiExample {

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

V1UpdateFoldersRequest *body = ; // 

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

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

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.FolderServiceApi()

var body = ; // {V1UpdateFoldersRequest} 


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

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

namespace Example
{
    public class folderServiceUpdateFoldersExample
    {
        public void main()
        {
            
            var apiInstance = new FolderServiceApi();
            var body = new V1UpdateFoldersRequest(); // V1UpdateFoldersRequest | 

            try
            {
                v1UpdateFoldersResponse result = apiInstance.folderServiceUpdateFolders(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FolderServiceApi.folderServiceUpdateFolders: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\FolderServiceApi();
$body = ; // V1UpdateFoldersRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.FolderServiceApi()
body =  # V1UpdateFoldersRequest | 

try: 
    api_response = api_instance.folder_service_update_folders(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FolderServiceApi->folderServiceUpdateFolders: %s\n" % e)

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

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

public class InspectionServiceApiExample {

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

import io.swagger.client.api.InspectionServiceApi;

public class InspectionServiceApiExample {

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

V1AddInspectionPhotosRequest *body = ; // 

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

// * No longer supported since 2.6.
[apiInstance inspectionServiceAddInspectionPhotosWith:body
              completionHandler: ^(v1AddInspectionPhotosResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.InspectionServiceApi()

var body = ; // {V1AddInspectionPhotosRequest} 


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

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

namespace Example
{
    public class inspectionServiceAddInspectionPhotosExample
    {
        public void main()
        {
            
            var apiInstance = new InspectionServiceApi();
            var body = new V1AddInspectionPhotosRequest(); // V1AddInspectionPhotosRequest | 

            try
            {
                // * No longer supported since 2.6.
                v1AddInspectionPhotosResponse result = apiInstance.inspectionServiceAddInspectionPhotos(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling InspectionServiceApi.inspectionServiceAddInspectionPhotos: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\InspectionServiceApi();
$body = ; // V1AddInspectionPhotosRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.InspectionServiceApi()
body =  # V1AddInspectionPhotosRequest | 

try: 
    # * No longer supported since 2.6.
    api_response = api_instance.inspection_service_add_inspection_photos(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling InspectionServiceApi->inspectionServiceAddInspectionPhotos: %s\n" % e)

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

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

public class InspectionServiceApiExample {

    public static void main(String[] args) {
        
        InspectionServiceApi apiInstance = new InspectionServiceApi();
        V1SetInspectionsArchivedRequest body = ; // V1SetInspectionsArchivedRequest | * SetInspectionsArchivedRequest is used to archive and unarchive  multiple inspections.
        try {
            v1SetInspectionsArchivedResponse result = apiInstance.inspectionServiceArchiveInspections(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InspectionServiceApi#inspectionServiceArchiveInspections");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.InspectionServiceApi;

public class InspectionServiceApiExample {

    public static void main(String[] args) {
        InspectionServiceApi apiInstance = new InspectionServiceApi();
        V1SetInspectionsArchivedRequest body = ; // V1SetInspectionsArchivedRequest | * SetInspectionsArchivedRequest is used to archive and unarchive  multiple inspections.
        try {
            v1SetInspectionsArchivedResponse result = apiInstance.inspectionServiceArchiveInspections(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InspectionServiceApi#inspectionServiceArchiveInspections");
            e.printStackTrace();
        }
    }
}

V1SetInspectionsArchivedRequest *body = ; // * SetInspectionsArchivedRequest is used to archive and unarchive  multiple inspections.

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

// * Archive inspections should be used to archive inspections that are no
longer wanted. No method for purging archived inspections is
available via the API. All inspections must belong to the same folder.
[apiInstance inspectionServiceArchiveInspectionsWith:body
              completionHandler: ^(v1SetInspectionsArchivedResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.InspectionServiceApi()

var body = ; // {V1SetInspectionsArchivedRequest} * SetInspectionsArchivedRequest is used to archive and unarchive  multiple inspections.


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

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

namespace Example
{
    public class inspectionServiceArchiveInspectionsExample
    {
        public void main()
        {
            
            var apiInstance = new InspectionServiceApi();
            var body = new V1SetInspectionsArchivedRequest(); // V1SetInspectionsArchivedRequest | * SetInspectionsArchivedRequest is used to archive and unarchive  multiple inspections.

            try
            {
                // * Archive inspections should be used to archive inspections that are no
longer wanted. No method for purging archived inspections is
available via the API. All inspections must belong to the same folder.
                v1SetInspectionsArchivedResponse result = apiInstance.inspectionServiceArchiveInspections(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling InspectionServiceApi.inspectionServiceArchiveInspections: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\InspectionServiceApi();
$body = ; // V1SetInspectionsArchivedRequest | * SetInspectionsArchivedRequest is used to archive and unarchive  multiple inspections.

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

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

my $api_instance = WWW::SwaggerClient::InspectionServiceApi->new();
my $body = WWW::SwaggerClient::Object::V1SetInspectionsArchivedRequest->new(); # V1SetInspectionsArchivedRequest | * SetInspectionsArchivedRequest is used to archive and unarchive  multiple inspections.

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

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

# create an instance of the API class
api_instance = swagger_client.InspectionServiceApi()
body =  # V1SetInspectionsArchivedRequest | * SetInspectionsArchivedRequest is used to archive and unarchive  multiple inspections.

try: 
    # * Archive inspections should be used to archive inspections that are no
longer wanted. No method for purging archived inspections is
available via the API. All inspections must belong to the same folder.
    api_response = api_instance.inspection_service_archive_inspections(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling InspectionServiceApi->inspectionServiceArchiveInspections: %s\n" % e)

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

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

public class InspectionServiceApiExample {

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

import io.swagger.client.api.InspectionServiceApi;

public class InspectionServiceApiExample {

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

V1CreateDelegatedInspectionLinksRequest *body = ; // 

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

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

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.InspectionServiceApi()

var body = ; // {V1CreateDelegatedInspectionLinksRequest} 


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

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

namespace Example
{
    public class inspectionServiceCreateDelegatedInspectionLinksExample
    {
        public void main()
        {
            
            var apiInstance = new InspectionServiceApi();
            var body = new V1CreateDelegatedInspectionLinksRequest(); // V1CreateDelegatedInspectionLinksRequest | 

            try
            {
                v1CreateDelegatedInspectionLinksResponse result = apiInstance.inspectionServiceCreateDelegatedInspectionLinks(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling InspectionServiceApi.inspectionServiceCreateDelegatedInspectionLinks: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\InspectionServiceApi();
$body = ; // V1CreateDelegatedInspectionLinksRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.InspectionServiceApi()
body =  # V1CreateDelegatedInspectionLinksRequest | 

try: 
    api_response = api_instance.inspection_service_create_delegated_inspection_links(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling InspectionServiceApi->inspectionServiceCreateDelegatedInspectionLinks: %s\n" % e)

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

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

public class InspectionServiceApiExample {

    public static void main(String[] args) {
        
        InspectionServiceApi apiInstance = new InspectionServiceApi();
        V1CreateInspectionsRequest body = ; // V1CreateInspectionsRequest | * Create Inspection request can be used to create new valid scheduled, in
progress or completed inspections. Two inspections cannot have the same
external ID and all must be valid for the request to complete. This includes
archived inspection IDs.
        try {
            v1CreateInspectionsResponse result = apiInstance.inspectionServiceCreateInspections(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InspectionServiceApi#inspectionServiceCreateInspections");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.InspectionServiceApi;

public class InspectionServiceApiExample {

    public static void main(String[] args) {
        InspectionServiceApi apiInstance = new InspectionServiceApi();
        V1CreateInspectionsRequest body = ; // V1CreateInspectionsRequest | * Create Inspection request can be used to create new valid scheduled, in
progress or completed inspections. Two inspections cannot have the same
external ID and all must be valid for the request to complete. This includes
archived inspection IDs.
        try {
            v1CreateInspectionsResponse result = apiInstance.inspectionServiceCreateInspections(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InspectionServiceApi#inspectionServiceCreateInspections");
            e.printStackTrace();
        }
    }
}

V1CreateInspectionsRequest *body = ; // * Create Inspection request can be used to create new valid scheduled, in
progress or completed inspections. Two inspections cannot have the same
external ID and all must be valid for the request to complete. This includes
archived inspection IDs.

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

// * Create inspections can create inspections with any status (normally
scheduled).
[apiInstance inspectionServiceCreateInspectionsWith:body
              completionHandler: ^(v1CreateInspectionsResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.InspectionServiceApi()

var body = ; // {V1CreateInspectionsRequest} * Create Inspection request can be used to create new valid scheduled, in
progress or completed inspections. Two inspections cannot have the same
external ID and all must be valid for the request to complete. This includes
archived inspection IDs.


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

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

namespace Example
{
    public class inspectionServiceCreateInspectionsExample
    {
        public void main()
        {
            
            var apiInstance = new InspectionServiceApi();
            var body = new V1CreateInspectionsRequest(); // V1CreateInspectionsRequest | * Create Inspection request can be used to create new valid scheduled, in
progress or completed inspections. Two inspections cannot have the same
external ID and all must be valid for the request to complete. This includes
archived inspection IDs.

            try
            {
                // * Create inspections can create inspections with any status (normally
scheduled).
                v1CreateInspectionsResponse result = apiInstance.inspectionServiceCreateInspections(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling InspectionServiceApi.inspectionServiceCreateInspections: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\InspectionServiceApi();
$body = ; // V1CreateInspectionsRequest | * Create Inspection request can be used to create new valid scheduled, in
progress or completed inspections. Two inspections cannot have the same
external ID and all must be valid for the request to complete. This includes
archived inspection IDs.

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

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

my $api_instance = WWW::SwaggerClient::InspectionServiceApi->new();
my $body = WWW::SwaggerClient::Object::V1CreateInspectionsRequest->new(); # V1CreateInspectionsRequest | * Create Inspection request can be used to create new valid scheduled, in
progress or completed inspections. Two inspections cannot have the same
external ID and all must be valid for the request to complete. This includes
archived inspection IDs.

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

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

# create an instance of the API class
api_instance = swagger_client.InspectionServiceApi()
body =  # V1CreateInspectionsRequest | * Create Inspection request can be used to create new valid scheduled, in
progress or completed inspections. Two inspections cannot have the same
external ID and all must be valid for the request to complete. This includes
archived inspection IDs.

try: 
    # * Create inspections can create inspections with any status (normally
scheduled).
    api_response = api_instance.inspection_service_create_inspections(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling InspectionServiceApi->inspectionServiceCreateInspections: %s\n" % e)

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

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

public class InspectionServiceApiExample {

    public static void main(String[] args) {
        
        InspectionServiceApi apiInstance = new InspectionServiceApi();
        V1ListInspectionsRequest body = ; // V1ListInspectionsRequest | * List inspection request is used for fetching inspections. It can be
filtered to specific inspections, assets or folders. If the intent is to be
notified when an inspection undergoes a status transition please use the
InspectionEventService.
        try {
            v1ListInspectionsResponse result = apiInstance.inspectionServiceListInspections(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InspectionServiceApi#inspectionServiceListInspections");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.InspectionServiceApi;

public class InspectionServiceApiExample {

    public static void main(String[] args) {
        InspectionServiceApi apiInstance = new InspectionServiceApi();
        V1ListInspectionsRequest body = ; // V1ListInspectionsRequest | * List inspection request is used for fetching inspections. It can be
filtered to specific inspections, assets or folders. If the intent is to be
notified when an inspection undergoes a status transition please use the
InspectionEventService.
        try {
            v1ListInspectionsResponse result = apiInstance.inspectionServiceListInspections(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InspectionServiceApi#inspectionServiceListInspections");
            e.printStackTrace();
        }
    }
}

V1ListInspectionsRequest *body = ; // * List inspection request is used for fetching inspections. It can be
filtered to specific inspections, assets or folders. If the intent is to be
notified when an inspection undergoes a status transition please use the
InspectionEventService.

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

// * List inspections gets a paginated and optionally filtered list of
inspections from one or more folders.
[apiInstance inspectionServiceListInspectionsWith:body
              completionHandler: ^(v1ListInspectionsResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.InspectionServiceApi()

var body = ; // {V1ListInspectionsRequest} * List inspection request is used for fetching inspections. It can be
filtered to specific inspections, assets or folders. If the intent is to be
notified when an inspection undergoes a status transition please use the
InspectionEventService.


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

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

namespace Example
{
    public class inspectionServiceListInspectionsExample
    {
        public void main()
        {
            
            var apiInstance = new InspectionServiceApi();
            var body = new V1ListInspectionsRequest(); // V1ListInspectionsRequest | * List inspection request is used for fetching inspections. It can be
filtered to specific inspections, assets or folders. If the intent is to be
notified when an inspection undergoes a status transition please use the
InspectionEventService.

            try
            {
                // * List inspections gets a paginated and optionally filtered list of
inspections from one or more folders.
                v1ListInspectionsResponse result = apiInstance.inspectionServiceListInspections(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling InspectionServiceApi.inspectionServiceListInspections: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\InspectionServiceApi();
$body = ; // V1ListInspectionsRequest | * List inspection request is used for fetching inspections. It can be
filtered to specific inspections, assets or folders. If the intent is to be
notified when an inspection undergoes a status transition please use the
InspectionEventService.

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

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

my $api_instance = WWW::SwaggerClient::InspectionServiceApi->new();
my $body = WWW::SwaggerClient::Object::V1ListInspectionsRequest->new(); # V1ListInspectionsRequest | * List inspection request is used for fetching inspections. It can be
filtered to specific inspections, assets or folders. If the intent is to be
notified when an inspection undergoes a status transition please use the
InspectionEventService.

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

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

# create an instance of the API class
api_instance = swagger_client.InspectionServiceApi()
body =  # V1ListInspectionsRequest | * List inspection request is used for fetching inspections. It can be
filtered to specific inspections, assets or folders. If the intent is to be
notified when an inspection undergoes a status transition please use the
InspectionEventService.

try: 
    # * List inspections gets a paginated and optionally filtered list of
inspections from one or more folders.
    api_response = api_instance.inspection_service_list_inspections(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling InspectionServiceApi->inspectionServiceListInspections: %s\n" % e)

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

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

public class InspectionServiceApiExample {

    public static void main(String[] args) {
        
        InspectionServiceApi apiInstance = new InspectionServiceApi();
        V1SetInspectionsArchivedRequest body = ; // V1SetInspectionsArchivedRequest | * SetInspectionsArchivedRequest is used to archive and unarchive  multiple inspections.
        try {
            v1SetInspectionsArchivedResponse result = apiInstance.inspectionServiceUnarchiveInspections(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InspectionServiceApi#inspectionServiceUnarchiveInspections");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.InspectionServiceApi;

public class InspectionServiceApiExample {

    public static void main(String[] args) {
        InspectionServiceApi apiInstance = new InspectionServiceApi();
        V1SetInspectionsArchivedRequest body = ; // V1SetInspectionsArchivedRequest | * SetInspectionsArchivedRequest is used to archive and unarchive  multiple inspections.
        try {
            v1SetInspectionsArchivedResponse result = apiInstance.inspectionServiceUnarchiveInspections(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InspectionServiceApi#inspectionServiceUnarchiveInspections");
            e.printStackTrace();
        }
    }
}

V1SetInspectionsArchivedRequest *body = ; // * SetInspectionsArchivedRequest is used to archive and unarchive  multiple inspections.

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

// * Unarchive inspections should be used if previously archived
inspections need to be restored. All inspections must belong
to the same folder.
[apiInstance inspectionServiceUnarchiveInspectionsWith:body
              completionHandler: ^(v1SetInspectionsArchivedResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.InspectionServiceApi()

var body = ; // {V1SetInspectionsArchivedRequest} * SetInspectionsArchivedRequest is used to archive and unarchive  multiple inspections.


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

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

namespace Example
{
    public class inspectionServiceUnarchiveInspectionsExample
    {
        public void main()
        {
            
            var apiInstance = new InspectionServiceApi();
            var body = new V1SetInspectionsArchivedRequest(); // V1SetInspectionsArchivedRequest | * SetInspectionsArchivedRequest is used to archive and unarchive  multiple inspections.

            try
            {
                // * Unarchive inspections should be used if previously archived
inspections need to be restored. All inspections must belong
to the same folder.
                v1SetInspectionsArchivedResponse result = apiInstance.inspectionServiceUnarchiveInspections(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling InspectionServiceApi.inspectionServiceUnarchiveInspections: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\InspectionServiceApi();
$body = ; // V1SetInspectionsArchivedRequest | * SetInspectionsArchivedRequest is used to archive and unarchive  multiple inspections.

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

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

my $api_instance = WWW::SwaggerClient::InspectionServiceApi->new();
my $body = WWW::SwaggerClient::Object::V1SetInspectionsArchivedRequest->new(); # V1SetInspectionsArchivedRequest | * SetInspectionsArchivedRequest is used to archive and unarchive  multiple inspections.

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

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

# create an instance of the API class
api_instance = swagger_client.InspectionServiceApi()
body =  # V1SetInspectionsArchivedRequest | * SetInspectionsArchivedRequest is used to archive and unarchive  multiple inspections.

try: 
    # * Unarchive inspections should be used if previously archived
inspections need to be restored. All inspections must belong
to the same folder.
    api_response = api_instance.inspection_service_unarchive_inspections(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling InspectionServiceApi->inspectionServiceUnarchiveInspections: %s\n" % e)

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

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

public class InspectionServiceApiExample {

    public static void main(String[] args) {
        
        InspectionServiceApi apiInstance = new InspectionServiceApi();
        V1UpdateInspectionsRequest body = ; // V1UpdateInspectionsRequest | * Update Inspection request can be used to update existing valid scheduled,
in progress completed, and archived inspections. Two inspections cannot have
the same external ID and all must be valid for the request to complete. This
includes archived inspection IDs. An update cannot cause an inspection to
transition from in_progress to scheduled.
        try {
            v1UpdateInspectionsResponse result = apiInstance.inspectionServiceUpdateInspections(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InspectionServiceApi#inspectionServiceUpdateInspections");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.InspectionServiceApi;

public class InspectionServiceApiExample {

    public static void main(String[] args) {
        InspectionServiceApi apiInstance = new InspectionServiceApi();
        V1UpdateInspectionsRequest body = ; // V1UpdateInspectionsRequest | * Update Inspection request can be used to update existing valid scheduled,
in progress completed, and archived inspections. Two inspections cannot have
the same external ID and all must be valid for the request to complete. This
includes archived inspection IDs. An update cannot cause an inspection to
transition from in_progress to scheduled.
        try {
            v1UpdateInspectionsResponse result = apiInstance.inspectionServiceUpdateInspections(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InspectionServiceApi#inspectionServiceUpdateInspections");
            e.printStackTrace();
        }
    }
}

V1UpdateInspectionsRequest *body = ; // * Update Inspection request can be used to update existing valid scheduled,
in progress completed, and archived inspections. Two inspections cannot have
the same external ID and all must be valid for the request to complete. This
includes archived inspection IDs. An update cannot cause an inspection to
transition from in_progress to scheduled.

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

// * Update inspections can change the contents of inspections.
Currently an inspection cannot have its asset_id or template_id
updated.
[apiInstance inspectionServiceUpdateInspectionsWith:body
              completionHandler: ^(v1UpdateInspectionsResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.InspectionServiceApi()

var body = ; // {V1UpdateInspectionsRequest} * Update Inspection request can be used to update existing valid scheduled,
in progress completed, and archived inspections. Two inspections cannot have
the same external ID and all must be valid for the request to complete. This
includes archived inspection IDs. An update cannot cause an inspection to
transition from in_progress to scheduled.


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

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

namespace Example
{
    public class inspectionServiceUpdateInspectionsExample
    {
        public void main()
        {
            
            var apiInstance = new InspectionServiceApi();
            var body = new V1UpdateInspectionsRequest(); // V1UpdateInspectionsRequest | * Update Inspection request can be used to update existing valid scheduled,
in progress completed, and archived inspections. Two inspections cannot have
the same external ID and all must be valid for the request to complete. This
includes archived inspection IDs. An update cannot cause an inspection to
transition from in_progress to scheduled.

            try
            {
                // * Update inspections can change the contents of inspections.
Currently an inspection cannot have its asset_id or template_id
updated.
                v1UpdateInspectionsResponse result = apiInstance.inspectionServiceUpdateInspections(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling InspectionServiceApi.inspectionServiceUpdateInspections: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\InspectionServiceApi();
$body = ; // V1UpdateInspectionsRequest | * Update Inspection request can be used to update existing valid scheduled,
in progress completed, and archived inspections. Two inspections cannot have
the same external ID and all must be valid for the request to complete. This
includes archived inspection IDs. An update cannot cause an inspection to
transition from in_progress to scheduled.

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

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

my $api_instance = WWW::SwaggerClient::InspectionServiceApi->new();
my $body = WWW::SwaggerClient::Object::V1UpdateInspectionsRequest->new(); # V1UpdateInspectionsRequest | * Update Inspection request can be used to update existing valid scheduled,
in progress completed, and archived inspections. Two inspections cannot have
the same external ID and all must be valid for the request to complete. This
includes archived inspection IDs. An update cannot cause an inspection to
transition from in_progress to scheduled.

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

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

# create an instance of the API class
api_instance = swagger_client.InspectionServiceApi()
body =  # V1UpdateInspectionsRequest | * Update Inspection request can be used to update existing valid scheduled,
in progress completed, and archived inspections. Two inspections cannot have
the same external ID and all must be valid for the request to complete. This
includes archived inspection IDs. An update cannot cause an inspection to
transition from in_progress to scheduled.

try: 
    # * Update inspections can change the contents of inspections.
Currently an inspection cannot have its asset_id or template_id
updated.
    api_response = api_instance.inspection_service_update_inspections(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling InspectionServiceApi->inspectionServiceUpdateInspections: %s\n" % e)

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

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

public class ReportServiceApiExample {

    public static void main(String[] args) {
        
        ReportServiceApi apiInstance = new ReportServiceApi();
        V1ListReportsRequest body = ; // V1ListReportsRequest | * List report request is used for fetching reports. It can be
filtered to specific reports, assets or folders. If the intent is to be
notified when an report undergoes a status transition please use the
ReportEventService.
        try {
            v1ListReportsResponse result = apiInstance.reportServiceListReports(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportServiceApi#reportServiceListReports");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportServiceApi;

public class ReportServiceApiExample {

    public static void main(String[] args) {
        ReportServiceApi apiInstance = new ReportServiceApi();
        V1ListReportsRequest body = ; // V1ListReportsRequest | * List report request is used for fetching reports. It can be
filtered to specific reports, assets or folders. If the intent is to be
notified when an report undergoes a status transition please use the
ReportEventService.
        try {
            v1ListReportsResponse result = apiInstance.reportServiceListReports(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportServiceApi#reportServiceListReports");
            e.printStackTrace();
        }
    }
}

V1ListReportsRequest *body = ; // * List report request is used for fetching reports. It can be
filtered to specific reports, assets or folders. If the intent is to be
notified when an report undergoes a status transition please use the
ReportEventService.

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

// * List reports gets a paginated and optionally filtered list of
reports from one or more folders.
[apiInstance reportServiceListReportsWith:body
              completionHandler: ^(v1ListReportsResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.ReportServiceApi()

var body = ; // {V1ListReportsRequest} * List report request is used for fetching reports. It can be
filtered to specific reports, assets or folders. If the intent is to be
notified when an report undergoes a status transition please use the
ReportEventService.


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

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

namespace Example
{
    public class reportServiceListReportsExample
    {
        public void main()
        {
            
            var apiInstance = new ReportServiceApi();
            var body = new V1ListReportsRequest(); // V1ListReportsRequest | * List report request is used for fetching reports. It can be
filtered to specific reports, assets or folders. If the intent is to be
notified when an report undergoes a status transition please use the
ReportEventService.

            try
            {
                // * List reports gets a paginated and optionally filtered list of
reports from one or more folders.
                v1ListReportsResponse result = apiInstance.reportServiceListReports(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportServiceApi.reportServiceListReports: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ReportServiceApi();
$body = ; // V1ListReportsRequest | * List report request is used for fetching reports. It can be
filtered to specific reports, assets or folders. If the intent is to be
notified when an report undergoes a status transition please use the
ReportEventService.

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

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

my $api_instance = WWW::SwaggerClient::ReportServiceApi->new();
my $body = WWW::SwaggerClient::Object::V1ListReportsRequest->new(); # V1ListReportsRequest | * List report request is used for fetching reports. It can be
filtered to specific reports, assets or folders. If the intent is to be
notified when an report undergoes a status transition please use the
ReportEventService.

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

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

# create an instance of the API class
api_instance = swagger_client.ReportServiceApi()
body =  # V1ListReportsRequest | * List report request is used for fetching reports. It can be
filtered to specific reports, assets or folders. If the intent is to be
notified when an report undergoes a status transition please use the
ReportEventService.

try: 
    # * List reports gets a paginated and optionally filtered list of
reports from one or more folders.
    api_response = api_instance.report_service_list_reports(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportServiceApi->reportServiceListReports: %s\n" % e)

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

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

public class TemplateServiceApiExample {

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

import io.swagger.client.api.TemplateServiceApi;

public class TemplateServiceApiExample {

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

V1SetTemplatesArchivedRequest *body = ; // 

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

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

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.TemplateServiceApi()

var body = ; // {V1SetTemplatesArchivedRequest} 


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

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

namespace Example
{
    public class templateServiceArchiveTemplatesExample
    {
        public void main()
        {
            
            var apiInstance = new TemplateServiceApi();
            var body = new V1SetTemplatesArchivedRequest(); // V1SetTemplatesArchivedRequest | 

            try
            {
                v1SetTemplatesArchivedResponse result = apiInstance.templateServiceArchiveTemplates(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TemplateServiceApi.templateServiceArchiveTemplates: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\TemplateServiceApi();
$body = ; // V1SetTemplatesArchivedRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.TemplateServiceApi()
body =  # V1SetTemplatesArchivedRequest | 

try: 
    api_response = api_instance.template_service_archive_templates(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TemplateServiceApi->templateServiceArchiveTemplates: %s\n" % e)

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

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

public class TemplateServiceApiExample {

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

import io.swagger.client.api.TemplateServiceApi;

public class TemplateServiceApiExample {

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

V1CreateTemplatesRequest *body = ; // 

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

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

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.TemplateServiceApi()

var body = ; // {V1CreateTemplatesRequest} 


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

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

namespace Example
{
    public class templateServiceCreateTemplatesExample
    {
        public void main()
        {
            
            var apiInstance = new TemplateServiceApi();
            var body = new V1CreateTemplatesRequest(); // V1CreateTemplatesRequest | 

            try
            {
                v1CreateTemplatesResponse result = apiInstance.templateServiceCreateTemplates(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TemplateServiceApi.templateServiceCreateTemplates: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\TemplateServiceApi();
$body = ; // V1CreateTemplatesRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.TemplateServiceApi()
body =  # V1CreateTemplatesRequest | 

try: 
    api_response = api_instance.template_service_create_templates(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TemplateServiceApi->templateServiceCreateTemplates: %s\n" % e)

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

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

public class TemplateServiceApiExample {

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

import io.swagger.client.api.TemplateServiceApi;

public class TemplateServiceApiExample {

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

V1ListTemplatesRequest *body = ; // 

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

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

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.TemplateServiceApi()

var body = ; // {V1ListTemplatesRequest} 


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

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

namespace Example
{
    public class templateServiceListTemplatesExample
    {
        public void main()
        {
            
            var apiInstance = new TemplateServiceApi();
            var body = new V1ListTemplatesRequest(); // V1ListTemplatesRequest | 

            try
            {
                v1ListTemplatesResponse result = apiInstance.templateServiceListTemplates(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TemplateServiceApi.templateServiceListTemplates: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\TemplateServiceApi();
$body = ; // V1ListTemplatesRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.TemplateServiceApi()
body =  # V1ListTemplatesRequest | 

try: 
    api_response = api_instance.template_service_list_templates(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TemplateServiceApi->templateServiceListTemplates: %s\n" % e)

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

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

public class TemplateServiceApiExample {

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

import io.swagger.client.api.TemplateServiceApi;

public class TemplateServiceApiExample {

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

V1SetTemplatesArchivedRequest *body = ; // 

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

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

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.TemplateServiceApi()

var body = ; // {V1SetTemplatesArchivedRequest} 


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

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

namespace Example
{
    public class templateServiceUnarchiveTemplatesExample
    {
        public void main()
        {
            
            var apiInstance = new TemplateServiceApi();
            var body = new V1SetTemplatesArchivedRequest(); // V1SetTemplatesArchivedRequest | 

            try
            {
                v1SetTemplatesArchivedResponse result = apiInstance.templateServiceUnarchiveTemplates(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TemplateServiceApi.templateServiceUnarchiveTemplates: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\TemplateServiceApi();
$body = ; // V1SetTemplatesArchivedRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.TemplateServiceApi()
body =  # V1SetTemplatesArchivedRequest | 

try: 
    api_response = api_instance.template_service_unarchive_templates(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TemplateServiceApi->templateServiceUnarchiveTemplates: %s\n" % e)

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

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

public class TemplateServiceApiExample {

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

import io.swagger.client.api.TemplateServiceApi;

public class TemplateServiceApiExample {

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

V1UpdateTemplatesRequest *body = ; // 

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

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

var MergedSwaggers = require('merged_swaggers');

var api = new MergedSwaggers.TemplateServiceApi()

var body = ; // {V1UpdateTemplatesRequest} 


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

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

namespace Example
{
    public class templateServiceUpdateTemplatesExample
    {
        public void main()
        {
            
            var apiInstance = new TemplateServiceApi();
            var body = new V1UpdateTemplatesRequest(); // V1UpdateTemplatesRequest | 

            try
            {
                v1UpdateTemplatesResponse result = apiInstance.templateServiceUpdateTemplates(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TemplateServiceApi.templateServiceUpdateTemplates: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\TemplateServiceApi();
$body = ; // V1UpdateTemplatesRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.TemplateServiceApi()
body =  # V1UpdateTemplatesRequest | 

try: 
    api_response = api_instance.template_service_update_templates(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TemplateServiceApi->templateServiceUpdateTemplates: %s\n" % e)