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

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

public class AuthenticationApiExample {

    public static void main(String[] args) {
        
        AuthenticationApi apiInstance = new AuthenticationApi();
        AuthRequest data = ; // AuthRequest | Login credentials
        try {
            AuthResponse result = apiInstance.login(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthenticationApi#login");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AuthenticationApi;

public class AuthenticationApiExample {

    public static void main(String[] args) {
        AuthenticationApi apiInstance = new AuthenticationApi();
        AuthRequest data = ; // AuthRequest | Login credentials
        try {
            AuthResponse result = apiInstance.login(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthenticationApi#login");
            e.printStackTrace();
        }
    }
}

AuthRequest *data = ; // Login credentials

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

// Login
[apiInstance loginWith:data
              completionHandler: ^(AuthResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenTodoApi = require('open_todo_api');

var api = new OpenTodoApi.AuthenticationApi()

var data = ; // {AuthRequest} Login credentials


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

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

namespace Example
{
    public class loginExample
    {
        public void main()
        {
            
            var apiInstance = new AuthenticationApi();
            var data = new AuthRequest(); // AuthRequest | Login credentials

            try
            {
                // Login
                AuthResponse result = apiInstance.login(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthenticationApi.login: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AuthenticationApi();
$data = ; // AuthRequest | Login credentials

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

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

my $api_instance = WWW::SwaggerClient::AuthenticationApi->new();
my $data = WWW::SwaggerClient::Object::AuthRequest->new(); # AuthRequest | Login credentials

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

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

# create an instance of the API class
api_instance = swagger_client.AuthenticationApi()
data =  # AuthRequest | Login credentials

try: 
    # Login
    api_response = api_instance.login(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthenticationApi->login: %s\n" % e)

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

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

public class AuthenticationApiExample {

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

        AuthenticationApi apiInstance = new AuthenticationApi();
        try {
            AuthLogoutResponse result = apiInstance.logout();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthenticationApi#logout");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AuthenticationApi;

public class AuthenticationApiExample {

    public static void main(String[] args) {
        AuthenticationApi apiInstance = new AuthenticationApi();
        try {
            AuthLogoutResponse result = apiInstance.logout();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthenticationApi#logout");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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


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

// Logout a specific token
[apiInstance logoutWithCompletionHandler: 
              ^(AuthLogoutResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenTodoApi = require('open_todo_api');
var defaultClient = OpenTodoApi.ApiClient.instance;

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

var api = new OpenTodoApi.AuthenticationApi()

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

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

namespace Example
{
    public class logoutExample
    {
        public void main()
        {
            
            // Configure API key authorization: JWT
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new AuthenticationApi();

            try
            {
                // Logout a specific token
                AuthLogoutResponse result = apiInstance.logout();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthenticationApi.logout: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new Swagger\Client\Api\AuthenticationApi();

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

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

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

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

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

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

# Configure API key authorization: JWT
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

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

try: 
    # Logout a specific token
    api_response = api_instance.logout()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthenticationApi->logout: %s\n" % e)

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

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

public class AuthenticationApiExample {

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

        AuthenticationApi apiInstance = new AuthenticationApi();
        try {
            AuthLogoutResponse result = apiInstance.logoutAll();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthenticationApi#logoutAll");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AuthenticationApi;

public class AuthenticationApiExample {

    public static void main(String[] args) {
        AuthenticationApi apiInstance = new AuthenticationApi();
        try {
            AuthLogoutResponse result = apiInstance.logoutAll();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthenticationApi#logoutAll");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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


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

// Logout all tokens from my username
[apiInstance logoutAllWithCompletionHandler: 
              ^(AuthLogoutResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenTodoApi = require('open_todo_api');
var defaultClient = OpenTodoApi.ApiClient.instance;

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

var api = new OpenTodoApi.AuthenticationApi()

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

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

namespace Example
{
    public class logoutAllExample
    {
        public void main()
        {
            
            // Configure API key authorization: JWT
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new AuthenticationApi();

            try
            {
                // Logout all tokens from my username
                AuthLogoutResponse result = apiInstance.logoutAll();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthenticationApi.logoutAll: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new Swagger\Client\Api\AuthenticationApi();

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

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

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

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

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

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

# Configure API key authorization: JWT
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

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

try: 
    # Logout all tokens from my username
    api_response = api_instance.logout_all()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthenticationApi->logoutAll: %s\n" % e)

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

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

public class ScopesApiExample {

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

        ScopesApi apiInstance = new ScopesApi();
        ScopeRequest scope = ; // ScopeRequest | Scope to create
        try {
            ScopeResponse result = apiInstance.createScope(scope);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScopesApi#createScope");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ScopesApi;

public class ScopesApiExample {

    public static void main(String[] args) {
        ScopesApi apiInstance = new ScopesApi();
        ScopeRequest scope = ; // ScopeRequest | Scope to create
        try {
            ScopeResponse result = apiInstance.createScope(scope);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScopesApi#createScope");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

ScopeRequest *scope = ; // Scope to create

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

// Create a scope
[apiInstance createScopeWith:scope
              completionHandler: ^(ScopeResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenTodoApi = require('open_todo_api');
var defaultClient = OpenTodoApi.ApiClient.instance;

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

var api = new OpenTodoApi.ScopesApi()

var scope = ; // {ScopeRequest} Scope to create


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

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

namespace Example
{
    public class createScopeExample
    {
        public void main()
        {
            
            // Configure API key authorization: JWT
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new ScopesApi();
            var scope = new ScopeRequest(); // ScopeRequest | Scope to create

            try
            {
                // Create a scope
                ScopeResponse result = apiInstance.createScope(scope);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ScopesApi.createScope: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new Swagger\Client\Api\ScopesApi();
$scope = ; // ScopeRequest | Scope to create

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

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

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

my $api_instance = WWW::SwaggerClient::ScopesApi->new();
my $scope = WWW::SwaggerClient::Object::ScopeRequest->new(); # ScopeRequest | Scope to create

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

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

# Configure API key authorization: JWT
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ScopesApi()
scope =  # ScopeRequest | Scope to create

try: 
    # Create a scope
    api_response = api_instance.create_scope(scope)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ScopesApi->createScope: %s\n" % e)

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

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

public class ScopesApiExample {

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

        ScopesApi apiInstance = new ScopesApi();
        UUID id = ; // UUID | The scopes id
        try {
            ScopeResponse result = apiInstance.deleteScope(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScopesApi#deleteScope");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ScopesApi;

public class ScopesApiExample {

    public static void main(String[] args) {
        ScopesApi apiInstance = new ScopesApi();
        UUID id = ; // UUID | The scopes id
        try {
            ScopeResponse result = apiInstance.deleteScope(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScopesApi#deleteScope");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

UUID *id = ; // The scopes id

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

// Delete a specific scope
[apiInstance deleteScopeWith:id
              completionHandler: ^(ScopeResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenTodoApi = require('open_todo_api');
var defaultClient = OpenTodoApi.ApiClient.instance;

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

var api = new OpenTodoApi.ScopesApi()

var id = ; // {UUID} The scopes id


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

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

namespace Example
{
    public class deleteScopeExample
    {
        public void main()
        {
            
            // Configure API key authorization: JWT
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new ScopesApi();
            var id = new UUID(); // UUID | The scopes id

            try
            {
                // Delete a specific scope
                ScopeResponse result = apiInstance.deleteScope(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ScopesApi.deleteScope: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new Swagger\Client\Api\ScopesApi();
$id = ; // UUID | The scopes id

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

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

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

my $api_instance = WWW::SwaggerClient::ScopesApi->new();
my $id = ; # UUID | The scopes id

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

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

# Configure API key authorization: JWT
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ScopesApi()
id =  # UUID | The scopes id

try: 
    # Delete a specific scope
    api_response = api_instance.delete_scope(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ScopesApi->deleteScope: %s\n" % e)

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

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

public class ScopesApiExample {

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

        ScopesApi apiInstance = new ScopesApi();
        UUID id = ; // UUID | The scopes id
        try {
            array[ScopeResponse] result = apiInstance.findChildScopes(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScopesApi#findChildScopes");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ScopesApi;

public class ScopesApiExample {

    public static void main(String[] args) {
        ScopesApi apiInstance = new ScopesApi();
        UUID id = ; // UUID | The scopes id
        try {
            array[ScopeResponse] result = apiInstance.findChildScopes(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScopesApi#findChildScopes");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

UUID *id = ; // The scopes id

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

// Find all children of specific scope
[apiInstance findChildScopesWith:id
              completionHandler: ^(array[ScopeResponse] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenTodoApi = require('open_todo_api');
var defaultClient = OpenTodoApi.ApiClient.instance;

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

var api = new OpenTodoApi.ScopesApi()

var id = ; // {UUID} The scopes id


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

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

namespace Example
{
    public class findChildScopesExample
    {
        public void main()
        {
            
            // Configure API key authorization: JWT
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new ScopesApi();
            var id = new UUID(); // UUID | The scopes id

            try
            {
                // Find all children of specific scope
                array[ScopeResponse] result = apiInstance.findChildScopes(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ScopesApi.findChildScopes: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new Swagger\Client\Api\ScopesApi();
$id = ; // UUID | The scopes id

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

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

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

my $api_instance = WWW::SwaggerClient::ScopesApi->new();
my $id = ; # UUID | The scopes id

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

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

# Configure API key authorization: JWT
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ScopesApi()
id =  # UUID | The scopes id

try: 
    # Find all children of specific scope
    api_response = api_instance.find_child_scopes(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ScopesApi->findChildScopes: %s\n" % e)

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

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

public class ScopesApiExample {

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

        ScopesApi apiInstance = new ScopesApi();
        try {
            array[ScopeResponse] result = apiInstance.findScopes();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScopesApi#findScopes");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ScopesApi;

public class ScopesApiExample {

    public static void main(String[] args) {
        ScopesApi apiInstance = new ScopesApi();
        try {
            array[ScopeResponse] result = apiInstance.findScopes();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScopesApi#findScopes");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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


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

// Find all scopes
[apiInstance findScopesWithCompletionHandler: 
              ^(array[ScopeResponse] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenTodoApi = require('open_todo_api');
var defaultClient = OpenTodoApi.ApiClient.instance;

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

var api = new OpenTodoApi.ScopesApi()

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

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

namespace Example
{
    public class findScopesExample
    {
        public void main()
        {
            
            // Configure API key authorization: JWT
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new ScopesApi();

            try
            {
                // Find all scopes
                array[ScopeResponse] result = apiInstance.findScopes();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ScopesApi.findScopes: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new Swagger\Client\Api\ScopesApi();

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

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

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

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

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

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

# Configure API key authorization: JWT
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

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

try: 
    # Find all scopes
    api_response = api_instance.find_scopes()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ScopesApi->findScopes: %s\n" % e)

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

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

public class ScopesApiExample {

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

        ScopesApi apiInstance = new ScopesApi();
        UUID id = ; // UUID | The scopes id
        try {
            ScopeResponse result = apiInstance.getScope(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScopesApi#getScope");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ScopesApi;

public class ScopesApiExample {

    public static void main(String[] args) {
        ScopesApi apiInstance = new ScopesApi();
        UUID id = ; // UUID | The scopes id
        try {
            ScopeResponse result = apiInstance.getScope(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScopesApi#getScope");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

UUID *id = ; // The scopes id

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

// Get a specific scope
[apiInstance getScopeWith:id
              completionHandler: ^(ScopeResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenTodoApi = require('open_todo_api');
var defaultClient = OpenTodoApi.ApiClient.instance;

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

var api = new OpenTodoApi.ScopesApi()

var id = ; // {UUID} The scopes id


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

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

namespace Example
{
    public class getScopeExample
    {
        public void main()
        {
            
            // Configure API key authorization: JWT
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new ScopesApi();
            var id = new UUID(); // UUID | The scopes id

            try
            {
                // Get a specific scope
                ScopeResponse result = apiInstance.getScope(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ScopesApi.getScope: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new Swagger\Client\Api\ScopesApi();
$id = ; // UUID | The scopes id

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

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

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

my $api_instance = WWW::SwaggerClient::ScopesApi->new();
my $id = ; # UUID | The scopes id

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

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

# Configure API key authorization: JWT
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ScopesApi()
id =  # UUID | The scopes id

try: 
    # Get a specific scope
    api_response = api_instance.get_scope(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ScopesApi->getScope: %s\n" % e)

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

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

public class ScopesApiExample {

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

        ScopesApi apiInstance = new ScopesApi();
        UUID id = ; // UUID | The scopes id
        ScopeRequest scope = ; // ScopeRequest | The update request
        try {
            ScopeResponse result = apiInstance.updateScope(id, scope);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScopesApi#updateScope");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ScopesApi;

public class ScopesApiExample {

    public static void main(String[] args) {
        ScopesApi apiInstance = new ScopesApi();
        UUID id = ; // UUID | The scopes id
        ScopeRequest scope = ; // ScopeRequest | The update request
        try {
            ScopeResponse result = apiInstance.updateScope(id, scope);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScopesApi#updateScope");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

UUID *id = ; // The scopes id
ScopeRequest *scope = ; // The update request

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

// Update a specific scope
[apiInstance updateScopeWith:id
    scope:scope
              completionHandler: ^(ScopeResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenTodoApi = require('open_todo_api');
var defaultClient = OpenTodoApi.ApiClient.instance;

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

var api = new OpenTodoApi.ScopesApi()

var id = ; // {UUID} The scopes id

var scope = ; // {ScopeRequest} The update request


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

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

namespace Example
{
    public class updateScopeExample
    {
        public void main()
        {
            
            // Configure API key authorization: JWT
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new ScopesApi();
            var id = new UUID(); // UUID | The scopes id
            var scope = new ScopeRequest(); // ScopeRequest | The update request

            try
            {
                // Update a specific scope
                ScopeResponse result = apiInstance.updateScope(id, scope);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ScopesApi.updateScope: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new Swagger\Client\Api\ScopesApi();
$id = ; // UUID | The scopes id
$scope = ; // ScopeRequest | The update request

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

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

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

my $api_instance = WWW::SwaggerClient::ScopesApi->new();
my $id = ; # UUID | The scopes id
my $scope = WWW::SwaggerClient::Object::ScopeRequest->new(); # ScopeRequest | The update request

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

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

# Configure API key authorization: JWT
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ScopesApi()
id =  # UUID | The scopes id
scope =  # ScopeRequest | The update request

try: 
    # Update a specific scope
    api_response = api_instance.update_scope(id, scope)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ScopesApi->updateScope: %s\n" % e)

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

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

public class TodosApiExample {

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

        TodosApi apiInstance = new TodosApi();
        UUID scope = ; // UUID | The scopes id
        TodoRequest todo = ; // TodoRequest | Todo to Create
        try {
            TodoResponse result = apiInstance.createTodo(scope, todo);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TodosApi#createTodo");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TodosApi;

public class TodosApiExample {

    public static void main(String[] args) {
        TodosApi apiInstance = new TodosApi();
        UUID scope = ; // UUID | The scopes id
        TodoRequest todo = ; // TodoRequest | Todo to Create
        try {
            TodoResponse result = apiInstance.createTodo(scope, todo);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TodosApi#createTodo");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

UUID *scope = ; // The scopes id
TodoRequest *todo = ; // Todo to Create

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

// Create a todo in scope
[apiInstance createTodoWith:scope
    todo:todo
              completionHandler: ^(TodoResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenTodoApi = require('open_todo_api');
var defaultClient = OpenTodoApi.ApiClient.instance;

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

var api = new OpenTodoApi.TodosApi()

var scope = ; // {UUID} The scopes id

var todo = ; // {TodoRequest} Todo to Create


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

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

namespace Example
{
    public class createTodoExample
    {
        public void main()
        {
            
            // Configure API key authorization: JWT
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new TodosApi();
            var scope = new UUID(); // UUID | The scopes id
            var todo = new TodoRequest(); // TodoRequest | Todo to Create

            try
            {
                // Create a todo in scope
                TodoResponse result = apiInstance.createTodo(scope, todo);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TodosApi.createTodo: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new Swagger\Client\Api\TodosApi();
$scope = ; // UUID | The scopes id
$todo = ; // TodoRequest | Todo to Create

try {
    $result = $api_instance->createTodo($scope, $todo);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TodosApi->createTodo: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

my $api_instance = WWW::SwaggerClient::TodosApi->new();
my $scope = ; # UUID | The scopes id
my $todo = WWW::SwaggerClient::Object::TodoRequest->new(); # TodoRequest | Todo to Create

eval { 
    my $result = $api_instance->createTodo(scope => $scope, todo => $todo);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TodosApi->createTodo: $@\n";
}

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

# Configure API key authorization: JWT
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.TodosApi()
scope =  # UUID | The scopes id
todo =  # TodoRequest | Todo to Create

try: 
    # Create a todo in scope
    api_response = api_instance.create_todo(scope, todo)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TodosApi->createTodo: %s\n" % e)

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

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

public class TodosApiExample {

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

        TodosApi apiInstance = new TodosApi();
        UUID id = ; // UUID | The todos id
        UUID scope = ; // UUID | The scopes id
        try {
            TodoResponse result = apiInstance.deleteTodo(id, scope);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TodosApi#deleteTodo");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TodosApi;

public class TodosApiExample {

    public static void main(String[] args) {
        TodosApi apiInstance = new TodosApi();
        UUID id = ; // UUID | The todos id
        UUID scope = ; // UUID | The scopes id
        try {
            TodoResponse result = apiInstance.deleteTodo(id, scope);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TodosApi#deleteTodo");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

UUID *id = ; // The todos id
UUID *scope = ; // The scopes id

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

// Delete specific todo in scope
[apiInstance deleteTodoWith:id
    scope:scope
              completionHandler: ^(TodoResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenTodoApi = require('open_todo_api');
var defaultClient = OpenTodoApi.ApiClient.instance;

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

var api = new OpenTodoApi.TodosApi()

var id = ; // {UUID} The todos id

var scope = ; // {UUID} The scopes id


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

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

namespace Example
{
    public class deleteTodoExample
    {
        public void main()
        {
            
            // Configure API key authorization: JWT
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new TodosApi();
            var id = new UUID(); // UUID | The todos id
            var scope = new UUID(); // UUID | The scopes id

            try
            {
                // Delete specific todo in scope
                TodoResponse result = apiInstance.deleteTodo(id, scope);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TodosApi.deleteTodo: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new Swagger\Client\Api\TodosApi();
$id = ; // UUID | The todos id
$scope = ; // UUID | The scopes id

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

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

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

my $api_instance = WWW::SwaggerClient::TodosApi->new();
my $id = ; # UUID | The todos id
my $scope = ; # UUID | The scopes id

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

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

# Configure API key authorization: JWT
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.TodosApi()
id =  # UUID | The todos id
scope =  # UUID | The scopes id

try: 
    # Delete specific todo in scope
    api_response = api_instance.delete_todo(id, scope)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TodosApi->deleteTodo: %s\n" % e)

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

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

public class TodosApiExample {

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

        TodosApi apiInstance = new TodosApi();
        UUID scope = ; // UUID | The scopes id
        try {
            array[TodoResponse] result = apiInstance.findTodos(scope);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TodosApi#findTodos");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TodosApi;

public class TodosApiExample {

    public static void main(String[] args) {
        TodosApi apiInstance = new TodosApi();
        UUID scope = ; // UUID | The scopes id
        try {
            array[TodoResponse] result = apiInstance.findTodos(scope);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TodosApi#findTodos");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

UUID *scope = ; // The scopes id

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

// Find all todos in scope
[apiInstance findTodosWith:scope
              completionHandler: ^(array[TodoResponse] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenTodoApi = require('open_todo_api');
var defaultClient = OpenTodoApi.ApiClient.instance;

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

var api = new OpenTodoApi.TodosApi()

var scope = ; // {UUID} The scopes id


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

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

namespace Example
{
    public class findTodosExample
    {
        public void main()
        {
            
            // Configure API key authorization: JWT
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new TodosApi();
            var scope = new UUID(); // UUID | The scopes id

            try
            {
                // Find all todos in scope
                array[TodoResponse] result = apiInstance.findTodos(scope);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TodosApi.findTodos: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new Swagger\Client\Api\TodosApi();
$scope = ; // UUID | The scopes id

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

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

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

my $api_instance = WWW::SwaggerClient::TodosApi->new();
my $scope = ; # UUID | The scopes id

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

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

# Configure API key authorization: JWT
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.TodosApi()
scope =  # UUID | The scopes id

try: 
    # Find all todos in scope
    api_response = api_instance.find_todos(scope)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TodosApi->findTodos: %s\n" % e)

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

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

public class TodosApiExample {

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

        TodosApi apiInstance = new TodosApi();
        UUID id = ; // UUID | The todos id
        UUID scope = ; // UUID | The scopes id
        try {
            TodoResponse result = apiInstance.getTodo(id, scope);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TodosApi#getTodo");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TodosApi;

public class TodosApiExample {

    public static void main(String[] args) {
        TodosApi apiInstance = new TodosApi();
        UUID id = ; // UUID | The todos id
        UUID scope = ; // UUID | The scopes id
        try {
            TodoResponse result = apiInstance.getTodo(id, scope);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TodosApi#getTodo");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

UUID *id = ; // The todos id
UUID *scope = ; // The scopes id

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

// Get specific todo in scope
[apiInstance getTodoWith:id
    scope:scope
              completionHandler: ^(TodoResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenTodoApi = require('open_todo_api');
var defaultClient = OpenTodoApi.ApiClient.instance;

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

var api = new OpenTodoApi.TodosApi()

var id = ; // {UUID} The todos id

var scope = ; // {UUID} The scopes id


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

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

namespace Example
{
    public class getTodoExample
    {
        public void main()
        {
            
            // Configure API key authorization: JWT
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new TodosApi();
            var id = new UUID(); // UUID | The todos id
            var scope = new UUID(); // UUID | The scopes id

            try
            {
                // Get specific todo in scope
                TodoResponse result = apiInstance.getTodo(id, scope);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TodosApi.getTodo: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new Swagger\Client\Api\TodosApi();
$id = ; // UUID | The todos id
$scope = ; // UUID | The scopes id

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

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

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

my $api_instance = WWW::SwaggerClient::TodosApi->new();
my $id = ; # UUID | The todos id
my $scope = ; # UUID | The scopes id

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

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

# Configure API key authorization: JWT
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.TodosApi()
id =  # UUID | The todos id
scope =  # UUID | The scopes id

try: 
    # Get specific todo in scope
    api_response = api_instance.get_todo(id, scope)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TodosApi->getTodo: %s\n" % e)

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

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

public class TodosApiExample {

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

        TodosApi apiInstance = new TodosApi();
        UUID id = ; // UUID | The todos id
        UUID scope = ; // UUID | The scopes id
        TodoRequest todo = ; // TodoRequest | The update request
        try {
            TodoResponse result = apiInstance.updateTodo(id, scope, todo);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TodosApi#updateTodo");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TodosApi;

public class TodosApiExample {

    public static void main(String[] args) {
        TodosApi apiInstance = new TodosApi();
        UUID id = ; // UUID | The todos id
        UUID scope = ; // UUID | The scopes id
        TodoRequest todo = ; // TodoRequest | The update request
        try {
            TodoResponse result = apiInstance.updateTodo(id, scope, todo);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TodosApi#updateTodo");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

UUID *id = ; // The todos id
UUID *scope = ; // The scopes id
TodoRequest *todo = ; // The update request

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

// Update specific todo in scope
[apiInstance updateTodoWith:id
    scope:scope
    todo:todo
              completionHandler: ^(TodoResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenTodoApi = require('open_todo_api');
var defaultClient = OpenTodoApi.ApiClient.instance;

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

var api = new OpenTodoApi.TodosApi()

var id = ; // {UUID} The todos id

var scope = ; // {UUID} The scopes id

var todo = ; // {TodoRequest} The update request


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

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

namespace Example
{
    public class updateTodoExample
    {
        public void main()
        {
            
            // Configure API key authorization: JWT
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new TodosApi();
            var id = new UUID(); // UUID | The todos id
            var scope = new UUID(); // UUID | The scopes id
            var todo = new TodoRequest(); // TodoRequest | The update request

            try
            {
                // Update specific todo in scope
                TodoResponse result = apiInstance.updateTodo(id, scope, todo);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TodosApi.updateTodo: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new Swagger\Client\Api\TodosApi();
$id = ; // UUID | The todos id
$scope = ; // UUID | The scopes id
$todo = ; // TodoRequest | The update request

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

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

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

my $api_instance = WWW::SwaggerClient::TodosApi->new();
my $id = ; # UUID | The todos id
my $scope = ; # UUID | The scopes id
my $todo = WWW::SwaggerClient::Object::TodoRequest->new(); # TodoRequest | The update request

eval { 
    my $result = $api_instance->updateTodo(id => $id, scope => $scope, todo => $todo);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TodosApi->updateTodo: $@\n";
}

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

# Configure API key authorization: JWT
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.TodosApi()
id =  # UUID | The todos id
scope =  # UUID | The scopes id
todo =  # TodoRequest | The update request

try: 
    # Update specific todo in scope
    api_response = api_instance.update_todo(id, scope, todo)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TodosApi->updateTodo: %s\n" % e)

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

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

public class UsersApiExample {

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

        UsersApi apiInstance = new UsersApi();
        UserRequest user = ; // UserRequest | User to create
        try {
            UserResponse result = apiInstance.createUser(user);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#createUser");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        UserRequest user = ; // UserRequest | User to create
        try {
            UserResponse result = apiInstance.createUser(user);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#createUser");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

UserRequest *user = ; // User to create

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

// Create a user
[apiInstance createUserWith:user
              completionHandler: ^(UserResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenTodoApi = require('open_todo_api');
var defaultClient = OpenTodoApi.ApiClient.instance;

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

var api = new OpenTodoApi.UsersApi()

var user = ; // {UserRequest} User to create


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

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

namespace Example
{
    public class createUserExample
    {
        public void main()
        {
            
            // Configure API key authorization: JWT
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new UsersApi();
            var user = new UserRequest(); // UserRequest | User to create

            try
            {
                // Create a user
                UserResponse result = apiInstance.createUser(user);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.createUser: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new Swagger\Client\Api\UsersApi();
$user = ; // UserRequest | User to create

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

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

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

my $api_instance = WWW::SwaggerClient::UsersApi->new();
my $user = WWW::SwaggerClient::Object::UserRequest->new(); # UserRequest | User to create

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

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

# Configure API key authorization: JWT
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.UsersApi()
user =  # UserRequest | User to create

try: 
    # Create a user
    api_response = api_instance.create_user(user)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->createUser: %s\n" % e)

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

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

public class UsersApiExample {

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

        UsersApi apiInstance = new UsersApi();
        UUID id = ; // UUID | The users id
        try {
            UserResponse result = apiInstance.deleteUser(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#deleteUser");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        UUID id = ; // UUID | The users id
        try {
            UserResponse result = apiInstance.deleteUser(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#deleteUser");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

UUID *id = ; // The users id

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

// Delete a specific user
[apiInstance deleteUserWith:id
              completionHandler: ^(UserResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenTodoApi = require('open_todo_api');
var defaultClient = OpenTodoApi.ApiClient.instance;

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

var api = new OpenTodoApi.UsersApi()

var id = ; // {UUID} The users id


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

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

namespace Example
{
    public class deleteUserExample
    {
        public void main()
        {
            
            // Configure API key authorization: JWT
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new UsersApi();
            var id = new UUID(); // UUID | The users id

            try
            {
                // Delete a specific user
                UserResponse result = apiInstance.deleteUser(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.deleteUser: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new Swagger\Client\Api\UsersApi();
$id = ; // UUID | The users id

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

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

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

my $api_instance = WWW::SwaggerClient::UsersApi->new();
my $id = ; # UUID | The users id

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

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

# Configure API key authorization: JWT
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.UsersApi()
id =  # UUID | The users id

try: 
    # Delete a specific user
    api_response = api_instance.delete_user(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->deleteUser: %s\n" % e)

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

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

public class UsersApiExample {

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

        UsersApi apiInstance = new UsersApi();
        try {
            array[UserResponse] result = apiInstance.findUsers();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#findUsers");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        try {
            array[UserResponse] result = apiInstance.findUsers();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#findUsers");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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


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

// Find all users
[apiInstance findUsersWithCompletionHandler: 
              ^(array[UserResponse] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenTodoApi = require('open_todo_api');
var defaultClient = OpenTodoApi.ApiClient.instance;

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

var api = new OpenTodoApi.UsersApi()

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

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

namespace Example
{
    public class findUsersExample
    {
        public void main()
        {
            
            // Configure API key authorization: JWT
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new UsersApi();

            try
            {
                // Find all users
                array[UserResponse] result = apiInstance.findUsers();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.findUsers: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new Swagger\Client\Api\UsersApi();

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

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

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

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

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

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

# Configure API key authorization: JWT
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

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

try: 
    # Find all users
    api_response = api_instance.find_users()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->findUsers: %s\n" % e)

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

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

public class UsersApiExample {

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

        UsersApi apiInstance = new UsersApi();
        try {
            UserResponse result = apiInstance.getSelf();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#getSelf");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        try {
            UserResponse result = apiInstance.getSelf();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#getSelf");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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


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

// Get own user
[apiInstance getSelfWithCompletionHandler: 
              ^(UserResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenTodoApi = require('open_todo_api');
var defaultClient = OpenTodoApi.ApiClient.instance;

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

var api = new OpenTodoApi.UsersApi()

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

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

namespace Example
{
    public class getSelfExample
    {
        public void main()
        {
            
            // Configure API key authorization: JWT
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new UsersApi();

            try
            {
                // Get own user
                UserResponse result = apiInstance.getSelf();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.getSelf: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new Swagger\Client\Api\UsersApi();

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

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

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

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

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

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

# Configure API key authorization: JWT
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

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

try: 
    # Get own user
    api_response = api_instance.get_self()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->getSelf: %s\n" % e)

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

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

public class UsersApiExample {

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

        UsersApi apiInstance = new UsersApi();
        UUID id = ; // UUID | The users id
        try {
            UserResponse result = apiInstance.getUser(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#getUser");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        UUID id = ; // UUID | The users id
        try {
            UserResponse result = apiInstance.getUser(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#getUser");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

UUID *id = ; // The users id

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

// Get a specific user
[apiInstance getUserWith:id
              completionHandler: ^(UserResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenTodoApi = require('open_todo_api');
var defaultClient = OpenTodoApi.ApiClient.instance;

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

var api = new OpenTodoApi.UsersApi()

var id = ; // {UUID} The users id


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

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

namespace Example
{
    public class getUserExample
    {
        public void main()
        {
            
            // Configure API key authorization: JWT
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new UsersApi();
            var id = new UUID(); // UUID | The users id

            try
            {
                // Get a specific user
                UserResponse result = apiInstance.getUser(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.getUser: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new Swagger\Client\Api\UsersApi();
$id = ; // UUID | The users id

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

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

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

my $api_instance = WWW::SwaggerClient::UsersApi->new();
my $id = ; # UUID | The users id

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

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

# Configure API key authorization: JWT
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.UsersApi()
id =  # UUID | The users id

try: 
    # Get a specific user
    api_response = api_instance.get_user(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->getUser: %s\n" % e)

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

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

public class UsersApiExample {

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

        UsersApi apiInstance = new UsersApi();
        UserRequest user = ; // UserRequest | The update request
        try {
            UserResponse result = apiInstance.updateSelf(user);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#updateSelf");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        UserRequest user = ; // UserRequest | The update request
        try {
            UserResponse result = apiInstance.updateSelf(user);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#updateSelf");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

UserRequest *user = ; // The update request

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

// Update own user
[apiInstance updateSelfWith:user
              completionHandler: ^(UserResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenTodoApi = require('open_todo_api');
var defaultClient = OpenTodoApi.ApiClient.instance;

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

var api = new OpenTodoApi.UsersApi()

var user = ; // {UserRequest} The update request


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

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

namespace Example
{
    public class updateSelfExample
    {
        public void main()
        {
            
            // Configure API key authorization: JWT
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new UsersApi();
            var user = new UserRequest(); // UserRequest | The update request

            try
            {
                // Update own user
                UserResponse result = apiInstance.updateSelf(user);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.updateSelf: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new Swagger\Client\Api\UsersApi();
$user = ; // UserRequest | The update request

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

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

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

my $api_instance = WWW::SwaggerClient::UsersApi->new();
my $user = WWW::SwaggerClient::Object::UserRequest->new(); # UserRequest | The update request

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

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

# Configure API key authorization: JWT
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.UsersApi()
user =  # UserRequest | The update request

try: 
    # Update own user
    api_response = api_instance.update_self(user)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->updateSelf: %s\n" % e)

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

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

public class UsersApiExample {

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

        UsersApi apiInstance = new UsersApi();
        UUID id = ; // UUID | The users id
        UserRequest user = ; // UserRequest | The update request
        try {
            UserResponse result = apiInstance.updateUser(id, user);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#updateUser");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        UUID id = ; // UUID | The users id
        UserRequest user = ; // UserRequest | The update request
        try {
            UserResponse result = apiInstance.updateUser(id, user);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#updateUser");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

UUID *id = ; // The users id
UserRequest *user = ; // The update request

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

// Update a specific user
[apiInstance updateUserWith:id
    user:user
              completionHandler: ^(UserResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenTodoApi = require('open_todo_api');
var defaultClient = OpenTodoApi.ApiClient.instance;

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

var api = new OpenTodoApi.UsersApi()

var id = ; // {UUID} The users id

var user = ; // {UserRequest} The update request


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

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

namespace Example
{
    public class updateUserExample
    {
        public void main()
        {
            
            // Configure API key authorization: JWT
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new UsersApi();
            var id = new UUID(); // UUID | The users id
            var user = new UserRequest(); // UserRequest | The update request

            try
            {
                // Update a specific user
                UserResponse result = apiInstance.updateUser(id, user);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.updateUser: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new Swagger\Client\Api\UsersApi();
$id = ; // UUID | The users id
$user = ; // UserRequest | The update request

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

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

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

my $api_instance = WWW::SwaggerClient::UsersApi->new();
my $id = ; # UUID | The users id
my $user = WWW::SwaggerClient::Object::UserRequest->new(); # UserRequest | The update request

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

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

# Configure API key authorization: JWT
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.UsersApi()
id =  # UUID | The users id
user =  # UserRequest | The update request

try: 
    # Update a specific user
    api_response = api_instance.update_user(id, user)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->updateUser: %s\n" % e)