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

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

public class CategoryApiExample {

    public static void main(String[] args) {
        
        CategoryApi apiInstance = new CategoryApi();
        Order body = ; // Order | order placed for purchasing the domain
        try {
            Order result = apiInstance.categoryRequestNew(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CategoryApi#categoryRequestNew");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CategoryApi;

public class CategoryApiExample {

    public static void main(String[] args) {
        CategoryApi apiInstance = new CategoryApi();
        Order body = ; // Order | order placed for purchasing the domain
        try {
            Order result = apiInstance.categoryRequestNew(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CategoryApi#categoryRequestNew");
            e.printStackTrace();
        }
    }
}

Order *body = ; // order placed for purchasing the domain

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

// Submit a new category request
[apiInstance categoryRequestNewWith:body
              completionHandler: ^(Order output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ReaListApi = require('rea_list_api');

var api = new ReaListApi.CategoryApi()

var body = ; // {Order} order placed for purchasing the domain


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

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

namespace Example
{
    public class categoryRequestNewExample
    {
        public void main()
        {
            
            var apiInstance = new CategoryApi();
            var body = new Order(); // Order | order placed for purchasing the domain

            try
            {
                // Submit a new category request
                Order result = apiInstance.categoryRequestNew(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CategoryApi.categoryRequestNew: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\CategoryApi();
$body = ; // Order | order placed for purchasing the domain

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

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

my $api_instance = WWW::SwaggerClient::CategoryApi->new();
my $body = WWW::SwaggerClient::Object::Order->new(); # Order | order placed for purchasing the domain

eval { 
    my $result = $api_instance->categoryRequestNew(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CategoryApi->categoryRequestNew: $@\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.CategoryApi()
body =  # Order | order placed for purchasing the domain

try: 
    # Submit a new category request
    api_response = api_instance.category_request_new(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CategoryApi->categoryRequestNew: %s\n" % e)

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

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

public class CategoryApiExample {

    public static void main(String[] args) {
        
        CategoryApi apiInstance = new CategoryApi();
        Long categoryId = 789; // Long | ID of the order that needs to be deleted
        try {
            apiInstance.deleteOrder(categoryId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CategoryApi#deleteOrder");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CategoryApi;

public class CategoryApiExample {

    public static void main(String[] args) {
        CategoryApi apiInstance = new CategoryApi();
        Long categoryId = 789; // Long | ID of the order that needs to be deleted
        try {
            apiInstance.deleteOrder(categoryId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CategoryApi#deleteOrder");
            e.printStackTrace();
        }
    }
}

Long *categoryId = 789; // ID of the order that needs to be deleted

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

// Delete a category by ID
[apiInstance deleteOrderWith:categoryId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ReaListApi = require('rea_list_api');

var api = new ReaListApi.CategoryApi()

var categoryId = 789; // {Long} ID of the order that needs to be deleted


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

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

namespace Example
{
    public class deleteOrderExample
    {
        public void main()
        {
            
            var apiInstance = new CategoryApi();
            var categoryId = 789;  // Long | ID of the order that needs to be deleted

            try
            {
                // Delete a category by ID
                apiInstance.deleteOrder(categoryId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CategoryApi.deleteOrder: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\CategoryApi();
$categoryId = 789; // Long | ID of the order that needs to be deleted

try {
    $api_instance->deleteOrder($categoryId);
} catch (Exception $e) {
    echo 'Exception when calling CategoryApi->deleteOrder: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::CategoryApi->new();
my $categoryId = 789; # Long | ID of the order that needs to be deleted

eval { 
    $api_instance->deleteOrder(categoryId => $categoryId);
};
if ($@) {
    warn "Exception when calling CategoryApi->deleteOrder: $@\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.CategoryApi()
categoryId = 789 # Long | ID of the order that needs to be deleted

try: 
    # Delete a category by ID
    api_instance.delete_order(categoryId)
except ApiException as e:
    print("Exception when calling CategoryApi->deleteOrder: %s\n" % e)

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

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

public class CategoryApiExample {

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

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

import io.swagger.client.api.CategoryApi;

public class CategoryApiExample {

    public static void main(String[] args) {
        CategoryApi apiInstance = new CategoryApi();
        try {
            map['String', 'Integer'] result = apiInstance.getCategories();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CategoryApi#getCategories");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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


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

// Returns domain categories
[apiInstance getCategoriesWithCompletionHandler: 
              ^(map['String', 'Integer'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ReaListApi = require('rea_list_api');
var defaultClient = ReaListApi.ApiClient.instance;

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

var api = new ReaListApi.CategoryApi()

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

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

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

            var apiInstance = new CategoryApi();

            try
            {
                // Returns domain categories
                map['String', 'Integer'] result = apiInstance.getCategories();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CategoryApi.getCategories: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

eval { 
    my $result = $api_instance->getCategories();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CategoryApi->getCategories: $@\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: api_key
swagger_client.configuration.api_key['api_key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['api_key'] = 'Bearer'

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

try: 
    # Returns domain categories
    api_response = api_instance.get_categories()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CategoryApi->getCategories: %s\n" % e)

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

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

public class CategoryApiExample {

    public static void main(String[] args) {
        
        CategoryApi apiInstance = new CategoryApi();
        Long categoryId = 789; // Long | ID of domain that needs to be fetched
        try {
            Order result = apiInstance.getCategoryById(categoryId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CategoryApi#getCategoryById");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CategoryApi;

public class CategoryApiExample {

    public static void main(String[] args) {
        CategoryApi apiInstance = new CategoryApi();
        Long categoryId = 789; // Long | ID of domain that needs to be fetched
        try {
            Order result = apiInstance.getCategoryById(categoryId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CategoryApi#getCategoryById");
            e.printStackTrace();
        }
    }
}

Long *categoryId = 789; // ID of domain that needs to be fetched

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

// Returns the details for a specific category ID
[apiInstance getCategoryByIdWith:categoryId
              completionHandler: ^(Order output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ReaListApi = require('rea_list_api');

var api = new ReaListApi.CategoryApi()

var categoryId = 789; // {Long} ID of domain that needs to be fetched


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

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

namespace Example
{
    public class getCategoryByIdExample
    {
        public void main()
        {
            
            var apiInstance = new CategoryApi();
            var categoryId = 789;  // Long | ID of domain that needs to be fetched

            try
            {
                // Returns the details for a specific category ID
                Order result = apiInstance.getCategoryById(categoryId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CategoryApi.getCategoryById: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\CategoryApi();
$categoryId = 789; // Long | ID of domain that needs to be fetched

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

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

my $api_instance = WWW::SwaggerClient::CategoryApi->new();
my $categoryId = 789; # Long | ID of domain that needs to be fetched

eval { 
    my $result = $api_instance->getCategoryById(categoryId => $categoryId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CategoryApi->getCategoryById: $@\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.CategoryApi()
categoryId = 789 # Long | ID of domain that needs to be fetched

try: 
    # Returns the details for a specific category ID
    api_response = api_instance.get_category_by_id(categoryId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CategoryApi->getCategoryById: %s\n" % e)

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

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

public class CategoryApiExample {

    public static void main(String[] args) {
        
        CategoryApi apiInstance = new CategoryApi();
        Long categoryId = 789; // Long | ID of domain that needs to be fetched
        try {
            Order result = apiInstance.getCountByCategoryId(categoryId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CategoryApi#getCountByCategoryId");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CategoryApi;

public class CategoryApiExample {

    public static void main(String[] args) {
        CategoryApi apiInstance = new CategoryApi();
        Long categoryId = 789; // Long | ID of domain that needs to be fetched
        try {
            Order result = apiInstance.getCountByCategoryId(categoryId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CategoryApi#getCountByCategoryId");
            e.printStackTrace();
        }
    }
}

Long *categoryId = 789; // ID of domain that needs to be fetched

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

// Returns the details for a specific category ID
[apiInstance getCountByCategoryIdWith:categoryId
              completionHandler: ^(Order output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ReaListApi = require('rea_list_api');

var api = new ReaListApi.CategoryApi()

var categoryId = 789; // {Long} ID of domain that needs to be fetched


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

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

namespace Example
{
    public class getCountByCategoryIdExample
    {
        public void main()
        {
            
            var apiInstance = new CategoryApi();
            var categoryId = 789;  // Long | ID of domain that needs to be fetched

            try
            {
                // Returns the details for a specific category ID
                Order result = apiInstance.getCountByCategoryId(categoryId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CategoryApi.getCountByCategoryId: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\CategoryApi();
$categoryId = 789; // Long | ID of domain that needs to be fetched

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

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

my $api_instance = WWW::SwaggerClient::CategoryApi->new();
my $categoryId = 789; # Long | ID of domain that needs to be fetched

eval { 
    my $result = $api_instance->getCountByCategoryId(categoryId => $categoryId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CategoryApi->getCountByCategoryId: $@\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.CategoryApi()
categoryId = 789 # Long | ID of domain that needs to be fetched

try: 
    # Returns the details for a specific category ID
    api_response = api_instance.get_count_by_category_id(categoryId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CategoryApi->getCountByCategoryId: %s\n" % e)

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

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

public class DomainApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: domainstore_auth
        OAuth domainstore_auth = (OAuth) defaultClient.getAuthentication("domainstore_auth");
        domainstore_auth.setAccessToken("YOUR ACCESS TOKEN");

        DomainApi apiInstance = new DomainApi();
        Domain body = ; // Domain | Domain object that needs to be added to the list
        try {
            apiInstance.addDomain(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DomainApi#addDomain");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DomainApi;

public class DomainApiExample {

    public static void main(String[] args) {
        DomainApi apiInstance = new DomainApi();
        Domain body = ; // Domain | Domain object that needs to be added to the list
        try {
            apiInstance.addDomain(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DomainApi#addDomain");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: domainstore_auth)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

Domain *body = ; // Domain object that needs to be added to the list

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

// Submit a new domain to the list
[apiInstance addDomainWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ReaListApi = require('rea_list_api');
var defaultClient = ReaListApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: domainstore_auth
var domainstore_auth = defaultClient.authentications['domainstore_auth'];
domainstore_auth.accessToken = "YOUR ACCESS TOKEN"

var api = new ReaListApi.DomainApi()

var body = ; // {Domain} Domain object that needs to be added to the list


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

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

namespace Example
{
    public class addDomainExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: domainstore_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new DomainApi();
            var body = new Domain(); // Domain | Domain object that needs to be added to the list

            try
            {
                // Submit a new domain to the list
                apiInstance.addDomain(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DomainApi.addDomain: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: domainstore_auth
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\DomainApi();
$body = ; // Domain | Domain object that needs to be added to the list

try {
    $api_instance->addDomain($body);
} catch (Exception $e) {
    echo 'Exception when calling DomainApi->addDomain: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure OAuth2 access token for authorization: domainstore_auth
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::DomainApi->new();
my $body = WWW::SwaggerClient::Object::Domain->new(); # Domain | Domain object that needs to be added to the list

eval { 
    $api_instance->addDomain(body => $body);
};
if ($@) {
    warn "Exception when calling DomainApi->addDomain: $@\n";
}

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

# Configure OAuth2 access token for authorization: domainstore_auth
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.DomainApi()
body =  # Domain | Domain object that needs to be added to the list

try: 
    # Submit a new domain to the list
    api_instance.add_domain(body)
except ApiException as e:
    print("Exception when calling DomainApi->addDomain: %s\n" % e)

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

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

public class DomainApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: domainstore_auth
        OAuth domainstore_auth = (OAuth) defaultClient.getAuthentication("domainstore_auth");
        domainstore_auth.setAccessToken("YOUR ACCESS TOKEN");

        DomainApi apiInstance = new DomainApi();
        Long domainId = 789; // Long | domain id to delete
        String apiKey = apiKey_example; // String | 
        try {
            apiInstance.deletedomain(domainId, apiKey);
        } catch (ApiException e) {
            System.err.println("Exception when calling DomainApi#deletedomain");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DomainApi;

public class DomainApiExample {

    public static void main(String[] args) {
        DomainApi apiInstance = new DomainApi();
        Long domainId = 789; // Long | domain id to delete
        String apiKey = apiKey_example; // String | 
        try {
            apiInstance.deletedomain(domainId, apiKey);
        } catch (ApiException e) {
            System.err.println("Exception when calling DomainApi#deletedomain");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: domainstore_auth)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

Long *domainId = 789; // domain id to delete
String *apiKey = apiKey_example; //  (optional)

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

// Deletes a domain
[apiInstance deletedomainWith:domainId
    apiKey:apiKey
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ReaListApi = require('rea_list_api');
var defaultClient = ReaListApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: domainstore_auth
var domainstore_auth = defaultClient.authentications['domainstore_auth'];
domainstore_auth.accessToken = "YOUR ACCESS TOKEN"

var api = new ReaListApi.DomainApi()

var domainId = 789; // {Long} domain id to delete

var opts = { 
  'apiKey': apiKey_example // {String} 
};

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

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

namespace Example
{
    public class deletedomainExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: domainstore_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new DomainApi();
            var domainId = 789;  // Long | domain id to delete
            var apiKey = apiKey_example;  // String |  (optional) 

            try
            {
                // Deletes a domain
                apiInstance.deletedomain(domainId, apiKey);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DomainApi.deletedomain: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: domainstore_auth
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\DomainApi();
$domainId = 789; // Long | domain id to delete
$apiKey = apiKey_example; // String | 

try {
    $api_instance->deletedomain($domainId, $apiKey);
} catch (Exception $e) {
    echo 'Exception when calling DomainApi->deletedomain: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure OAuth2 access token for authorization: domainstore_auth
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::DomainApi->new();
my $domainId = 789; # Long | domain id to delete
my $apiKey = apiKey_example; # String | 

eval { 
    $api_instance->deletedomain(domainId => $domainId, apiKey => $apiKey);
};
if ($@) {
    warn "Exception when calling DomainApi->deletedomain: $@\n";
}

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

# Configure OAuth2 access token for authorization: domainstore_auth
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.DomainApi()
domainId = 789 # Long | domain id to delete
apiKey = apiKey_example # String |  (optional)

try: 
    # Deletes a domain
    api_instance.deletedomain(domainId, apiKey=apiKey)
except ApiException as e:
    print("Exception when calling DomainApi->deletedomain: %s\n" % e)

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

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

public class DomainApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: domainstore_auth
        OAuth domainstore_auth = (OAuth) defaultClient.getAuthentication("domainstore_auth");
        domainstore_auth.setAccessToken("YOUR ACCESS TOKEN");

        DomainApi apiInstance = new DomainApi();
        array[String] status = ; // array[String] | Status values that need to be considered for filter
        try {
            array[domain] result = apiInstance.finddomainsByStatus(status);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DomainApi#finddomainsByStatus");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DomainApi;

public class DomainApiExample {

    public static void main(String[] args) {
        DomainApi apiInstance = new DomainApi();
        array[String] status = ; // array[String] | Status values that need to be considered for filter
        try {
            array[domain] result = apiInstance.finddomainsByStatus(status);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DomainApi#finddomainsByStatus");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: domainstore_auth)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

array[String] *status = ; // Status values that need to be considered for filter

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

// Retrieve Domains by Category
[apiInstance finddomainsByStatusWith:status
              completionHandler: ^(array[domain] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ReaListApi = require('rea_list_api');
var defaultClient = ReaListApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: domainstore_auth
var domainstore_auth = defaultClient.authentications['domainstore_auth'];
domainstore_auth.accessToken = "YOUR ACCESS TOKEN"

var api = new ReaListApi.DomainApi()

var status = ; // {array[String]} Status values that need to be considered for filter


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

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

namespace Example
{
    public class finddomainsByStatusExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: domainstore_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new DomainApi();
            var status = new array[String](); // array[String] | Status values that need to be considered for filter

            try
            {
                // Retrieve Domains by Category
                array[domain] result = apiInstance.finddomainsByStatus(status);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DomainApi.finddomainsByStatus: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: domainstore_auth
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\DomainApi();
$status = ; // array[String] | Status values that need to be considered for filter

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

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

# Configure OAuth2 access token for authorization: domainstore_auth
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::DomainApi->new();
my $status = []; # array[String] | Status values that need to be considered for filter

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

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

# Configure OAuth2 access token for authorization: domainstore_auth
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.DomainApi()
status =  # array[String] | Status values that need to be considered for filter

try: 
    # Retrieve Domains by Category
    api_response = api_instance.finddomains_by_status(status)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DomainApi->finddomainsByStatus: %s\n" % e)

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

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

public class DomainApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: domainstore_auth
        OAuth domainstore_auth = (OAuth) defaultClient.getAuthentication("domainstore_auth");
        domainstore_auth.setAccessToken("YOUR ACCESS TOKEN");

        DomainApi apiInstance = new DomainApi();
        array[String] tags = ; // array[String] | Tags to filter by
        try {
            array[domain] result = apiInstance.finddomainsByTags(tags);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DomainApi#finddomainsByTags");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DomainApi;

public class DomainApiExample {

    public static void main(String[] args) {
        DomainApi apiInstance = new DomainApi();
        array[String] tags = ; // array[String] | Tags to filter by
        try {
            array[domain] result = apiInstance.finddomainsByTags(tags);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DomainApi#finddomainsByTags");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: domainstore_auth)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

array[String] *tags = ; // Tags to filter by

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

// Returns all the domains
[apiInstance finddomainsByTagsWith:tags
              completionHandler: ^(array[domain] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ReaListApi = require('rea_list_api');
var defaultClient = ReaListApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: domainstore_auth
var domainstore_auth = defaultClient.authentications['domainstore_auth'];
domainstore_auth.accessToken = "YOUR ACCESS TOKEN"

var api = new ReaListApi.DomainApi()

var tags = ; // {array[String]} Tags to filter by


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

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

namespace Example
{
    public class finddomainsByTagsExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: domainstore_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new DomainApi();
            var tags = new array[String](); // array[String] | Tags to filter by

            try
            {
                // Returns all the domains
                array[domain] result = apiInstance.finddomainsByTags(tags);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DomainApi.finddomainsByTags: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: domainstore_auth
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\DomainApi();
$tags = ; // array[String] | Tags to filter by

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

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

# Configure OAuth2 access token for authorization: domainstore_auth
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::DomainApi->new();
my $tags = []; # array[String] | Tags to filter by

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

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

# Configure OAuth2 access token for authorization: domainstore_auth
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.DomainApi()
tags =  # array[String] | Tags to filter by

try: 
    # Returns all the domains
    api_response = api_instance.finddomains_by_tags(tags)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DomainApi->finddomainsByTags: %s\n" % e)

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

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

public class DomainApiExample {

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

        DomainApi apiInstance = new DomainApi();
        Long domainId = 789; // Long | ID of domain to return
        try {
            domain result = apiInstance.getdomainById(domainId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DomainApi#getdomainById");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DomainApi;

public class DomainApiExample {

    public static void main(String[] args) {
        DomainApi apiInstance = new DomainApi();
        Long domainId = 789; // Long | ID of domain to return
        try {
            domain result = apiInstance.getdomainById(domainId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DomainApi#getdomainById");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

Long *domainId = 789; // ID of domain to return

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

// Find domain by ID
[apiInstance getdomainByIdWith:domainId
              completionHandler: ^(domain output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ReaListApi = require('rea_list_api');
var defaultClient = ReaListApi.ApiClient.instance;

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

var api = new ReaListApi.DomainApi()

var domainId = 789; // {Long} ID of domain to return


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

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

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

            var apiInstance = new DomainApi();
            var domainId = 789;  // Long | ID of domain to return

            try
            {
                // Find domain by ID
                domain result = apiInstance.getdomainById(domainId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DomainApi.getdomainById: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new Swagger\Client\Api\DomainApi();
$domainId = 789; // Long | ID of domain to return

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

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

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

my $api_instance = WWW::SwaggerClient::DomainApi->new();
my $domainId = 789; # Long | ID of domain to return

eval { 
    my $result = $api_instance->getdomainById(domainId => $domainId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DomainApi->getdomainById: $@\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: api_key
swagger_client.configuration.api_key['api_key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['api_key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DomainApi()
domainId = 789 # Long | ID of domain to return

try: 
    # Find domain by ID
    api_response = api_instance.getdomain_by_id(domainId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DomainApi->getdomainById: %s\n" % e)

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

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

public class DomainApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: domainstore_auth
        OAuth domainstore_auth = (OAuth) defaultClient.getAuthentication("domainstore_auth");
        domainstore_auth.setAccessToken("YOUR ACCESS TOKEN");

        DomainApi apiInstance = new DomainApi();
        Domain body = ; // Domain | domain object that needs to be added to the store
        try {
            apiInstance.updatedomain(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DomainApi#updatedomain");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DomainApi;

public class DomainApiExample {

    public static void main(String[] args) {
        DomainApi apiInstance = new DomainApi();
        Domain body = ; // Domain | domain object that needs to be added to the store
        try {
            apiInstance.updatedomain(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DomainApi#updatedomain");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: domainstore_auth)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

Domain *body = ; // domain object that needs to be added to the store

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

// Update Request - an existing domain
[apiInstance updatedomainWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ReaListApi = require('rea_list_api');
var defaultClient = ReaListApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: domainstore_auth
var domainstore_auth = defaultClient.authentications['domainstore_auth'];
domainstore_auth.accessToken = "YOUR ACCESS TOKEN"

var api = new ReaListApi.DomainApi()

var body = ; // {Domain} domain object that needs to be added to the store


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

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

namespace Example
{
    public class updatedomainExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: domainstore_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new DomainApi();
            var body = new Domain(); // Domain | domain object that needs to be added to the store

            try
            {
                // Update Request - an existing domain
                apiInstance.updatedomain(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DomainApi.updatedomain: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: domainstore_auth
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\DomainApi();
$body = ; // Domain | domain object that needs to be added to the store

try {
    $api_instance->updatedomain($body);
} catch (Exception $e) {
    echo 'Exception when calling DomainApi->updatedomain: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure OAuth2 access token for authorization: domainstore_auth
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::DomainApi->new();
my $body = WWW::SwaggerClient::Object::Domain->new(); # Domain | domain object that needs to be added to the store

eval { 
    $api_instance->updatedomain(body => $body);
};
if ($@) {
    warn "Exception when calling DomainApi->updatedomain: $@\n";
}

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

# Configure OAuth2 access token for authorization: domainstore_auth
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.DomainApi()
body =  # Domain | domain object that needs to be added to the store

try: 
    # Update Request - an existing domain
    api_instance.updatedomain(body)
except ApiException as e:
    print("Exception when calling DomainApi->updatedomain: %s\n" % e)

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

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

public class DomainApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: domainstore_auth
        OAuth domainstore_auth = (OAuth) defaultClient.getAuthentication("domainstore_auth");
        domainstore_auth.setAccessToken("YOUR ACCESS TOKEN");

        DomainApi apiInstance = new DomainApi();
        Long domainId = 789; // Long | ID of domain that needs to be updated
        String name = name_example; // String | Updated name of the domain
        String status = status_example; // String | Updated status of the domain
        try {
            apiInstance.updatedomainWithForm(domainId, name, status);
        } catch (ApiException e) {
            System.err.println("Exception when calling DomainApi#updatedomainWithForm");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DomainApi;

public class DomainApiExample {

    public static void main(String[] args) {
        DomainApi apiInstance = new DomainApi();
        Long domainId = 789; // Long | ID of domain that needs to be updated
        String name = name_example; // String | Updated name of the domain
        String status = status_example; // String | Updated status of the domain
        try {
            apiInstance.updatedomainWithForm(domainId, name, status);
        } catch (ApiException e) {
            System.err.println("Exception when calling DomainApi#updatedomainWithForm");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: domainstore_auth)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

Long *domainId = 789; // ID of domain that needs to be updated
String *name = name_example; // Updated name of the domain (optional)
String *status = status_example; // Updated status of the domain (optional)

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

// Updates a domain in the store with form data
[apiInstance updatedomainWithFormWith:domainId
    name:name
    status:status
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ReaListApi = require('rea_list_api');
var defaultClient = ReaListApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: domainstore_auth
var domainstore_auth = defaultClient.authentications['domainstore_auth'];
domainstore_auth.accessToken = "YOUR ACCESS TOKEN"

var api = new ReaListApi.DomainApi()

var domainId = 789; // {Long} ID of domain that needs to be updated

var opts = { 
  'name': name_example, // {String} Updated name of the domain
  'status': status_example // {String} Updated status of the domain
};

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

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

namespace Example
{
    public class updatedomainWithFormExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: domainstore_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new DomainApi();
            var domainId = 789;  // Long | ID of domain that needs to be updated
            var name = name_example;  // String | Updated name of the domain (optional) 
            var status = status_example;  // String | Updated status of the domain (optional) 

            try
            {
                // Updates a domain in the store with form data
                apiInstance.updatedomainWithForm(domainId, name, status);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DomainApi.updatedomainWithForm: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: domainstore_auth
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\DomainApi();
$domainId = 789; // Long | ID of domain that needs to be updated
$name = name_example; // String | Updated name of the domain
$status = status_example; // String | Updated status of the domain

try {
    $api_instance->updatedomainWithForm($domainId, $name, $status);
} catch (Exception $e) {
    echo 'Exception when calling DomainApi->updatedomainWithForm: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure OAuth2 access token for authorization: domainstore_auth
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::DomainApi->new();
my $domainId = 789; # Long | ID of domain that needs to be updated
my $name = name_example; # String | Updated name of the domain
my $status = status_example; # String | Updated status of the domain

eval { 
    $api_instance->updatedomainWithForm(domainId => $domainId, name => $name, status => $status);
};
if ($@) {
    warn "Exception when calling DomainApi->updatedomainWithForm: $@\n";
}

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

# Configure OAuth2 access token for authorization: domainstore_auth
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.DomainApi()
domainId = 789 # Long | ID of domain that needs to be updated
name = name_example # String | Updated name of the domain (optional)
status = status_example # String | Updated status of the domain (optional)

try: 
    # Updates a domain in the store with form data
    api_instance.updatedomain_with_form(domainId, name=name, status=status)
except ApiException as e:
    print("Exception when calling DomainApi->updatedomainWithForm: %s\n" % e)

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

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

public class UserApiExample {

    public static void main(String[] args) {
        
        UserApi apiInstance = new UserApi();
        array[User] body = ; // array[User] | List of user object
        try {
            apiInstance.createNewListInput(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#createNewListInput");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UserApi;

public class UserApiExample {

    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        array[User] body = ; // array[User] | List of user object
        try {
            apiInstance.createNewListInput(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#createNewListInput");
            e.printStackTrace();
        }
    }
}

array[User] *body = ; // List of user object

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

// Creates list of domains associated with a specific user
[apiInstance createNewListInputWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ReaListApi = require('rea_list_api');

var api = new ReaListApi.UserApi()

var body = ; // {array[User]} List of user object


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

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

namespace Example
{
    public class createNewListInputExample
    {
        public void main()
        {
            
            var apiInstance = new UserApi();
            var body = new array[User](); // array[User] | List of user object

            try
            {
                // Creates list of domains associated with a specific user
                apiInstance.createNewListInput(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.createNewListInput: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\UserApi();
$body = ; // array[User] | List of user object

try {
    $api_instance->createNewListInput($body);
} catch (Exception $e) {
    echo 'Exception when calling UserApi->createNewListInput: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $body = [WWW::SwaggerClient::Object::array[User]->new()]; # array[User] | List of user object

eval { 
    $api_instance->createNewListInput(body => $body);
};
if ($@) {
    warn "Exception when calling UserApi->createNewListInput: $@\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.UserApi()
body =  # array[User] | List of user object

try: 
    # Creates list of domains associated with a specific user
    api_instance.create_new_list_input(body)
except ApiException as e:
    print("Exception when calling UserApi->createNewListInput: %s\n" % e)

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

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

public class UserApiExample {

    public static void main(String[] args) {
        
        UserApi apiInstance = new UserApi();
        User body = ; // User | Created user object
        try {
            apiInstance.createUser(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#createUser");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UserApi;

public class UserApiExample {

    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        User body = ; // User | Created user object
        try {
            apiInstance.createUser(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#createUser");
            e.printStackTrace();
        }
    }
}

User *body = ; // Created user object

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

// Create user and generate API Key
[apiInstance createUserWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ReaListApi = require('rea_list_api');

var api = new ReaListApi.UserApi()

var body = ; // {User} Created user object


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createUser(body, 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()
        {
            
            var apiInstance = new UserApi();
            var body = new User(); // User | Created user object

            try
            {
                // Create user and generate API Key
                apiInstance.createUser(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.createUser: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\UserApi();
$body = ; // User | Created user object

try {
    $api_instance->createUser($body);
} catch (Exception $e) {
    echo 'Exception when calling UserApi->createUser: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $body = WWW::SwaggerClient::Object::User->new(); # User | Created user object

eval { 
    $api_instance->createUser(body => $body);
};
if ($@) {
    warn "Exception when calling UserApi->createUser: $@\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.UserApi()
body =  # User | Created user object

try: 
    # Create user and generate API Key
    api_instance.create_user(body)
except ApiException as e:
    print("Exception when calling UserApi->createUser: %s\n" % e)

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

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

public class UserApiExample {

    public static void main(String[] args) {
        
        UserApi apiInstance = new UserApi();
        array[User] body = ; // array[User] | List of user object
        try {
            apiInstance.createUsersWithArrayInput(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#createUsersWithArrayInput");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UserApi;

public class UserApiExample {

    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        array[User] body = ; // array[User] | List of user object
        try {
            apiInstance.createUsersWithArrayInput(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#createUsersWithArrayInput");
            e.printStackTrace();
        }
    }
}

array[User] *body = ; // List of user object

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

// Creates list of users with given input array, and generates API key
[apiInstance createUsersWithArrayInputWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ReaListApi = require('rea_list_api');

var api = new ReaListApi.UserApi()

var body = ; // {array[User]} List of user object


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

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

namespace Example
{
    public class createUsersWithArrayInputExample
    {
        public void main()
        {
            
            var apiInstance = new UserApi();
            var body = new array[User](); // array[User] | List of user object

            try
            {
                // Creates list of users with given input array, and generates API key
                apiInstance.createUsersWithArrayInput(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.createUsersWithArrayInput: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\UserApi();
$body = ; // array[User] | List of user object

try {
    $api_instance->createUsersWithArrayInput($body);
} catch (Exception $e) {
    echo 'Exception when calling UserApi->createUsersWithArrayInput: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $body = [WWW::SwaggerClient::Object::array[User]->new()]; # array[User] | List of user object

eval { 
    $api_instance->createUsersWithArrayInput(body => $body);
};
if ($@) {
    warn "Exception when calling UserApi->createUsersWithArrayInput: $@\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.UserApi()
body =  # array[User] | List of user object

try: 
    # Creates list of users with given input array, and generates API key
    api_instance.create_users_with_array_input(body)
except ApiException as e:
    print("Exception when calling UserApi->createUsersWithArrayInput: %s\n" % e)

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

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

public class UserApiExample {

    public static void main(String[] args) {
        
        UserApi apiInstance = new UserApi();
        String username = username_example; // String | The name that needs to be deleted
        try {
            apiInstance.deleteUser(username);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#deleteUser");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UserApi;

public class UserApiExample {

    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        String username = username_example; // String | The name that needs to be deleted
        try {
            apiInstance.deleteUser(username);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#deleteUser");
            e.printStackTrace();
        }
    }
}

String *username = username_example; // The name that needs to be deleted

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

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

var ReaListApi = require('rea_list_api');

var api = new ReaListApi.UserApi()

var username = username_example; // {String} The name that needs to be deleted


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteUser(username, 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()
        {
            
            var apiInstance = new UserApi();
            var username = username_example;  // String | The name that needs to be deleted

            try
            {
                // Delete user
                apiInstance.deleteUser(username);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.deleteUser: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\UserApi();
$username = username_example; // String | The name that needs to be deleted

try {
    $api_instance->deleteUser($username);
} catch (Exception $e) {
    echo 'Exception when calling UserApi->deleteUser: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $username = username_example; # String | The name that needs to be deleted

eval { 
    $api_instance->deleteUser(username => $username);
};
if ($@) {
    warn "Exception when calling UserApi->deleteUser: $@\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.UserApi()
username = username_example # String | The name that needs to be deleted

try: 
    # Delete user
    api_instance.delete_user(username)
except ApiException as e:
    print("Exception when calling UserApi->deleteUser: %s\n" % e)

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

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

public class UserApiExample {

    public static void main(String[] args) {
        
        UserApi apiInstance = new UserApi();
        String username = username_example; // String | The name that needs to be fetched. Use user1 for testing.
        try {
            User result = apiInstance.getUserByName(username);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#getUserByName");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UserApi;

public class UserApiExample {

    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        String username = username_example; // String | The name that needs to be fetched. Use user1 for testing.
        try {
            User result = apiInstance.getUserByName(username);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#getUserByName");
            e.printStackTrace();
        }
    }
}

String *username = username_example; // The name that needs to be fetched. Use user1 for testing.

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

// Get user by user name
[apiInstance getUserByNameWith:username
              completionHandler: ^(User output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ReaListApi = require('rea_list_api');

var api = new ReaListApi.UserApi()

var username = username_example; // {String} The name that needs to be fetched. Use user1 for testing.


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

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

namespace Example
{
    public class getUserByNameExample
    {
        public void main()
        {
            
            var apiInstance = new UserApi();
            var username = username_example;  // String | The name that needs to be fetched. Use user1 for testing.

            try
            {
                // Get user by user name
                User result = apiInstance.getUserByName(username);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.getUserByName: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\UserApi();
$username = username_example; // String | The name that needs to be fetched. Use user1 for testing.

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

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

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $username = username_example; # String | The name that needs to be fetched. Use user1 for testing.

eval { 
    my $result = $api_instance->getUserByName(username => $username);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->getUserByName: $@\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.UserApi()
username = username_example # String | The name that needs to be fetched. Use user1 for testing.

try: 
    # Get user by user name
    api_response = api_instance.get_user_by_name(username)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->getUserByName: %s\n" % e)

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

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

public class UserApiExample {

    public static void main(String[] args) {
        
        UserApi apiInstance = new UserApi();
        String username = username_example; // String | The user name for login
        String password = password_example; // String | The password for login in clear text
        try {
            'String' result = apiInstance.loginUser(username, password);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#loginUser");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UserApi;

public class UserApiExample {

    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        String username = username_example; // String | The user name for login
        String password = password_example; // String | The password for login in clear text
        try {
            'String' result = apiInstance.loginUser(username, password);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#loginUser");
            e.printStackTrace();
        }
    }
}

String *username = username_example; // The user name for login
String *password = password_example; // The password for login in clear text

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

// Logs user into the system
[apiInstance loginUserWith:username
    password:password
              completionHandler: ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ReaListApi = require('rea_list_api');

var api = new ReaListApi.UserApi()

var username = username_example; // {String} The user name for login

var password = password_example; // {String} The password for login in clear text


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

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

namespace Example
{
    public class loginUserExample
    {
        public void main()
        {
            
            var apiInstance = new UserApi();
            var username = username_example;  // String | The user name for login
            var password = password_example;  // String | The password for login in clear text

            try
            {
                // Logs user into the system
                'String' result = apiInstance.loginUser(username, password);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.loginUser: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\UserApi();
$username = username_example; // String | The user name for login
$password = password_example; // String | The password for login in clear text

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

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

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $username = username_example; # String | The user name for login
my $password = password_example; # String | The password for login in clear text

eval { 
    my $result = $api_instance->loginUser(username => $username, password => $password);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->loginUser: $@\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.UserApi()
username = username_example # String | The user name for login
password = password_example # String | The password for login in clear text

try: 
    # Logs user into the system
    api_response = api_instance.login_user(username, password)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->loginUser: %s\n" % e)

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

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

public class UserApiExample {

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

import io.swagger.client.api.UserApi;

public class UserApiExample {

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

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

// Logs out current logged in user session
[apiInstance logoutUserWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ReaListApi = require('rea_list_api');

var api = new ReaListApi.UserApi()

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

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

namespace Example
{
    public class logoutUserExample
    {
        public void main()
        {
            
            var apiInstance = new UserApi();

            try
            {
                // Logs out current logged in user session
                apiInstance.logoutUser();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.logoutUser: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    $api_instance->logoutUser();
};
if ($@) {
    warn "Exception when calling UserApi->logoutUser: $@\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.UserApi()

try: 
    # Logs out current logged in user session
    api_instance.logout_user()
except ApiException as e:
    print("Exception when calling UserApi->logoutUser: %s\n" % e)

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

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

public class UserApiExample {

    public static void main(String[] args) {
        
        UserApi apiInstance = new UserApi();
        String username = username_example; // String | name that need to be updated
        User body = ; // User | Updated user object
        try {
            apiInstance.updateUser(username, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#updateUser");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UserApi;

public class UserApiExample {

    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        String username = username_example; // String | name that need to be updated
        User body = ; // User | Updated user object
        try {
            apiInstance.updateUser(username, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#updateUser");
            e.printStackTrace();
        }
    }
}

String *username = username_example; // name that need to be updated
User *body = ; // Updated user object

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

// Updated user
[apiInstance updateUserWith:username
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ReaListApi = require('rea_list_api');

var api = new ReaListApi.UserApi()

var username = username_example; // {String} name that need to be updated

var body = ; // {User} Updated user object


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateUser(username, body, 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()
        {
            
            var apiInstance = new UserApi();
            var username = username_example;  // String | name that need to be updated
            var body = new User(); // User | Updated user object

            try
            {
                // Updated user
                apiInstance.updateUser(username, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.updateUser: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\UserApi();
$username = username_example; // String | name that need to be updated
$body = ; // User | Updated user object

try {
    $api_instance->updateUser($username, $body);
} catch (Exception $e) {
    echo 'Exception when calling UserApi->updateUser: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $username = username_example; # String | name that need to be updated
my $body = WWW::SwaggerClient::Object::User->new(); # User | Updated user object

eval { 
    $api_instance->updateUser(username => $username, body => $body);
};
if ($@) {
    warn "Exception when calling UserApi->updateUser: $@\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.UserApi()
username = username_example # String | name that need to be updated
body =  # User | Updated user object

try: 
    # Updated user
    api_instance.update_user(username, body)
except ApiException as e:
    print("Exception when calling UserApi->updateUser: %s\n" % e)