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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        OAuthV2ClientType oAuthV2ClientType = ; // OAuthV2ClientType | 

        try {
            clientId result = apiInstance.createClient(module, setupId, oAuthV2ClientType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createClient");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 
final OAuthV2ClientType oAuthV2ClientType = new OAuthV2ClientType(); // OAuthV2ClientType | 

try {
    final result = await api_instance.createClient(module, setupId, oAuthV2ClientType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createClient: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        OAuthV2ClientType oAuthV2ClientType = ; // OAuthV2ClientType | 

        try {
            clientId result = apiInstance.createClient(module, setupId, oAuthV2ClientType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createClient");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)
OAuthV2ClientType *oAuthV2ClientType = ; //  (optional)

// Create client
[apiInstance createClientWith:module
    setupId:setupId
    oAuthV2ClientType:oAuthV2ClientType
              completionHandler: ^(clientId output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 
var opts = {
  'oAuthV2ClientType':  // {OAuthV2ClientType} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)
            var oAuthV2ClientType = new OAuthV2ClientType(); // OAuthV2ClientType |  (optional) 

            try {
                // Create client
                clientId result = apiInstance.createClient(module, setupId, oAuthV2ClientType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.createClient: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 
$oAuthV2ClientType = ; // OAuthV2ClientType | 

try {
    $result = $api_instance->createClient($module, $setupId, $oAuthV2ClientType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->createClient: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 
my $oAuthV2ClientType = WWW::OPenAPIClient::Object::OAuthV2ClientType->new(); # OAuthV2ClientType | 

eval {
    my $result = $api_instance->createClient(module => $module, setupId => $setupId, oAuthV2ClientType => $oAuthV2ClientType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createClient: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)
oAuthV2ClientType =  # OAuthV2ClientType |  (optional)

try:
    # Create client
    api_response = api_instance.create_client(module, setupId, oAuthV2ClientType=oAuthV2ClientType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->createClient: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String
    let oAuthV2ClientType = ; // OAuthV2ClientType

    let mut context = DefaultApi::Context::default();
    let result = client.createClient(module, setupId, oAuthV2ClientType, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        OAuthV2ResourceServerType oAuthV2ResourceServerType = ; // OAuthV2ResourceServerType | 

        try {
            resourceServerId result = apiInstance.createResourceServer(module, setupId, oAuthV2ResourceServerType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createResourceServer");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 
final OAuthV2ResourceServerType oAuthV2ResourceServerType = new OAuthV2ResourceServerType(); // OAuthV2ResourceServerType | 

try {
    final result = await api_instance.createResourceServer(module, setupId, oAuthV2ResourceServerType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createResourceServer: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        OAuthV2ResourceServerType oAuthV2ResourceServerType = ; // OAuthV2ResourceServerType | 

        try {
            resourceServerId result = apiInstance.createResourceServer(module, setupId, oAuthV2ResourceServerType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createResourceServer");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)
OAuthV2ResourceServerType *oAuthV2ResourceServerType = ; //  (optional)

// Create resource server for a setup
[apiInstance createResourceServerWith:module
    setupId:setupId
    oAuthV2ResourceServerType:oAuthV2ResourceServerType
              completionHandler: ^(resourceServerId output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 
var opts = {
  'oAuthV2ResourceServerType':  // {OAuthV2ResourceServerType} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)
            var oAuthV2ResourceServerType = new OAuthV2ResourceServerType(); // OAuthV2ResourceServerType |  (optional) 

            try {
                // Create resource server for a setup
                resourceServerId result = apiInstance.createResourceServer(module, setupId, oAuthV2ResourceServerType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.createResourceServer: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 
$oAuthV2ResourceServerType = ; // OAuthV2ResourceServerType | 

try {
    $result = $api_instance->createResourceServer($module, $setupId, $oAuthV2ResourceServerType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->createResourceServer: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 
my $oAuthV2ResourceServerType = WWW::OPenAPIClient::Object::OAuthV2ResourceServerType->new(); # OAuthV2ResourceServerType | 

eval {
    my $result = $api_instance->createResourceServer(module => $module, setupId => $setupId, oAuthV2ResourceServerType => $oAuthV2ResourceServerType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createResourceServer: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)
oAuthV2ResourceServerType =  # OAuthV2ResourceServerType |  (optional)

try:
    # Create resource server for a setup
    api_response = api_instance.create_resource_server(module, setupId, oAuthV2ResourceServerType=oAuthV2ResourceServerType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->createResourceServer: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String
    let oAuthV2ResourceServerType = ; // OAuthV2ResourceServerType

    let mut context = DefaultApi::Context::default();
    let result = client.createResourceServer(module, setupId, oAuthV2ResourceServerType, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        OAuthV2SetupType oAuthV2SetupType = ; // OAuthV2SetupType | 

        try {
            setupId result = apiInstance.createSetup(module, oAuthV2SetupType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createSetup");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final OAuthV2SetupType oAuthV2SetupType = new OAuthV2SetupType(); // OAuthV2SetupType | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        OAuthV2SetupType oAuthV2SetupType = ; // OAuthV2SetupType | 

        try {
            setupId result = apiInstance.createSetup(module, oAuthV2SetupType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createSetup");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
OAuthV2SetupType *oAuthV2SetupType = ; //  (optional)

// Create a setup
[apiInstance createSetupWith:module
    oAuthV2SetupType:oAuthV2SetupType
              completionHandler: ^(setupId output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var opts = {
  'oAuthV2SetupType':  // {OAuthV2SetupType} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var oAuthV2SetupType = new OAuthV2SetupType(); // OAuthV2SetupType |  (optional) 

            try {
                // Create a setup
                setupId result = apiInstance.createSetup(module, oAuthV2SetupType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.createSetup: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$oAuthV2SetupType = ; // OAuthV2SetupType | 

try {
    $result = $api_instance->createSetup($module, $oAuthV2SetupType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->createSetup: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $oAuthV2SetupType = WWW::OPenAPIClient::Object::OAuthV2SetupType->new(); # OAuthV2SetupType | 

eval {
    my $result = $api_instance->createSetup(module => $module, oAuthV2SetupType => $oAuthV2SetupType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createSetup: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
oAuthV2SetupType =  # OAuthV2SetupType |  (optional)

try:
    # Create a setup
    api_response = api_instance.create_setup(module, oAuthV2SetupType=oAuthV2SetupType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->createSetup: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let oAuthV2SetupType = ; // OAuthV2SetupType

    let mut context = DefaultApi::Context::default();
    let result = client.createSetup(module, oAuthV2SetupType, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String setup = setup_example; // String | 
        String user = user_example; // String | 

        try {
            apiInstance.deleteAllPersistedConsentsOfSetup(setup, user);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteAllPersistedConsentsOfSetup");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String setup = new String(); // String | 
final String user = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String setup = setup_example; // String | 
        String user = user_example; // String | 

        try {
            apiInstance.deleteAllPersistedConsentsOfSetup(setup, user);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteAllPersistedConsentsOfSetup");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *setup = setup_example; //  (default to null)
String *user = user_example; //  (optional) (default to null)

// Delete all persisted consents of a setup
[apiInstance deleteAllPersistedConsentsOfSetupWith:setup
    user:user
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var setup = setup_example; // {String} 
var opts = {
  'user': user_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var setup = setup_example;  // String |  (default to null)
            var user = user_example;  // String |  (optional)  (default to null)

            try {
                // Delete all persisted consents of a setup
                apiInstance.deleteAllPersistedConsentsOfSetup(setup, user);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.deleteAllPersistedConsentsOfSetup: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$setup = setup_example; // String | 
$user = user_example; // String | 

try {
    $api_instance->deleteAllPersistedConsentsOfSetup($setup, $user);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteAllPersistedConsentsOfSetup: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $setup = setup_example; # String | 
my $user = user_example; # String | 

eval {
    $api_instance->deleteAllPersistedConsentsOfSetup(setup => $setup, user => $user);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteAllPersistedConsentsOfSetup: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
setup = setup_example # String |  (default to null)
user = user_example # String |  (optional) (default to null)

try:
    # Delete all persisted consents of a setup
    api_instance.delete_all_persisted_consents_of_setup(setup, user=user)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteAllPersistedConsentsOfSetup: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let setup = setup_example; // String
    let user = user_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.deleteAllPersistedConsentsOfSetup(setup, user, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String clientId = clientId_example; // String | 
        String snapshotId = snapshotId_example; // String | 

        try {
            apiInstance.deleteFutureSnapshot(module, setupId, clientId, snapshotId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteFutureSnapshot");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 
final String clientId = new String(); // String | 
final String snapshotId = new String(); // String | 

try {
    final result = await api_instance.deleteFutureSnapshot(module, setupId, clientId, snapshotId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteFutureSnapshot: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String clientId = clientId_example; // String | 
        String snapshotId = snapshotId_example; // String | 

        try {
            apiInstance.deleteFutureSnapshot(module, setupId, clientId, snapshotId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteFutureSnapshot");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)
String *clientId = clientId_example; //  (default to null)
String *snapshotId = snapshotId_example; //  (default to null)

// Delete a future snapshot of a client
[apiInstance deleteFutureSnapshotWith:module
    setupId:setupId
    clientId:clientId
    snapshotId:snapshotId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 
var clientId = clientId_example; // {String} 
var snapshotId = snapshotId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteFutureSnapshot(module, setupId, clientId, snapshotId, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)
            var clientId = clientId_example;  // String |  (default to null)
            var snapshotId = snapshotId_example;  // String |  (default to null)

            try {
                // Delete a future snapshot of a client
                apiInstance.deleteFutureSnapshot(module, setupId, clientId, snapshotId);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.deleteFutureSnapshot: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 
$clientId = clientId_example; // String | 
$snapshotId = snapshotId_example; // String | 

try {
    $api_instance->deleteFutureSnapshot($module, $setupId, $clientId, $snapshotId);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteFutureSnapshot: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 
my $clientId = clientId_example; # String | 
my $snapshotId = snapshotId_example; # String | 

eval {
    $api_instance->deleteFutureSnapshot(module => $module, setupId => $setupId, clientId => $clientId, snapshotId => $snapshotId);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteFutureSnapshot: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)
clientId = clientId_example # String |  (default to null)
snapshotId = snapshotId_example # String |  (default to null)

try:
    # Delete a future snapshot of a client
    api_instance.delete_future_snapshot(module, setupId, clientId, snapshotId)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteFutureSnapshot: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String
    let clientId = clientId_example; // String
    let snapshotId = snapshotId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.deleteFutureSnapshot(module, setupId, clientId, snapshotId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String resourceId = resourceId_example; // String | 
        String snapshotId = snapshotId_example; // String | 

        try {
            apiInstance.deleteFutureSnapshot1(module, setupId, resourceId, snapshotId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteFutureSnapshot1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 
final String resourceId = new String(); // String | 
final String snapshotId = new String(); // String | 

try {
    final result = await api_instance.deleteFutureSnapshot1(module, setupId, resourceId, snapshotId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteFutureSnapshot1: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String resourceId = resourceId_example; // String | 
        String snapshotId = snapshotId_example; // String | 

        try {
            apiInstance.deleteFutureSnapshot1(module, setupId, resourceId, snapshotId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteFutureSnapshot1");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)
String *resourceId = resourceId_example; //  (default to null)
String *snapshotId = snapshotId_example; //  (default to null)

// Delete a future snapshot of a resource server
[apiInstance deleteFutureSnapshot1With:module
    setupId:setupId
    resourceId:resourceId
    snapshotId:snapshotId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 
var resourceId = resourceId_example; // {String} 
var snapshotId = snapshotId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteFutureSnapshot1(module, setupId, resourceId, snapshotId, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)
            var resourceId = resourceId_example;  // String |  (default to null)
            var snapshotId = snapshotId_example;  // String |  (default to null)

            try {
                // Delete a future snapshot of a resource server
                apiInstance.deleteFutureSnapshot1(module, setupId, resourceId, snapshotId);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.deleteFutureSnapshot1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 
$resourceId = resourceId_example; // String | 
$snapshotId = snapshotId_example; // String | 

try {
    $api_instance->deleteFutureSnapshot1($module, $setupId, $resourceId, $snapshotId);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteFutureSnapshot1: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 
my $resourceId = resourceId_example; # String | 
my $snapshotId = snapshotId_example; # String | 

eval {
    $api_instance->deleteFutureSnapshot1(module => $module, setupId => $setupId, resourceId => $resourceId, snapshotId => $snapshotId);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteFutureSnapshot1: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)
resourceId = resourceId_example # String |  (default to null)
snapshotId = snapshotId_example # String |  (default to null)

try:
    # Delete a future snapshot of a resource server
    api_instance.delete_future_snapshot1(module, setupId, resourceId, snapshotId)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteFutureSnapshot1: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String
    let resourceId = resourceId_example; // String
    let snapshotId = snapshotId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.deleteFutureSnapshot1(module, setupId, resourceId, snapshotId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String snapshotId = snapshotId_example; // String | 

        try {
            apiInstance.deleteFutureSnapshot2(module, setupId, snapshotId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteFutureSnapshot2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 
final String snapshotId = new String(); // String | 

try {
    final result = await api_instance.deleteFutureSnapshot2(module, setupId, snapshotId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteFutureSnapshot2: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String snapshotId = snapshotId_example; // String | 

        try {
            apiInstance.deleteFutureSnapshot2(module, setupId, snapshotId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteFutureSnapshot2");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)
String *snapshotId = snapshotId_example; //  (default to null)

// Delete a future snapshot of a setup
[apiInstance deleteFutureSnapshot2With:module
    setupId:setupId
    snapshotId:snapshotId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 
var snapshotId = snapshotId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)
            var snapshotId = snapshotId_example;  // String |  (default to null)

            try {
                // Delete a future snapshot of a setup
                apiInstance.deleteFutureSnapshot2(module, setupId, snapshotId);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.deleteFutureSnapshot2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 
$snapshotId = snapshotId_example; // String | 

try {
    $api_instance->deleteFutureSnapshot2($module, $setupId, $snapshotId);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteFutureSnapshot2: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 
my $snapshotId = snapshotId_example; # String | 

eval {
    $api_instance->deleteFutureSnapshot2(module => $module, setupId => $setupId, snapshotId => $snapshotId);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteFutureSnapshot2: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)
snapshotId = snapshotId_example # String |  (default to null)

try:
    # Delete a future snapshot of a setup
    api_instance.delete_future_snapshot2(module, setupId, snapshotId)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteFutureSnapshot2: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String
    let snapshotId = snapshotId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.deleteFutureSnapshot2(module, setupId, snapshotId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String setupId = setupId_example; // String | 
        String clientId = clientId_example; // String | 
        String user = user_example; // String | 

        try {
            apiInstance.deletePersistedConsent(setupId, clientId, user);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deletePersistedConsent");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String setupId = new String(); // String | 
final String clientId = new String(); // String | 
final String user = new String(); // String | 

try {
    final result = await api_instance.deletePersistedConsent(setupId, clientId, user);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deletePersistedConsent: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String setupId = setupId_example; // String | 
        String clientId = clientId_example; // String | 
        String user = user_example; // String | 

        try {
            apiInstance.deletePersistedConsent(setupId, clientId, user);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deletePersistedConsent");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *setupId = setupId_example; //  (default to null)
String *clientId = clientId_example; //  (default to null)
String *user = user_example; //  (optional) (default to null)

// Delete persisted consent
[apiInstance deletePersistedConsentWith:setupId
    clientId:clientId
    user:user
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var setupId = setupId_example; // {String} 
var clientId = clientId_example; // {String} 
var opts = {
  'user': user_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var setupId = setupId_example;  // String |  (default to null)
            var clientId = clientId_example;  // String |  (default to null)
            var user = user_example;  // String |  (optional)  (default to null)

            try {
                // Delete persisted consent
                apiInstance.deletePersistedConsent(setupId, clientId, user);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.deletePersistedConsent: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$setupId = setupId_example; // String | 
$clientId = clientId_example; // String | 
$user = user_example; // String | 

try {
    $api_instance->deletePersistedConsent($setupId, $clientId, $user);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deletePersistedConsent: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $setupId = setupId_example; # String | 
my $clientId = clientId_example; # String | 
my $user = user_example; # String | 

eval {
    $api_instance->deletePersistedConsent(setupId => $setupId, clientId => $clientId, user => $user);
};
if ($@) {
    warn "Exception when calling DefaultApi->deletePersistedConsent: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
setupId = setupId_example # String |  (default to null)
clientId = clientId_example # String |  (default to null)
user = user_example # String |  (optional) (default to null)

try:
    # Delete persisted consent
    api_instance.delete_persisted_consent(setupId, clientId, user=user)
except ApiException as e:
    print("Exception when calling DefaultApi->deletePersistedConsent: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let setupId = setupId_example; // String
    let clientId = clientId_example; // String
    let user = user_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.deletePersistedConsent(setupId, clientId, user, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String setupId = setupId_example; // String | 
        String token = token_example; // String | 

        try {
            apiInstance.deleteRefreshToken(setupId, token);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteRefreshToken");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String setupId = new String(); // String | 
final String token = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String setupId = setupId_example; // String | 
        String token = token_example; // String | 

        try {
            apiInstance.deleteRefreshToken(setupId, token);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteRefreshToken");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *setupId = setupId_example; //  (default to null)
String *token = token_example; //  (default to null)

// Delete a refresh token
[apiInstance deleteRefreshTokenWith:setupId
    token:token
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var setupId = setupId_example; // {String} 
var token = token_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var setupId = setupId_example;  // String |  (default to null)
            var token = token_example;  // String |  (default to null)

            try {
                // Delete a refresh token
                apiInstance.deleteRefreshToken(setupId, token);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.deleteRefreshToken: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$setupId = setupId_example; // String | 
$token = token_example; // String | 

try {
    $api_instance->deleteRefreshToken($setupId, $token);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteRefreshToken: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $setupId = setupId_example; # String | 
my $token = token_example; # String | 

eval {
    $api_instance->deleteRefreshToken(setupId => $setupId, token => $token);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteRefreshToken: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
setupId = setupId_example # String |  (default to null)
token = token_example # String |  (default to null)

try:
    # Delete a refresh token
    api_instance.delete_refresh_token(setupId, token)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteRefreshToken: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let setupId = setupId_example; // String
    let token = token_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.deleteRefreshToken(setupId, token, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String setup = setup_example; // String | 
        String token = token_example; // String | 

        try {
            apiInstance.deleteRefreshToken1(setup, token);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteRefreshToken1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String setup = new String(); // String | 
final String token = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String setup = setup_example; // String | 
        String token = token_example; // String | 

        try {
            apiInstance.deleteRefreshToken1(setup, token);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteRefreshToken1");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *setup = setup_example; //  (default to null)
String *token = token_example; //  (default to null)

// Delete a refresh token
[apiInstance deleteRefreshToken1With:setup
    token:token
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var setup = setup_example; // {String} 
var token = token_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var setup = setup_example;  // String |  (default to null)
            var token = token_example;  // String |  (default to null)

            try {
                // Delete a refresh token
                apiInstance.deleteRefreshToken1(setup, token);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.deleteRefreshToken1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$setup = setup_example; // String | 
$token = token_example; // String | 

try {
    $api_instance->deleteRefreshToken1($setup, $token);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteRefreshToken1: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $setup = setup_example; # String | 
my $token = token_example; # String | 

eval {
    $api_instance->deleteRefreshToken1(setup => $setup, token => $token);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteRefreshToken1: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
setup = setup_example # String |  (default to null)
token = token_example # String |  (default to null)

try:
    # Delete a refresh token
    api_instance.delete_refresh_token1(setup, token)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteRefreshToken1: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let setup = setup_example; // String
    let token = token_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.deleteRefreshToken1(setup, token, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String setupId = setupId_example; // String | 
        String user = user_example; // String | 

        try {
            apiInstance.deleteRefreshTokens(setupId, user);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteRefreshTokens");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String setupId = new String(); // String | 
final String user = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String setupId = setupId_example; // String | 
        String user = user_example; // String | 

        try {
            apiInstance.deleteRefreshTokens(setupId, user);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteRefreshTokens");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *setupId = setupId_example; //  (default to null)
String *user = user_example; //  (optional) (default to null)

// Delete refresh tokens of a user
[apiInstance deleteRefreshTokensWith:setupId
    user:user
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var setupId = setupId_example; // {String} 
var opts = {
  'user': user_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var setupId = setupId_example;  // String |  (default to null)
            var user = user_example;  // String |  (optional)  (default to null)

            try {
                // Delete refresh tokens of a user
                apiInstance.deleteRefreshTokens(setupId, user);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.deleteRefreshTokens: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$setupId = setupId_example; // String | 
$user = user_example; // String | 

try {
    $api_instance->deleteRefreshTokens($setupId, $user);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteRefreshTokens: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $setupId = setupId_example; # String | 
my $user = user_example; # String | 

eval {
    $api_instance->deleteRefreshTokens(setupId => $setupId, user => $user);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteRefreshTokens: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
setupId = setupId_example # String |  (default to null)
user = user_example # String |  (optional) (default to null)

try:
    # Delete refresh tokens of a user
    api_instance.delete_refresh_tokens(setupId, user=user)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteRefreshTokens: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let setupId = setupId_example; // String
    let user = user_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.deleteRefreshTokens(setupId, user, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String setup = setup_example; // String | 
        String user = user_example; // String | 

        try {
            apiInstance.deleteRefreshTokens1(setup, user);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteRefreshTokens1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String setup = new String(); // String | 
final String user = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String setup = setup_example; // String | 
        String user = user_example; // String | 

        try {
            apiInstance.deleteRefreshTokens1(setup, user);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteRefreshTokens1");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *setup = setup_example; //  (default to null)
String *user = user_example; //  (optional) (default to null)

// Delete all refresh tokens of a user
[apiInstance deleteRefreshTokens1With:setup
    user:user
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var setup = setup_example; // {String} 
var opts = {
  'user': user_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var setup = setup_example;  // String |  (default to null)
            var user = user_example;  // String |  (optional)  (default to null)

            try {
                // Delete all refresh tokens of a user
                apiInstance.deleteRefreshTokens1(setup, user);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.deleteRefreshTokens1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$setup = setup_example; // String | 
$user = user_example; // String | 

try {
    $api_instance->deleteRefreshTokens1($setup, $user);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteRefreshTokens1: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $setup = setup_example; # String | 
my $user = user_example; # String | 

eval {
    $api_instance->deleteRefreshTokens1(setup => $setup, user => $user);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteRefreshTokens1: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
setup = setup_example # String |  (default to null)
user = user_example # String |  (optional) (default to null)

try:
    # Delete all refresh tokens of a user
    api_instance.delete_refresh_tokens1(setup, user=user)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteRefreshTokens1: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let setup = setup_example; // String
    let user = user_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.deleteRefreshTokens1(setup, user, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String clientId = clientId_example; // String | 
        Boolean replaceActiveState = true; // Boolean | 
        OAuthV2ClientType oAuthV2ClientType = ; // OAuthV2ClientType | 

        try {
            OAuthV2ClientType result = apiInstance.editClient(module, setupId, clientId, replaceActiveState, oAuthV2ClientType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#editClient");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 
final String clientId = new String(); // String | 
final Boolean replaceActiveState = new Boolean(); // Boolean | 
final OAuthV2ClientType oAuthV2ClientType = new OAuthV2ClientType(); // OAuthV2ClientType | 

try {
    final result = await api_instance.editClient(module, setupId, clientId, replaceActiveState, oAuthV2ClientType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->editClient: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String clientId = clientId_example; // String | 
        Boolean replaceActiveState = true; // Boolean | 
        OAuthV2ClientType oAuthV2ClientType = ; // OAuthV2ClientType | 

        try {
            OAuthV2ClientType result = apiInstance.editClient(module, setupId, clientId, replaceActiveState, oAuthV2ClientType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#editClient");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)
String *clientId = clientId_example; //  (default to null)
Boolean *replaceActiveState = true; //  (optional) (default to null)
OAuthV2ClientType *oAuthV2ClientType = ; //  (optional)

// Edit a client
[apiInstance editClientWith:module
    setupId:setupId
    clientId:clientId
    replaceActiveState:replaceActiveState
    oAuthV2ClientType:oAuthV2ClientType
              completionHandler: ^(OAuthV2ClientType output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 
var clientId = clientId_example; // {String} 
var opts = {
  'replaceActiveState': true, // {Boolean} 
  'oAuthV2ClientType':  // {OAuthV2ClientType} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)
            var clientId = clientId_example;  // String |  (default to null)
            var replaceActiveState = true;  // Boolean |  (optional)  (default to null)
            var oAuthV2ClientType = new OAuthV2ClientType(); // OAuthV2ClientType |  (optional) 

            try {
                // Edit a client
                OAuthV2ClientType result = apiInstance.editClient(module, setupId, clientId, replaceActiveState, oAuthV2ClientType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.editClient: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 
$clientId = clientId_example; // String | 
$replaceActiveState = true; // Boolean | 
$oAuthV2ClientType = ; // OAuthV2ClientType | 

try {
    $result = $api_instance->editClient($module, $setupId, $clientId, $replaceActiveState, $oAuthV2ClientType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->editClient: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 
my $clientId = clientId_example; # String | 
my $replaceActiveState = true; # Boolean | 
my $oAuthV2ClientType = WWW::OPenAPIClient::Object::OAuthV2ClientType->new(); # OAuthV2ClientType | 

eval {
    my $result = $api_instance->editClient(module => $module, setupId => $setupId, clientId => $clientId, replaceActiveState => $replaceActiveState, oAuthV2ClientType => $oAuthV2ClientType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->editClient: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)
clientId = clientId_example # String |  (default to null)
replaceActiveState = true # Boolean |  (optional) (default to null)
oAuthV2ClientType =  # OAuthV2ClientType |  (optional)

try:
    # Edit a client
    api_response = api_instance.edit_client(module, setupId, clientId, replaceActiveState=replaceActiveState, oAuthV2ClientType=oAuthV2ClientType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->editClient: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String
    let clientId = clientId_example; // String
    let replaceActiveState = true; // Boolean
    let oAuthV2ClientType = ; // OAuthV2ClientType

    let mut context = DefaultApi::Context::default();
    let result = client.editClient(module, setupId, clientId, replaceActiveState, oAuthV2ClientType, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String resourceId = resourceId_example; // String | 
        Boolean replaceActiveState = true; // Boolean | 
        OAuthV2ResourceServerType oAuthV2ResourceServerType = ; // OAuthV2ResourceServerType | 

        try {
            OAuthV2ResourceServerType result = apiInstance.editResourceServer(module, setupId, resourceId, replaceActiveState, oAuthV2ResourceServerType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#editResourceServer");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 
final String resourceId = new String(); // String | 
final Boolean replaceActiveState = new Boolean(); // Boolean | 
final OAuthV2ResourceServerType oAuthV2ResourceServerType = new OAuthV2ResourceServerType(); // OAuthV2ResourceServerType | 

try {
    final result = await api_instance.editResourceServer(module, setupId, resourceId, replaceActiveState, oAuthV2ResourceServerType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->editResourceServer: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String resourceId = resourceId_example; // String | 
        Boolean replaceActiveState = true; // Boolean | 
        OAuthV2ResourceServerType oAuthV2ResourceServerType = ; // OAuthV2ResourceServerType | 

        try {
            OAuthV2ResourceServerType result = apiInstance.editResourceServer(module, setupId, resourceId, replaceActiveState, oAuthV2ResourceServerType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#editResourceServer");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)
String *resourceId = resourceId_example; //  (default to null)
Boolean *replaceActiveState = true; //  (optional) (default to null)
OAuthV2ResourceServerType *oAuthV2ResourceServerType = ; //  (optional)

// Edit a resource server
[apiInstance editResourceServerWith:module
    setupId:setupId
    resourceId:resourceId
    replaceActiveState:replaceActiveState
    oAuthV2ResourceServerType:oAuthV2ResourceServerType
              completionHandler: ^(OAuthV2ResourceServerType output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 
var resourceId = resourceId_example; // {String} 
var opts = {
  'replaceActiveState': true, // {Boolean} 
  'oAuthV2ResourceServerType':  // {OAuthV2ResourceServerType} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)
            var resourceId = resourceId_example;  // String |  (default to null)
            var replaceActiveState = true;  // Boolean |  (optional)  (default to null)
            var oAuthV2ResourceServerType = new OAuthV2ResourceServerType(); // OAuthV2ResourceServerType |  (optional) 

            try {
                // Edit a resource server
                OAuthV2ResourceServerType result = apiInstance.editResourceServer(module, setupId, resourceId, replaceActiveState, oAuthV2ResourceServerType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.editResourceServer: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 
$resourceId = resourceId_example; // String | 
$replaceActiveState = true; // Boolean | 
$oAuthV2ResourceServerType = ; // OAuthV2ResourceServerType | 

try {
    $result = $api_instance->editResourceServer($module, $setupId, $resourceId, $replaceActiveState, $oAuthV2ResourceServerType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->editResourceServer: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 
my $resourceId = resourceId_example; # String | 
my $replaceActiveState = true; # Boolean | 
my $oAuthV2ResourceServerType = WWW::OPenAPIClient::Object::OAuthV2ResourceServerType->new(); # OAuthV2ResourceServerType | 

eval {
    my $result = $api_instance->editResourceServer(module => $module, setupId => $setupId, resourceId => $resourceId, replaceActiveState => $replaceActiveState, oAuthV2ResourceServerType => $oAuthV2ResourceServerType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->editResourceServer: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)
resourceId = resourceId_example # String |  (default to null)
replaceActiveState = true # Boolean |  (optional) (default to null)
oAuthV2ResourceServerType =  # OAuthV2ResourceServerType |  (optional)

try:
    # Edit a resource server
    api_response = api_instance.edit_resource_server(module, setupId, resourceId, replaceActiveState=replaceActiveState, oAuthV2ResourceServerType=oAuthV2ResourceServerType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->editResourceServer: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String
    let resourceId = resourceId_example; // String
    let replaceActiveState = true; // Boolean
    let oAuthV2ResourceServerType = ; // OAuthV2ResourceServerType

    let mut context = DefaultApi::Context::default();
    let result = client.editResourceServer(module, setupId, resourceId, replaceActiveState, oAuthV2ResourceServerType, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        OAuthV2SetupType oAuthV2SetupType = ; // OAuthV2SetupType | 

        try {
            OAuthV2SetupType result = apiInstance.editSetup(module, setupId, oAuthV2SetupType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#editSetup");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 
final OAuthV2SetupType oAuthV2SetupType = new OAuthV2SetupType(); // OAuthV2SetupType | 

try {
    final result = await api_instance.editSetup(module, setupId, oAuthV2SetupType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->editSetup: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        OAuthV2SetupType oAuthV2SetupType = ; // OAuthV2SetupType | 

        try {
            OAuthV2SetupType result = apiInstance.editSetup(module, setupId, oAuthV2SetupType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#editSetup");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)
OAuthV2SetupType *oAuthV2SetupType = ; //  (optional)

// Edit a setup
[apiInstance editSetupWith:module
    setupId:setupId
    oAuthV2SetupType:oAuthV2SetupType
              completionHandler: ^(OAuthV2SetupType output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 
var opts = {
  'oAuthV2SetupType':  // {OAuthV2SetupType} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)
            var oAuthV2SetupType = new OAuthV2SetupType(); // OAuthV2SetupType |  (optional) 

            try {
                // Edit a setup
                OAuthV2SetupType result = apiInstance.editSetup(module, setupId, oAuthV2SetupType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.editSetup: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 
$oAuthV2SetupType = ; // OAuthV2SetupType | 

try {
    $result = $api_instance->editSetup($module, $setupId, $oAuthV2SetupType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->editSetup: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 
my $oAuthV2SetupType = WWW::OPenAPIClient::Object::OAuthV2SetupType->new(); # OAuthV2SetupType | 

eval {
    my $result = $api_instance->editSetup(module => $module, setupId => $setupId, oAuthV2SetupType => $oAuthV2SetupType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->editSetup: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)
oAuthV2SetupType =  # OAuthV2SetupType |  (optional)

try:
    # Edit a setup
    api_response = api_instance.edit_setup(module, setupId, oAuthV2SetupType=oAuthV2SetupType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->editSetup: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String
    let oAuthV2SetupType = ; // OAuthV2SetupType

    let mut context = DefaultApi::Context::default();
    let result = client.editSetup(module, setupId, oAuthV2SetupType, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 

        try {
            'String' result = apiInstance.getAllClientNamesOfSetup(module, setupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getAllClientNamesOfSetup");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 

        try {
            'String' result = apiInstance.getAllClientNamesOfSetup(module, setupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getAllClientNamesOfSetup");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)

// Return all client names of a setup
[apiInstance getAllClientNamesOfSetupWith:module
    setupId:setupId
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)

            try {
                // Return all client names of a setup
                'String' result = apiInstance.getAllClientNamesOfSetup(module, setupId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getAllClientNamesOfSetup: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 

try {
    $result = $api_instance->getAllClientNamesOfSetup($module, $setupId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getAllClientNamesOfSetup: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 

eval {
    my $result = $api_instance->getAllClientNamesOfSetup(module => $module, setupId => $setupId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getAllClientNamesOfSetup: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)

try:
    # Return all client names of a setup
    api_response = api_instance.get_all_client_names_of_setup(module, setupId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getAllClientNamesOfSetup: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getAllClientNamesOfSetup(module, setupId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String setup = setup_example; // String | 
        String user = user_example; // String | 
        String lang = lang_example; // String | 

        try {
            array[PersistedConsentType] result = apiInstance.getAllPersistedConsentsOfSetup(setup, user, lang);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getAllPersistedConsentsOfSetup");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String setup = new String(); // String | 
final String user = new String(); // String | 
final String lang = new String(); // String | 

try {
    final result = await api_instance.getAllPersistedConsentsOfSetup(setup, user, lang);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getAllPersistedConsentsOfSetup: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String setup = setup_example; // String | 
        String user = user_example; // String | 
        String lang = lang_example; // String | 

        try {
            array[PersistedConsentType] result = apiInstance.getAllPersistedConsentsOfSetup(setup, user, lang);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getAllPersistedConsentsOfSetup");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *setup = setup_example; //  (default to null)
String *user = user_example; //  (optional) (default to null)
String *lang = lang_example; //  (optional) (default to null)

// Return persisted consents of a setup
[apiInstance getAllPersistedConsentsOfSetupWith:setup
    user:user
    lang:lang
              completionHandler: ^(array[PersistedConsentType] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var setup = setup_example; // {String} 
var opts = {
  'user': user_example, // {String} 
  'lang': lang_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var setup = setup_example;  // String |  (default to null)
            var user = user_example;  // String |  (optional)  (default to null)
            var lang = lang_example;  // String |  (optional)  (default to null)

            try {
                // Return persisted consents of a setup
                array[PersistedConsentType] result = apiInstance.getAllPersistedConsentsOfSetup(setup, user, lang);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getAllPersistedConsentsOfSetup: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$setup = setup_example; // String | 
$user = user_example; // String | 
$lang = lang_example; // String | 

try {
    $result = $api_instance->getAllPersistedConsentsOfSetup($setup, $user, $lang);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getAllPersistedConsentsOfSetup: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $setup = setup_example; # String | 
my $user = user_example; # String | 
my $lang = lang_example; # String | 

eval {
    my $result = $api_instance->getAllPersistedConsentsOfSetup(setup => $setup, user => $user, lang => $lang);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getAllPersistedConsentsOfSetup: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
setup = setup_example # String |  (default to null)
user = user_example # String |  (optional) (default to null)
lang = lang_example # String |  (optional) (default to null)

try:
    # Return persisted consents of a setup
    api_response = api_instance.get_all_persisted_consents_of_setup(setup, user=user, lang=lang)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getAllPersistedConsentsOfSetup: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let setup = setup_example; // String
    let user = user_example; // String
    let lang = lang_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getAllPersistedConsentsOfSetup(setup, user, lang, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String clientId = clientId_example; // String | 

        try {
            OAuthV2ClientType result = apiInstance.getClient(module, setupId, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getClient");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 
final String clientId = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String clientId = clientId_example; // String | 

        try {
            OAuthV2ClientType result = apiInstance.getClient(module, setupId, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getClient");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)
String *clientId = clientId_example; //  (default to null)

// Return a client
[apiInstance getClientWith:module
    setupId:setupId
    clientId:clientId
              completionHandler: ^(OAuthV2ClientType output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 
var clientId = clientId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)
            var clientId = clientId_example;  // String |  (default to null)

            try {
                // Return a client
                OAuthV2ClientType result = apiInstance.getClient(module, setupId, clientId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getClient: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 
$clientId = clientId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 
my $clientId = clientId_example; # String | 

eval {
    my $result = $api_instance->getClient(module => $module, setupId => $setupId, clientId => $clientId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getClient: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)
clientId = clientId_example # String |  (default to null)

try:
    # Return a client
    api_response = api_instance.get_client(module, setupId, clientId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getClient: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String
    let clientId = clientId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getClient(module, setupId, clientId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 

        try {
            clientIds result = apiInstance.getClientOfSetup(module, setupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getClientOfSetup");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 

        try {
            clientIds result = apiInstance.getClientOfSetup(module, setupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getClientOfSetup");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)

// Return client ids of a setup
[apiInstance getClientOfSetupWith:module
    setupId:setupId
              completionHandler: ^(clientIds output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)

            try {
                // Return client ids of a setup
                clientIds result = apiInstance.getClientOfSetup(module, setupId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getClientOfSetup: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 

try {
    $result = $api_instance->getClientOfSetup($module, $setupId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getClientOfSetup: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 

eval {
    my $result = $api_instance->getClientOfSetup(module => $module, setupId => $setupId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getClientOfSetup: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)

try:
    # Return client ids of a setup
    api_response = api_instance.get_client_of_setup(module, setupId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getClientOfSetup: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getClientOfSetup(module, setupId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String oAuthClientId = oAuthClientId_example; // String | 

        try {
            'String' result = apiInstance.getEntityClientIdByOAuthClientId(module, setupId, oAuthClientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getEntityClientIdByOAuthClientId");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 
final String oAuthClientId = new String(); // String | 

try {
    final result = await api_instance.getEntityClientIdByOAuthClientId(module, setupId, oAuthClientId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getEntityClientIdByOAuthClientId: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String oAuthClientId = oAuthClientId_example; // String | 

        try {
            'String' result = apiInstance.getEntityClientIdByOAuthClientId(module, setupId, oAuthClientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getEntityClientIdByOAuthClientId");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)
String *oAuthClientId = oAuthClientId_example; //  (optional) (default to null)

// Return an internal id of client equivalent to OAuth ClientId
[apiInstance getEntityClientIdByOAuthClientIdWith:module
    setupId:setupId
    oAuthClientId:oAuthClientId
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 
var opts = {
  'oAuthClientId': oAuthClientId_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)
            var oAuthClientId = oAuthClientId_example;  // String |  (optional)  (default to null)

            try {
                // Return an internal id of client equivalent to OAuth ClientId
                'String' result = apiInstance.getEntityClientIdByOAuthClientId(module, setupId, oAuthClientId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getEntityClientIdByOAuthClientId: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 
$oAuthClientId = oAuthClientId_example; // String | 

try {
    $result = $api_instance->getEntityClientIdByOAuthClientId($module, $setupId, $oAuthClientId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getEntityClientIdByOAuthClientId: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 
my $oAuthClientId = oAuthClientId_example; # String | 

eval {
    my $result = $api_instance->getEntityClientIdByOAuthClientId(module => $module, setupId => $setupId, oAuthClientId => $oAuthClientId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getEntityClientIdByOAuthClientId: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)
oAuthClientId = oAuthClientId_example # String |  (optional) (default to null)

try:
    # Return an internal id of client equivalent to OAuth ClientId
    api_response = api_instance.get_entity_client_id_by_o_auth_client_id(module, setupId, oAuthClientId=oAuthClientId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getEntityClientIdByOAuthClientId: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String
    let oAuthClientId = oAuthClientId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getEntityClientIdByOAuthClientId(module, setupId, oAuthClientId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String setupId = setupId_example; // String | 
        String clientEntityId = clientEntityId_example; // String | 
        String user = user_example; // String | 
        Integer page = 56; // Integer | 
        Integer size = 56; // Integer | 

        try {
            PersistedConsentType result = apiInstance.getPersistedConsents(setupId, clientEntityId, user, page, size);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getPersistedConsents");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String setupId = new String(); // String | 
final String clientEntityId = new String(); // String | 
final String user = new String(); // String | 
final Integer page = new Integer(); // Integer | 
final Integer size = new Integer(); // Integer | 

try {
    final result = await api_instance.getPersistedConsents(setupId, clientEntityId, user, page, size);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getPersistedConsents: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String setupId = setupId_example; // String | 
        String clientEntityId = clientEntityId_example; // String | 
        String user = user_example; // String | 
        Integer page = 56; // Integer | 
        Integer size = 56; // Integer | 

        try {
            PersistedConsentType result = apiInstance.getPersistedConsents(setupId, clientEntityId, user, page, size);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getPersistedConsents");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *setupId = setupId_example; //  (default to null)
String *clientEntityId = clientEntityId_example; //  (optional) (default to null)
String *user = user_example; //  (optional) (default to null)
Integer *page = 56; //  (optional) (default to null)
Integer *size = 56; //  (optional) (default to null)

// Return a persisted consents of a setup
[apiInstance getPersistedConsentsWith:setupId
    clientEntityId:clientEntityId
    user:user
    page:page
    size:size
              completionHandler: ^(PersistedConsentType output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var setupId = setupId_example; // {String} 
var opts = {
  'clientEntityId': clientEntityId_example, // {String} 
  'user': user_example, // {String} 
  'page': 56, // {Integer} 
  'size': 56 // {Integer} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var setupId = setupId_example;  // String |  (default to null)
            var clientEntityId = clientEntityId_example;  // String |  (optional)  (default to null)
            var user = user_example;  // String |  (optional)  (default to null)
            var page = 56;  // Integer |  (optional)  (default to null)
            var size = 56;  // Integer |  (optional)  (default to null)

            try {
                // Return a persisted consents of a setup
                PersistedConsentType result = apiInstance.getPersistedConsents(setupId, clientEntityId, user, page, size);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getPersistedConsents: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$setupId = setupId_example; // String | 
$clientEntityId = clientEntityId_example; // String | 
$user = user_example; // String | 
$page = 56; // Integer | 
$size = 56; // Integer | 

try {
    $result = $api_instance->getPersistedConsents($setupId, $clientEntityId, $user, $page, $size);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getPersistedConsents: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $setupId = setupId_example; # String | 
my $clientEntityId = clientEntityId_example; # String | 
my $user = user_example; # String | 
my $page = 56; # Integer | 
my $size = 56; # Integer | 

eval {
    my $result = $api_instance->getPersistedConsents(setupId => $setupId, clientEntityId => $clientEntityId, user => $user, page => $page, size => $size);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getPersistedConsents: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
setupId = setupId_example # String |  (default to null)
clientEntityId = clientEntityId_example # String |  (optional) (default to null)
user = user_example # String |  (optional) (default to null)
page = 56 # Integer |  (optional) (default to null)
size = 56 # Integer |  (optional) (default to null)

try:
    # Return a persisted consents of a setup
    api_response = api_instance.get_persisted_consents(setupId, clientEntityId=clientEntityId, user=user, page=page, size=size)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getPersistedConsents: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let setupId = setupId_example; // String
    let clientEntityId = clientEntityId_example; // String
    let user = user_example; // String
    let page = 56; // Integer
    let size = 56; // Integer

    let mut context = DefaultApi::Context::default();
    let result = client.getPersistedConsents(setupId, clientEntityId, user, page, size, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String resourceId = resourceId_example; // String | 

        try {
            Response result = apiInstance.getResourceServer(module, setupId, resourceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getResourceServer");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 
final String resourceId = new String(); // String | 

try {
    final result = await api_instance.getResourceServer(module, setupId, resourceId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getResourceServer: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String resourceId = resourceId_example; // String | 

        try {
            Response result = apiInstance.getResourceServer(module, setupId, resourceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getResourceServer");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)
String *resourceId = resourceId_example; //  (default to null)

// Return a resource server
[apiInstance getResourceServerWith:module
    setupId:setupId
    resourceId:resourceId
              completionHandler: ^(Response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 
var resourceId = resourceId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)
            var resourceId = resourceId_example;  // String |  (default to null)

            try {
                // Return a resource server
                Response result = apiInstance.getResourceServer(module, setupId, resourceId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getResourceServer: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 
$resourceId = resourceId_example; // String | 

try {
    $result = $api_instance->getResourceServer($module, $setupId, $resourceId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getResourceServer: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 
my $resourceId = resourceId_example; # String | 

eval {
    my $result = $api_instance->getResourceServer(module => $module, setupId => $setupId, resourceId => $resourceId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getResourceServer: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)
resourceId = resourceId_example # String |  (default to null)

try:
    # Return a resource server
    api_response = api_instance.get_resource_server(module, setupId, resourceId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getResourceServer: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String
    let resourceId = resourceId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getResourceServer(module, setupId, resourceId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 

        try {
            Response result = apiInstance.getResourceServersOfSetup(module, setupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getResourceServersOfSetup");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 

        try {
            Response result = apiInstance.getResourceServersOfSetup(module, setupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getResourceServersOfSetup");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)

// Return resource servers of a setup
[apiInstance getResourceServersOfSetupWith:module
    setupId:setupId
              completionHandler: ^(Response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)

            try {
                // Return resource servers of a setup
                Response result = apiInstance.getResourceServersOfSetup(module, setupId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getResourceServersOfSetup: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 

try {
    $result = $api_instance->getResourceServersOfSetup($module, $setupId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getResourceServersOfSetup: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 

eval {
    my $result = $api_instance->getResourceServersOfSetup(module => $module, setupId => $setupId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getResourceServersOfSetup: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)

try:
    # Return resource servers of a setup
    api_response = api_instance.get_resource_servers_of_setup(module, setupId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getResourceServersOfSetup: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getResourceServersOfSetup(module, setupId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 

        try {
            OAuthV2SetupType result = apiInstance.getSetup(module, setupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSetup");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 

        try {
            OAuthV2SetupType result = apiInstance.getSetup(module, setupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSetup");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)

// Return a setup
[apiInstance getSetupWith:module
    setupId:setupId
              completionHandler: ^(OAuthV2SetupType output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)

            try {
                // Return a setup
                OAuthV2SetupType result = apiInstance.getSetup(module, setupId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getSetup: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 

try {
    $result = $api_instance->getSetup($module, $setupId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getSetup: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 

eval {
    my $result = $api_instance->getSetup(module => $module, setupId => $setupId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getSetup: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)

try:
    # Return a setup
    api_response = api_instance.get_setup(module, setupId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getSetup: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getSetup(module, setupId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 

        try {
            setupIds result = apiInstance.getSetupsOfModule(module);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSetupsOfModule");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 

        try {
            setupIds result = apiInstance.getSetupsOfModule(module);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSetupsOfModule");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)

// Return all setups of a module
[apiInstance getSetupsOfModuleWith:module
              completionHandler: ^(setupIds output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)

            try {
                // Return all setups of a module
                setupIds result = apiInstance.getSetupsOfModule(module);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getSetupsOfModule: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)

try:
    # Return all setups of a module
    api_response = api_instance.get_setups_of_module(module)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getSetupsOfModule: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getSetupsOfModule(module, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String clientId = clientId_example; // String | 
        String snapshotId = snapshotId_example; // String | 

        try {
            OAuthV2ClientType result = apiInstance.getSnapshot(module, setupId, clientId, snapshotId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSnapshot");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 
final String clientId = new String(); // String | 
final String snapshotId = new String(); // String | 

try {
    final result = await api_instance.getSnapshot(module, setupId, clientId, snapshotId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getSnapshot: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String clientId = clientId_example; // String | 
        String snapshotId = snapshotId_example; // String | 

        try {
            OAuthV2ClientType result = apiInstance.getSnapshot(module, setupId, clientId, snapshotId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSnapshot");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)
String *clientId = clientId_example; //  (default to null)
String *snapshotId = snapshotId_example; //  (default to null)

// Return a snapshot of a client
[apiInstance getSnapshotWith:module
    setupId:setupId
    clientId:clientId
    snapshotId:snapshotId
              completionHandler: ^(OAuthV2ClientType output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 
var clientId = clientId_example; // {String} 
var snapshotId = snapshotId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSnapshot(module, setupId, clientId, snapshotId, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)
            var clientId = clientId_example;  // String |  (default to null)
            var snapshotId = snapshotId_example;  // String |  (default to null)

            try {
                // Return a snapshot of a client
                OAuthV2ClientType result = apiInstance.getSnapshot(module, setupId, clientId, snapshotId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getSnapshot: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 
$clientId = clientId_example; // String | 
$snapshotId = snapshotId_example; // String | 

try {
    $result = $api_instance->getSnapshot($module, $setupId, $clientId, $snapshotId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getSnapshot: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 
my $clientId = clientId_example; # String | 
my $snapshotId = snapshotId_example; # String | 

eval {
    my $result = $api_instance->getSnapshot(module => $module, setupId => $setupId, clientId => $clientId, snapshotId => $snapshotId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getSnapshot: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)
clientId = clientId_example # String |  (default to null)
snapshotId = snapshotId_example # String |  (default to null)

try:
    # Return a snapshot of a client
    api_response = api_instance.get_snapshot(module, setupId, clientId, snapshotId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getSnapshot: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String
    let clientId = clientId_example; // String
    let snapshotId = snapshotId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getSnapshot(module, setupId, clientId, snapshotId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String resourceId = resourceId_example; // String | 
        String snapshotId = snapshotId_example; // String | 

        try {
            OAuthV2ResourceServerType result = apiInstance.getSnapshot1(module, setupId, resourceId, snapshotId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSnapshot1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 
final String resourceId = new String(); // String | 
final String snapshotId = new String(); // String | 

try {
    final result = await api_instance.getSnapshot1(module, setupId, resourceId, snapshotId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getSnapshot1: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String resourceId = resourceId_example; // String | 
        String snapshotId = snapshotId_example; // String | 

        try {
            OAuthV2ResourceServerType result = apiInstance.getSnapshot1(module, setupId, resourceId, snapshotId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSnapshot1");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)
String *resourceId = resourceId_example; //  (default to null)
String *snapshotId = snapshotId_example; //  (default to null)

// Return a snapshot of a resource server
[apiInstance getSnapshot1With:module
    setupId:setupId
    resourceId:resourceId
    snapshotId:snapshotId
              completionHandler: ^(OAuthV2ResourceServerType output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 
var resourceId = resourceId_example; // {String} 
var snapshotId = snapshotId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSnapshot1(module, setupId, resourceId, snapshotId, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)
            var resourceId = resourceId_example;  // String |  (default to null)
            var snapshotId = snapshotId_example;  // String |  (default to null)

            try {
                // Return a snapshot of a resource server
                OAuthV2ResourceServerType result = apiInstance.getSnapshot1(module, setupId, resourceId, snapshotId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getSnapshot1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 
$resourceId = resourceId_example; // String | 
$snapshotId = snapshotId_example; // String | 

try {
    $result = $api_instance->getSnapshot1($module, $setupId, $resourceId, $snapshotId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getSnapshot1: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 
my $resourceId = resourceId_example; # String | 
my $snapshotId = snapshotId_example; # String | 

eval {
    my $result = $api_instance->getSnapshot1(module => $module, setupId => $setupId, resourceId => $resourceId, snapshotId => $snapshotId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getSnapshot1: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)
resourceId = resourceId_example # String |  (default to null)
snapshotId = snapshotId_example # String |  (default to null)

try:
    # Return a snapshot of a resource server
    api_response = api_instance.get_snapshot1(module, setupId, resourceId, snapshotId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getSnapshot1: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String
    let resourceId = resourceId_example; // String
    let snapshotId = snapshotId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getSnapshot1(module, setupId, resourceId, snapshotId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String snapshotId = snapshotId_example; // String | 

        try {
            OAuthV2SetupType result = apiInstance.getSnapshot2(module, setupId, snapshotId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSnapshot2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 
final String snapshotId = new String(); // String | 

try {
    final result = await api_instance.getSnapshot2(module, setupId, snapshotId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getSnapshot2: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String snapshotId = snapshotId_example; // String | 

        try {
            OAuthV2SetupType result = apiInstance.getSnapshot2(module, setupId, snapshotId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSnapshot2");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)
String *snapshotId = snapshotId_example; //  (default to null)

// Return a snapshot of a setup
[apiInstance getSnapshot2With:module
    setupId:setupId
    snapshotId:snapshotId
              completionHandler: ^(OAuthV2SetupType output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 
var snapshotId = snapshotId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)
            var snapshotId = snapshotId_example;  // String |  (default to null)

            try {
                // Return a snapshot of a setup
                OAuthV2SetupType result = apiInstance.getSnapshot2(module, setupId, snapshotId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getSnapshot2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 
$snapshotId = snapshotId_example; // String | 

try {
    $result = $api_instance->getSnapshot2($module, $setupId, $snapshotId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getSnapshot2: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 
my $snapshotId = snapshotId_example; # String | 

eval {
    my $result = $api_instance->getSnapshot2(module => $module, setupId => $setupId, snapshotId => $snapshotId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getSnapshot2: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)
snapshotId = snapshotId_example # String |  (default to null)

try:
    # Return a snapshot of a setup
    api_response = api_instance.get_snapshot2(module, setupId, snapshotId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getSnapshot2: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String
    let snapshotId = snapshotId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getSnapshot2(module, setupId, snapshotId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String clientId = clientId_example; // String | 
        Date validAt = 2013-10-20T19:20:30+01:00; // Date | 
        Boolean includeSoftDeletedStates = true; // Boolean | 

        try {
            snapshotIds result = apiInstance.getSnapshotsOfClient(module, setupId, clientId, validAt, includeSoftDeletedStates);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSnapshotsOfClient");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 
final String clientId = new String(); // String | 
final Date validAt = new Date(); // Date | 
final Boolean includeSoftDeletedStates = new Boolean(); // Boolean | 

try {
    final result = await api_instance.getSnapshotsOfClient(module, setupId, clientId, validAt, includeSoftDeletedStates);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getSnapshotsOfClient: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String clientId = clientId_example; // String | 
        Date validAt = 2013-10-20T19:20:30+01:00; // Date | 
        Boolean includeSoftDeletedStates = true; // Boolean | 

        try {
            snapshotIds result = apiInstance.getSnapshotsOfClient(module, setupId, clientId, validAt, includeSoftDeletedStates);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSnapshotsOfClient");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)
String *clientId = clientId_example; //  (default to null)
Date *validAt = 2013-10-20T19:20:30+01:00; //  (optional) (default to null)
Boolean *includeSoftDeletedStates = true; //  (optional) (default to null)

// Return all snapshot ids of a client
[apiInstance getSnapshotsOfClientWith:module
    setupId:setupId
    clientId:clientId
    validAt:validAt
    includeSoftDeletedStates:includeSoftDeletedStates
              completionHandler: ^(snapshotIds output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 
var clientId = clientId_example; // {String} 
var opts = {
  'validAt': 2013-10-20T19:20:30+01:00, // {Date} 
  'includeSoftDeletedStates': true // {Boolean} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)
            var clientId = clientId_example;  // String |  (default to null)
            var validAt = 2013-10-20T19:20:30+01:00;  // Date |  (optional)  (default to null)
            var includeSoftDeletedStates = true;  // Boolean |  (optional)  (default to null)

            try {
                // Return all snapshot ids of a client
                snapshotIds result = apiInstance.getSnapshotsOfClient(module, setupId, clientId, validAt, includeSoftDeletedStates);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getSnapshotsOfClient: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 
$clientId = clientId_example; // String | 
$validAt = 2013-10-20T19:20:30+01:00; // Date | 
$includeSoftDeletedStates = true; // Boolean | 

try {
    $result = $api_instance->getSnapshotsOfClient($module, $setupId, $clientId, $validAt, $includeSoftDeletedStates);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getSnapshotsOfClient: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 
my $clientId = clientId_example; # String | 
my $validAt = 2013-10-20T19:20:30+01:00; # Date | 
my $includeSoftDeletedStates = true; # Boolean | 

eval {
    my $result = $api_instance->getSnapshotsOfClient(module => $module, setupId => $setupId, clientId => $clientId, validAt => $validAt, includeSoftDeletedStates => $includeSoftDeletedStates);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getSnapshotsOfClient: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)
clientId = clientId_example # String |  (default to null)
validAt = 2013-10-20T19:20:30+01:00 # Date |  (optional) (default to null)
includeSoftDeletedStates = true # Boolean |  (optional) (default to null)

try:
    # Return all snapshot ids of a client
    api_response = api_instance.get_snapshots_of_client(module, setupId, clientId, validAt=validAt, includeSoftDeletedStates=includeSoftDeletedStates)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getSnapshotsOfClient: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String
    let clientId = clientId_example; // String
    let validAt = 2013-10-20T19:20:30+01:00; // Date
    let includeSoftDeletedStates = true; // Boolean

    let mut context = DefaultApi::Context::default();
    let result = client.getSnapshotsOfClient(module, setupId, clientId, validAt, includeSoftDeletedStates, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String resourceId = resourceId_example; // String | 
        Date validAt = 2013-10-20T19:20:30+01:00; // Date | 
        Boolean includeSoftDeletedStates = true; // Boolean | 

        try {
            snapshotIds result = apiInstance.getSnapshotsOfResourceServer(module, setupId, resourceId, validAt, includeSoftDeletedStates);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSnapshotsOfResourceServer");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 
final String resourceId = new String(); // String | 
final Date validAt = new Date(); // Date | 
final Boolean includeSoftDeletedStates = new Boolean(); // Boolean | 

try {
    final result = await api_instance.getSnapshotsOfResourceServer(module, setupId, resourceId, validAt, includeSoftDeletedStates);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getSnapshotsOfResourceServer: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String resourceId = resourceId_example; // String | 
        Date validAt = 2013-10-20T19:20:30+01:00; // Date | 
        Boolean includeSoftDeletedStates = true; // Boolean | 

        try {
            snapshotIds result = apiInstance.getSnapshotsOfResourceServer(module, setupId, resourceId, validAt, includeSoftDeletedStates);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSnapshotsOfResourceServer");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)
String *resourceId = resourceId_example; //  (default to null)
Date *validAt = 2013-10-20T19:20:30+01:00; //  (optional) (default to null)
Boolean *includeSoftDeletedStates = true; //  (optional) (default to null)

// Return all snapshots of a resource server
[apiInstance getSnapshotsOfResourceServerWith:module
    setupId:setupId
    resourceId:resourceId
    validAt:validAt
    includeSoftDeletedStates:includeSoftDeletedStates
              completionHandler: ^(snapshotIds output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 
var resourceId = resourceId_example; // {String} 
var opts = {
  'validAt': 2013-10-20T19:20:30+01:00, // {Date} 
  'includeSoftDeletedStates': true // {Boolean} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)
            var resourceId = resourceId_example;  // String |  (default to null)
            var validAt = 2013-10-20T19:20:30+01:00;  // Date |  (optional)  (default to null)
            var includeSoftDeletedStates = true;  // Boolean |  (optional)  (default to null)

            try {
                // Return all snapshots of a resource server
                snapshotIds result = apiInstance.getSnapshotsOfResourceServer(module, setupId, resourceId, validAt, includeSoftDeletedStates);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getSnapshotsOfResourceServer: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 
$resourceId = resourceId_example; // String | 
$validAt = 2013-10-20T19:20:30+01:00; // Date | 
$includeSoftDeletedStates = true; // Boolean | 

try {
    $result = $api_instance->getSnapshotsOfResourceServer($module, $setupId, $resourceId, $validAt, $includeSoftDeletedStates);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getSnapshotsOfResourceServer: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 
my $resourceId = resourceId_example; # String | 
my $validAt = 2013-10-20T19:20:30+01:00; # Date | 
my $includeSoftDeletedStates = true; # Boolean | 

eval {
    my $result = $api_instance->getSnapshotsOfResourceServer(module => $module, setupId => $setupId, resourceId => $resourceId, validAt => $validAt, includeSoftDeletedStates => $includeSoftDeletedStates);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getSnapshotsOfResourceServer: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)
resourceId = resourceId_example # String |  (default to null)
validAt = 2013-10-20T19:20:30+01:00 # Date |  (optional) (default to null)
includeSoftDeletedStates = true # Boolean |  (optional) (default to null)

try:
    # Return all snapshots of a resource server
    api_response = api_instance.get_snapshots_of_resource_server(module, setupId, resourceId, validAt=validAt, includeSoftDeletedStates=includeSoftDeletedStates)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getSnapshotsOfResourceServer: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String
    let resourceId = resourceId_example; // String
    let validAt = 2013-10-20T19:20:30+01:00; // Date
    let includeSoftDeletedStates = true; // Boolean

    let mut context = DefaultApi::Context::default();
    let result = client.getSnapshotsOfResourceServer(module, setupId, resourceId, validAt, includeSoftDeletedStates, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        Date validAt = 2013-10-20T19:20:30+01:00; // Date | 
        Boolean includeSoftDeletedStates = true; // Boolean | 

        try {
            snapshotIds result = apiInstance.getSnapshotsOfSetup(module, setupId, validAt, includeSoftDeletedStates);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSnapshotsOfSetup");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 
final Date validAt = new Date(); // Date | 
final Boolean includeSoftDeletedStates = new Boolean(); // Boolean | 

try {
    final result = await api_instance.getSnapshotsOfSetup(module, setupId, validAt, includeSoftDeletedStates);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getSnapshotsOfSetup: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        Date validAt = 2013-10-20T19:20:30+01:00; // Date | 
        Boolean includeSoftDeletedStates = true; // Boolean | 

        try {
            snapshotIds result = apiInstance.getSnapshotsOfSetup(module, setupId, validAt, includeSoftDeletedStates);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSnapshotsOfSetup");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)
Date *validAt = 2013-10-20T19:20:30+01:00; //  (optional) (default to null)
Boolean *includeSoftDeletedStates = true; //  (optional) (default to null)

// Return all snapshots of a setup
[apiInstance getSnapshotsOfSetupWith:module
    setupId:setupId
    validAt:validAt
    includeSoftDeletedStates:includeSoftDeletedStates
              completionHandler: ^(snapshotIds output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 
var opts = {
  'validAt': 2013-10-20T19:20:30+01:00, // {Date} 
  'includeSoftDeletedStates': true // {Boolean} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)
            var validAt = 2013-10-20T19:20:30+01:00;  // Date |  (optional)  (default to null)
            var includeSoftDeletedStates = true;  // Boolean |  (optional)  (default to null)

            try {
                // Return all snapshots of a setup
                snapshotIds result = apiInstance.getSnapshotsOfSetup(module, setupId, validAt, includeSoftDeletedStates);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getSnapshotsOfSetup: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 
$validAt = 2013-10-20T19:20:30+01:00; // Date | 
$includeSoftDeletedStates = true; // Boolean | 

try {
    $result = $api_instance->getSnapshotsOfSetup($module, $setupId, $validAt, $includeSoftDeletedStates);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getSnapshotsOfSetup: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 
my $validAt = 2013-10-20T19:20:30+01:00; # Date | 
my $includeSoftDeletedStates = true; # Boolean | 

eval {
    my $result = $api_instance->getSnapshotsOfSetup(module => $module, setupId => $setupId, validAt => $validAt, includeSoftDeletedStates => $includeSoftDeletedStates);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getSnapshotsOfSetup: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)
validAt = 2013-10-20T19:20:30+01:00 # Date |  (optional) (default to null)
includeSoftDeletedStates = true # Boolean |  (optional) (default to null)

try:
    # Return all snapshots of a setup
    api_response = api_instance.get_snapshots_of_setup(module, setupId, validAt=validAt, includeSoftDeletedStates=includeSoftDeletedStates)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getSnapshotsOfSetup: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String
    let validAt = 2013-10-20T19:20:30+01:00; // Date
    let includeSoftDeletedStates = true; // Boolean

    let mut context = DefaultApi::Context::default();
    let result = client.getSnapshotsOfSetup(module, setupId, validAt, includeSoftDeletedStates, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String setupId = setupId_example; // String | 
        String value = value_example; // String | 

        try {
            RefreshTokenType result = apiInstance.getToken(setupId, value);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getToken");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String setupId = new String(); // String | 
final String value = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String setupId = setupId_example; // String | 
        String value = value_example; // String | 

        try {
            RefreshTokenType result = apiInstance.getToken(setupId, value);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getToken");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *setupId = setupId_example; //  (default to null)
String *value = value_example; //  (default to null)

// Return a refresh token
[apiInstance getTokenWith:setupId
    value:value
              completionHandler: ^(RefreshTokenType output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var setupId = setupId_example; // {String} 
var value = value_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var setupId = setupId_example;  // String |  (default to null)
            var value = value_example;  // String |  (default to null)

            try {
                // Return a refresh token
                RefreshTokenType result = apiInstance.getToken(setupId, value);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getToken: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$setupId = setupId_example; // String | 
$value = value_example; // String | 

try {
    $result = $api_instance->getToken($setupId, $value);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getToken: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $setupId = setupId_example; # String | 
my $value = value_example; # String | 

eval {
    my $result = $api_instance->getToken(setupId => $setupId, value => $value);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getToken: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
setupId = setupId_example # String |  (default to null)
value = value_example # String |  (default to null)

try:
    # Return a refresh token
    api_response = api_instance.get_token(setupId, value)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getToken: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let setupId = setupId_example; // String
    let value = value_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getToken(setupId, value, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String setup = setup_example; // String | 
        String token = token_example; // String | 

        try {
            RefreshTokenType result = apiInstance.getToken1(setup, token);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getToken1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String setup = new String(); // String | 
final String token = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String setup = setup_example; // String | 
        String token = token_example; // String | 

        try {
            RefreshTokenType result = apiInstance.getToken1(setup, token);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getToken1");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *setup = setup_example; //  (default to null)
String *token = token_example; //  (default to null)

// Return a refresh token
[apiInstance getToken1With:setup
    token:token
              completionHandler: ^(RefreshTokenType output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var setup = setup_example; // {String} 
var token = token_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var setup = setup_example;  // String |  (default to null)
            var token = token_example;  // String |  (default to null)

            try {
                // Return a refresh token
                RefreshTokenType result = apiInstance.getToken1(setup, token);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getToken1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$setup = setup_example; // String | 
$token = token_example; // String | 

try {
    $result = $api_instance->getToken1($setup, $token);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getToken1: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $setup = setup_example; # String | 
my $token = token_example; # String | 

eval {
    my $result = $api_instance->getToken1(setup => $setup, token => $token);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getToken1: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
setup = setup_example # String |  (default to null)
token = token_example # String |  (default to null)

try:
    # Return a refresh token
    api_response = api_instance.get_token1(setup, token)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getToken1: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let setup = setup_example; // String
    let token = token_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getToken1(setup, token, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String setup = setup_example; // String | 
        String user = user_example; // String | 
        String lang = lang_example; // String | 

        try {
            array[RefreshTokenType] result = apiInstance.listRefreshTokens(setup, user, lang);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#listRefreshTokens");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String setup = new String(); // String | 
final String user = new String(); // String | 
final String lang = new String(); // String | 

try {
    final result = await api_instance.listRefreshTokens(setup, user, lang);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listRefreshTokens: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String setup = setup_example; // String | 
        String user = user_example; // String | 
        String lang = lang_example; // String | 

        try {
            array[RefreshTokenType] result = apiInstance.listRefreshTokens(setup, user, lang);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#listRefreshTokens");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *setup = setup_example; //  (default to null)
String *user = user_example; //  (optional) (default to null)
String *lang = lang_example; //  (optional) (default to null)

// Return all refresh tokens of a user
[apiInstance listRefreshTokensWith:setup
    user:user
    lang:lang
              completionHandler: ^(array[RefreshTokenType] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var setup = setup_example; // {String} 
var opts = {
  'user': user_example, // {String} 
  'lang': lang_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var setup = setup_example;  // String |  (default to null)
            var user = user_example;  // String |  (optional)  (default to null)
            var lang = lang_example;  // String |  (optional)  (default to null)

            try {
                // Return all refresh tokens of a user
                array[RefreshTokenType] result = apiInstance.listRefreshTokens(setup, user, lang);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.listRefreshTokens: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$setup = setup_example; // String | 
$user = user_example; // String | 
$lang = lang_example; // String | 

try {
    $result = $api_instance->listRefreshTokens($setup, $user, $lang);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->listRefreshTokens: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $setup = setup_example; # String | 
my $user = user_example; # String | 
my $lang = lang_example; # String | 

eval {
    my $result = $api_instance->listRefreshTokens(setup => $setup, user => $user, lang => $lang);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->listRefreshTokens: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
setup = setup_example # String |  (default to null)
user = user_example # String |  (optional) (default to null)
lang = lang_example # String |  (optional) (default to null)

try:
    # Return all refresh tokens of a user
    api_response = api_instance.list_refresh_tokens(setup, user=user, lang=lang)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->listRefreshTokens: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let setup = setup_example; // String
    let user = user_example; // String
    let lang = lang_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.listRefreshTokens(setup, user, lang, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String setupId = setupId_example; // String | 
        String clientEntityId = clientEntityId_example; // String | 
        String user = user_example; // String | 
        String lang = lang_example; // String | 
        Boolean latest = true; // Boolean | 
        Integer page = 56; // Integer | 
        Integer size = 56; // Integer | 

        try {
            RefreshTokenType result = apiInstance.listRefreshTokensWithPagination(setupId, clientEntityId, user, lang, latest, page, size);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#listRefreshTokensWithPagination");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String setupId = new String(); // String | 
final String clientEntityId = new String(); // String | 
final String user = new String(); // String | 
final String lang = new String(); // String | 
final Boolean latest = new Boolean(); // Boolean | 
final Integer page = new Integer(); // Integer | 
final Integer size = new Integer(); // Integer | 

try {
    final result = await api_instance.listRefreshTokensWithPagination(setupId, clientEntityId, user, lang, latest, page, size);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listRefreshTokensWithPagination: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String setupId = setupId_example; // String | 
        String clientEntityId = clientEntityId_example; // String | 
        String user = user_example; // String | 
        String lang = lang_example; // String | 
        Boolean latest = true; // Boolean | 
        Integer page = 56; // Integer | 
        Integer size = 56; // Integer | 

        try {
            RefreshTokenType result = apiInstance.listRefreshTokensWithPagination(setupId, clientEntityId, user, lang, latest, page, size);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#listRefreshTokensWithPagination");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *setupId = setupId_example; //  (default to null)
String *clientEntityId = clientEntityId_example; //  (optional) (default to null)
String *user = user_example; //  (optional) (default to null)
String *lang = lang_example; //  (optional) (default to null)
Boolean *latest = true; //  (optional) (default to false)
Integer *page = 56; //  (optional) (default to null)
Integer *size = 56; //  (optional) (default to null)

// Return all refresh tokens of a setup
[apiInstance listRefreshTokensWithPaginationWith:setupId
    clientEntityId:clientEntityId
    user:user
    lang:lang
    latest:latest
    page:page
    size:size
              completionHandler: ^(RefreshTokenType output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var setupId = setupId_example; // {String} 
var opts = {
  'clientEntityId': clientEntityId_example, // {String} 
  'user': user_example, // {String} 
  'lang': lang_example, // {String} 
  'latest': true, // {Boolean} 
  'page': 56, // {Integer} 
  'size': 56 // {Integer} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var setupId = setupId_example;  // String |  (default to null)
            var clientEntityId = clientEntityId_example;  // String |  (optional)  (default to null)
            var user = user_example;  // String |  (optional)  (default to null)
            var lang = lang_example;  // String |  (optional)  (default to null)
            var latest = true;  // Boolean |  (optional)  (default to false)
            var page = 56;  // Integer |  (optional)  (default to null)
            var size = 56;  // Integer |  (optional)  (default to null)

            try {
                // Return all refresh tokens of a setup
                RefreshTokenType result = apiInstance.listRefreshTokensWithPagination(setupId, clientEntityId, user, lang, latest, page, size);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.listRefreshTokensWithPagination: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$setupId = setupId_example; // String | 
$clientEntityId = clientEntityId_example; // String | 
$user = user_example; // String | 
$lang = lang_example; // String | 
$latest = true; // Boolean | 
$page = 56; // Integer | 
$size = 56; // Integer | 

try {
    $result = $api_instance->listRefreshTokensWithPagination($setupId, $clientEntityId, $user, $lang, $latest, $page, $size);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->listRefreshTokensWithPagination: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $setupId = setupId_example; # String | 
my $clientEntityId = clientEntityId_example; # String | 
my $user = user_example; # String | 
my $lang = lang_example; # String | 
my $latest = true; # Boolean | 
my $page = 56; # Integer | 
my $size = 56; # Integer | 

eval {
    my $result = $api_instance->listRefreshTokensWithPagination(setupId => $setupId, clientEntityId => $clientEntityId, user => $user, lang => $lang, latest => $latest, page => $page, size => $size);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->listRefreshTokensWithPagination: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
setupId = setupId_example # String |  (default to null)
clientEntityId = clientEntityId_example # String |  (optional) (default to null)
user = user_example # String |  (optional) (default to null)
lang = lang_example # String |  (optional) (default to null)
latest = true # Boolean |  (optional) (default to false)
page = 56 # Integer |  (optional) (default to null)
size = 56 # Integer |  (optional) (default to null)

try:
    # Return all refresh tokens of a setup
    api_response = api_instance.list_refresh_tokens_with_pagination(setupId, clientEntityId=clientEntityId, user=user, lang=lang, latest=latest, page=page, size=size)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->listRefreshTokensWithPagination: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let setupId = setupId_example; // String
    let clientEntityId = clientEntityId_example; // String
    let user = user_example; // String
    let lang = lang_example; // String
    let latest = true; // Boolean
    let page = 56; // Integer
    let size = 56; // Integer

    let mut context = DefaultApi::Context::default();
    let result = client.listRefreshTokensWithPagination(setupId, clientEntityId, user, lang, latest, page, size, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String clientId = clientId_example; // String | 

        try {
            apiInstance.removeClient(module, setupId, clientId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#removeClient");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 
final String clientId = new String(); // String | 

try {
    final result = await api_instance.removeClient(module, setupId, clientId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->removeClient: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String clientId = clientId_example; // String | 

        try {
            apiInstance.removeClient(module, setupId, clientId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#removeClient");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)
String *clientId = clientId_example; //  (default to null)

// Delete a client
[apiInstance removeClientWith:module
    setupId:setupId
    clientId:clientId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 
var clientId = clientId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)
            var clientId = clientId_example;  // String |  (default to null)

            try {
                // Delete a client
                apiInstance.removeClient(module, setupId, clientId);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.removeClient: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 
$clientId = clientId_example; // String | 

try {
    $api_instance->removeClient($module, $setupId, $clientId);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->removeClient: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 
my $clientId = clientId_example; # String | 

eval {
    $api_instance->removeClient(module => $module, setupId => $setupId, clientId => $clientId);
};
if ($@) {
    warn "Exception when calling DefaultApi->removeClient: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)
clientId = clientId_example # String |  (default to null)

try:
    # Delete a client
    api_instance.remove_client(module, setupId, clientId)
except ApiException as e:
    print("Exception when calling DefaultApi->removeClient: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String
    let clientId = clientId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.removeClient(module, setupId, clientId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String resourceId = resourceId_example; // String | 

        try {
            apiInstance.removeResourceServer(module, setupId, resourceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#removeResourceServer");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 
final String resourceId = new String(); // String | 

try {
    final result = await api_instance.removeResourceServer(module, setupId, resourceId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->removeResourceServer: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        String resourceId = resourceId_example; // String | 

        try {
            apiInstance.removeResourceServer(module, setupId, resourceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#removeResourceServer");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)
String *resourceId = resourceId_example; //  (default to null)

// Delete a resource server
[apiInstance removeResourceServerWith:module
    setupId:setupId
    resourceId:resourceId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 
var resourceId = resourceId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)
            var resourceId = resourceId_example;  // String |  (default to null)

            try {
                // Delete a resource server
                apiInstance.removeResourceServer(module, setupId, resourceId);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.removeResourceServer: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 
$resourceId = resourceId_example; // String | 

try {
    $api_instance->removeResourceServer($module, $setupId, $resourceId);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->removeResourceServer: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 
my $resourceId = resourceId_example; # String | 

eval {
    $api_instance->removeResourceServer(module => $module, setupId => $setupId, resourceId => $resourceId);
};
if ($@) {
    warn "Exception when calling DefaultApi->removeResourceServer: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)
resourceId = resourceId_example # String |  (default to null)

try:
    # Delete a resource server
    api_instance.remove_resource_server(module, setupId, resourceId)
except ApiException as e:
    print("Exception when calling DefaultApi->removeResourceServer: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String
    let resourceId = resourceId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.removeResourceServer(module, setupId, resourceId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 

        try {
            apiInstance.removeSetup(module, setupId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#removeSetup");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 

        try {
            apiInstance.removeSetup(module, setupId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#removeSetup");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)

// Delete a setup
[apiInstance removeSetupWith:module
    setupId:setupId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)

            try {
                // Delete a setup
                apiInstance.removeSetup(module, setupId);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.removeSetup: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 

try {
    $api_instance->removeSetup($module, $setupId);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->removeSetup: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 

eval {
    $api_instance->removeSetup(module => $module, setupId => $setupId);
};
if ($@) {
    warn "Exception when calling DefaultApi->removeSetup: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)

try:
    # Delete a setup
    api_instance.remove_setup(module, setupId)
except ApiException as e:
    print("Exception when calling DefaultApi->removeSetup: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.removeSetup(module, setupId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        OAuthV3ClientTypeExt oAuthV3ClientTypeExt = ; // OAuthV3ClientTypeExt | 

        try {
            client_id result = apiInstance.test(module, setupId, oAuthV3ClientTypeExt);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#test");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String module = new String(); // String | 
final String setupId = new String(); // String | 
final OAuthV3ClientTypeExt oAuthV3ClientTypeExt = new OAuthV3ClientTypeExt(); // OAuthV3ClientTypeExt | 

try {
    final result = await api_instance.test(module, setupId, oAuthV3ClientTypeExt);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->test: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String module = module_example; // String | 
        String setupId = setupId_example; // String | 
        OAuthV3ClientTypeExt oAuthV3ClientTypeExt = ; // OAuthV3ClientTypeExt | 

        try {
            client_id result = apiInstance.test(module, setupId, oAuthV3ClientTypeExt);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#test");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *module = module_example; //  (default to null)
String *setupId = setupId_example; //  (default to null)
OAuthV3ClientTypeExt *oAuthV3ClientTypeExt = ; //  (optional)

// Create a client of a setup
[apiInstance testWith:module
    setupId:setupId
    oAuthV3ClientTypeExt:oAuthV3ClientTypeExt
              completionHandler: ^(client_id output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApi = require('open_api');

// Create an instance of the API class
var api = new OpenApi.DefaultApi()
var module = module_example; // {String} 
var setupId = setupId_example; // {String} 
var opts = {
  'oAuthV3ClientTypeExt':  // {OAuthV3ClientTypeExt} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var module = module_example;  // String |  (default to null)
            var setupId = setupId_example;  // String |  (default to null)
            var oAuthV3ClientTypeExt = new OAuthV3ClientTypeExt(); // OAuthV3ClientTypeExt |  (optional) 

            try {
                // Create a client of a setup
                client_id result = apiInstance.test(module, setupId, oAuthV3ClientTypeExt);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.test: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$module = module_example; // String | 
$setupId = setupId_example; // String | 
$oAuthV3ClientTypeExt = ; // OAuthV3ClientTypeExt | 

try {
    $result = $api_instance->test($module, $setupId, $oAuthV3ClientTypeExt);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->test: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $module = module_example; # String | 
my $setupId = setupId_example; # String | 
my $oAuthV3ClientTypeExt = WWW::OPenAPIClient::Object::OAuthV3ClientTypeExt->new(); # OAuthV3ClientTypeExt | 

eval {
    my $result = $api_instance->test(module => $module, setupId => $setupId, oAuthV3ClientTypeExt => $oAuthV3ClientTypeExt);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->test: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
module = module_example # String |  (default to null)
setupId = setupId_example # String |  (default to null)
oAuthV3ClientTypeExt =  # OAuthV3ClientTypeExt |  (optional)

try:
    # Create a client of a setup
    api_response = api_instance.test(module, setupId, oAuthV3ClientTypeExt=oAuthV3ClientTypeExt)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->test: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let module = module_example; // String
    let setupId = setupId_example; // String
    let oAuthV3ClientTypeExt = ; // OAuthV3ClientTypeExt

    let mut context = DefaultApi::Context::default();
    let result = client.test(module, setupId, oAuthV3ClientTypeExt, &context).wait();

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