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

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

public class AccountApiExample {

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

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

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

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

[apiInstance apiV1AccountGetWithCompletionHandler: 
              ^(AccountPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new AccountApi();

            try
            {
                AccountPagingList result = apiInstance.apiV1AccountGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiV1AccountGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAccountApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1AccountGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountApi->apiV1AccountGet: $@\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.AccountApi()

try: 
    api_response = api_instance.api_v1_account_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->apiV1AccountGet: %s\n" % e)

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

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

public class AccountApiExample {

    public static void main(String[] args) {
        
        AccountApi apiInstance = new AccountApi();
        Long id = 789; // Long | 
        try {
            apiInstance.apiV1AccountIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiV1AccountIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        Long id = 789; // Long | 
        try {
            apiInstance.apiV1AccountIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiV1AccountIdDelete");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.AccountApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new AccountApi();
            var id = 789;  // Long | 

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

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

$api_instance = new Swagger\Client\ApiAccountApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $id = 789; # Long | 

eval { 
    $api_instance->apiV1AccountIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling AccountApi->apiV1AccountIdDelete: $@\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.AccountApi()
id = 789 # Long | 

try: 
    api_instance.api_v1_account_id_delete(id)
except ApiException as e:
    print("Exception when calling AccountApi->apiV1AccountIdDelete: %s\n" % e)

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

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

public class AccountApiExample {

    public static void main(String[] args) {
        
        AccountApi apiInstance = new AccountApi();
        Long id = 789; // Long | 
        try {
            Account result = apiInstance.apiV1AccountIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiV1AccountIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        Long id = 789; // Long | 
        try {
            Account result = apiInstance.apiV1AccountIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiV1AccountIdGet");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.AccountApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new AccountApi();
            var id = 789;  // Long | 

            try
            {
                Account result = apiInstance.apiV1AccountIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiV1AccountIdGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAccountApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->apiV1AccountIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountApi->apiV1AccountIdGet: $@\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.AccountApi()
id = 789 # Long | 

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

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

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

public class AccountApiExample {

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

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

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

Account *body = ; //  (optional)

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.AccountApi()
var opts = { 
  'body':  // {{Account}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1AccountPost(opts, callback);

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

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

            var apiInstance = new AccountApi();
            var body = new Account(); // Account |  (optional) 

            try
            {
                Account result = apiInstance.apiV1AccountPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiV1AccountPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // Account | 

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

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

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

eval { 
    my $result = $api_instance->apiV1AccountPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountApi->apiV1AccountPost: $@\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.AccountApi()
body =  # Account |  (optional)

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

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

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

public class AccountApiExample {

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

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

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

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

[apiInstance apiV1AccountPublicKeyGetWithCompletionHandler: 
              ^(KeyObject output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new AccountApi();

            try
            {
                KeyObject result = apiInstance.apiV1AccountPublicKeyGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiV1AccountPublicKeyGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAccountApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1AccountPublicKeyGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountApi->apiV1AccountPublicKeyGet: $@\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.AccountApi()

try: 
    api_response = api_instance.api_v1_account_public_key_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->apiV1AccountPublicKeyGet: %s\n" % e)

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

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

public class AccountApiExample {

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

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

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

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

[apiInstance apiV1AccountPutWithCompletionHandler: 
              ^(Account output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new AccountApi();

            try
            {
                Account result = apiInstance.apiV1AccountPut();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiV1AccountPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAccountApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1AccountPut();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountApi->apiV1AccountPut: $@\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.AccountApi()

try: 
    api_response = api_instance.api_v1_account_put()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->apiV1AccountPut: %s\n" % e)

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

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

public class AccountApiExample {

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

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

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

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

[apiInstance apiV1AccountSearchGetWithCompletionHandler: 
              ^(AccountPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new AccountApi();

            try
            {
                AccountPagingList result = apiInstance.apiV1AccountSearchGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiV1AccountSearchGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAccountApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1AccountSearchGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountApi->apiV1AccountSearchGet: $@\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.AccountApi()

try: 
    api_response = api_instance.api_v1_account_search_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->apiV1AccountSearchGet: %s\n" % e)

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

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

public class AccountApiExample {

    public static void main(String[] args) {
        
        AccountApi apiInstance = new AccountApi();
        TopUp body = ; // TopUp | 
        try {
            apiInstance.apiV1AccountTopupPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiV1AccountTopupPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        TopUp body = ; // TopUp | 
        try {
            apiInstance.apiV1AccountTopupPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiV1AccountTopupPost");
            e.printStackTrace();
        }
    }
}

TopUp *body = ; //  (optional)

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.AccountApi()
var opts = { 
  'body':  // {{TopUp}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiV1AccountTopupPost(opts, callback);

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

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

            var apiInstance = new AccountApi();
            var body = new TopUp(); // TopUp |  (optional) 

            try
            {
                apiInstance.apiV1AccountTopupPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiV1AccountTopupPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // TopUp | 

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

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

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

eval { 
    $api_instance->apiV1AccountTopupPost(body => $body);
};
if ($@) {
    warn "Exception when calling AccountApi->apiV1AccountTopupPost: $@\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.AccountApi()
body =  # TopUp |  (optional)

try: 
    api_instance.api_v1_account_topup_post(body=body)
except ApiException as e:
    print("Exception when calling AccountApi->apiV1AccountTopupPost: %s\n" % e)

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

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

public class AnalyticsApiExample {

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

import io.swagger.client.api.AnalyticsApi;

public class AnalyticsApiExample {

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

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

[apiInstance apiV1AnalyticsGetWithCompletionHandler: 
              ^(AnalyticEventPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new AnalyticsApi();

            try
            {
                AnalyticEventPagingList result = apiInstance.apiV1AnalyticsGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AnalyticsApi.apiV1AnalyticsGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAnalyticsApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1AnalyticsGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AnalyticsApi->apiV1AnalyticsGet: $@\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.AnalyticsApi()

try: 
    api_response = api_instance.api_v1_analytics_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AnalyticsApi->apiV1AnalyticsGet: %s\n" % e)

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

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

public class AnalyticsApiExample {

    public static void main(String[] args) {
        
        AnalyticsApi apiInstance = new AnalyticsApi();
        Long id = 789; // Long | 
        try {
            AnalyticEvent result = apiInstance.apiV1AnalyticsIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnalyticsApi#apiV1AnalyticsIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AnalyticsApi;

public class AnalyticsApiExample {

    public static void main(String[] args) {
        AnalyticsApi apiInstance = new AnalyticsApi();
        Long id = 789; // Long | 
        try {
            AnalyticEvent result = apiInstance.apiV1AnalyticsIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnalyticsApi#apiV1AnalyticsIdGet");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.AnalyticsApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new AnalyticsApi();
            var id = 789;  // Long | 

            try
            {
                AnalyticEvent result = apiInstance.apiV1AnalyticsIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AnalyticsApi.apiV1AnalyticsIdGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAnalyticsApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::AnalyticsApi->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->apiV1AnalyticsIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AnalyticsApi->apiV1AnalyticsIdGet: $@\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.AnalyticsApi()
id = 789 # Long | 

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

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

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

public class AnalyticsApiExample {

    public static void main(String[] args) {
        
        AnalyticsApi apiInstance = new AnalyticsApi();
        AnalyticEvent body = ; // AnalyticEvent | 
        try {
            apiInstance.apiV1AnalyticsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnalyticsApi#apiV1AnalyticsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AnalyticsApi;

public class AnalyticsApiExample {

    public static void main(String[] args) {
        AnalyticsApi apiInstance = new AnalyticsApi();
        AnalyticEvent body = ; // AnalyticEvent | 
        try {
            apiInstance.apiV1AnalyticsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnalyticsApi#apiV1AnalyticsPost");
            e.printStackTrace();
        }
    }
}

AnalyticEvent *body = ; //  (optional)

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.AnalyticsApi()
var opts = { 
  'body':  // {{AnalyticEvent}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiV1AnalyticsPost(opts, callback);

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

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

            var apiInstance = new AnalyticsApi();
            var body = new AnalyticEvent(); // AnalyticEvent |  (optional) 

            try
            {
                apiInstance.apiV1AnalyticsPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AnalyticsApi.apiV1AnalyticsPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAnalyticsApi();
$body = ; // AnalyticEvent | 

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

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

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

eval { 
    $api_instance->apiV1AnalyticsPost(body => $body);
};
if ($@) {
    warn "Exception when calling AnalyticsApi->apiV1AnalyticsPost: $@\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.AnalyticsApi()
body =  # AnalyticEvent |  (optional)

try: 
    api_instance.api_v1_analytics_post(body=body)
except ApiException as e:
    print("Exception when calling AnalyticsApi->apiV1AnalyticsPost: %s\n" % e)

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

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

public class AnalyticsApiExample {

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

import io.swagger.client.api.AnalyticsApi;

public class AnalyticsApiExample {

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

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

[apiInstance apiV1AnalyticsSearchGetWithCompletionHandler: 
              ^(AnalyticEventPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new AnalyticsApi();

            try
            {
                AnalyticEventPagingList result = apiInstance.apiV1AnalyticsSearchGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AnalyticsApi.apiV1AnalyticsSearchGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAnalyticsApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1AnalyticsSearchGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AnalyticsApi->apiV1AnalyticsSearchGet: $@\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.AnalyticsApi()

try: 
    api_response = api_instance.api_v1_analytics_search_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AnalyticsApi->apiV1AnalyticsSearchGet: %s\n" % e)

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

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

public class AssetApiExample {

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

import io.swagger.client.api.AssetApi;

public class AssetApiExample {

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

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

[apiInstance apiV1AssetsGetWithCompletionHandler: 
              ^(AssetPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new AssetApi();

            try
            {
                AssetPagingList result = apiInstance.apiV1AssetsGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetApi.apiV1AssetsGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAssetApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1AssetsGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetApi->apiV1AssetsGet: $@\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.AssetApi()

try: 
    api_response = api_instance.api_v1_assets_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetApi->apiV1AssetsGet: %s\n" % e)

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

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

public class AssetApiExample {

    public static void main(String[] args) {
        
        AssetApi apiInstance = new AssetApi();
        Long id = 789; // Long | 
        try {
            apiInstance.apiV1AssetsIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetApi#apiV1AssetsIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AssetApi;

public class AssetApiExample {

    public static void main(String[] args) {
        AssetApi apiInstance = new AssetApi();
        Long id = 789; // Long | 
        try {
            apiInstance.apiV1AssetsIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetApi#apiV1AssetsIdDelete");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.AssetApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new AssetApi();
            var id = 789;  // Long | 

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

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

$api_instance = new Swagger\Client\ApiAssetApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::AssetApi->new();
my $id = 789; # Long | 

eval { 
    $api_instance->apiV1AssetsIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling AssetApi->apiV1AssetsIdDelete: $@\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.AssetApi()
id = 789 # Long | 

try: 
    api_instance.api_v1_assets_id_delete(id)
except ApiException as e:
    print("Exception when calling AssetApi->apiV1AssetsIdDelete: %s\n" % e)

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

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

public class AssetApiExample {

    public static void main(String[] args) {
        
        AssetApi apiInstance = new AssetApi();
        Long id = 789; // Long | 
        try {
            Asset result = apiInstance.apiV1AssetsIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetApi#apiV1AssetsIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AssetApi;

public class AssetApiExample {

    public static void main(String[] args) {
        AssetApi apiInstance = new AssetApi();
        Long id = 789; // Long | 
        try {
            Asset result = apiInstance.apiV1AssetsIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetApi#apiV1AssetsIdGet");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.AssetApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new AssetApi();
            var id = 789;  // Long | 

            try
            {
                Asset result = apiInstance.apiV1AssetsIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetApi.apiV1AssetsIdGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAssetApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::AssetApi->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->apiV1AssetsIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetApi->apiV1AssetsIdGet: $@\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.AssetApi()
id = 789 # Long | 

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

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

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

public class AssetApiExample {

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

import io.swagger.client.api.AssetApi;

public class AssetApiExample {

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

Asset *body = ; //  (optional)

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.AssetApi()
var opts = { 
  'body':  // {{Asset}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1AssetsPost(opts, callback);

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

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

            var apiInstance = new AssetApi();
            var body = new Asset(); // Asset |  (optional) 

            try
            {
                Asset result = apiInstance.apiV1AssetsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetApi.apiV1AssetsPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAssetApi();
$body = ; // Asset | 

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

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

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

eval { 
    my $result = $api_instance->apiV1AssetsPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetApi->apiV1AssetsPost: $@\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.AssetApi()
body =  # Asset |  (optional)

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

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

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

public class AssetApiExample {

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

import io.swagger.client.api.AssetApi;

public class AssetApiExample {

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

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

[apiInstance apiV1AssetsPutWithCompletionHandler: 
              ^(Asset output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new AssetApi();

            try
            {
                Asset result = apiInstance.apiV1AssetsPut();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetApi.apiV1AssetsPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAssetApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1AssetsPut();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetApi->apiV1AssetsPut: $@\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.AssetApi()

try: 
    api_response = api_instance.api_v1_assets_put()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetApi->apiV1AssetsPut: %s\n" % e)

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

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

public class AssetApiExample {

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

import io.swagger.client.api.AssetApi;

public class AssetApiExample {

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

Asset *body = ; //  (optional)

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.AssetApi()
var opts = { 
  'body':  // {{Asset}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1AssetsResavePost(opts, callback);

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

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

            var apiInstance = new AssetApi();
            var body = new Asset(); // Asset |  (optional) 

            try
            {
                Asset result = apiInstance.apiV1AssetsResavePost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetApi.apiV1AssetsResavePost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAssetApi();
$body = ; // Asset | 

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

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

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

eval { 
    my $result = $api_instance->apiV1AssetsResavePost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetApi->apiV1AssetsResavePost: $@\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.AssetApi()
body =  # Asset |  (optional)

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

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

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

public class AssetApiExample {

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

import io.swagger.client.api.AssetApi;

public class AssetApiExample {

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

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

[apiInstance apiV1AssetsSearchGetWithCompletionHandler: 
              ^(AssetPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new AssetApi();

            try
            {
                AssetPagingList result = apiInstance.apiV1AssetsSearchGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetApi.apiV1AssetsSearchGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAssetApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1AssetsSearchGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetApi->apiV1AssetsSearchGet: $@\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.AssetApi()

try: 
    api_response = api_instance.api_v1_assets_search_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetApi->apiV1AssetsSearchGet: %s\n" % e)

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

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

public class AssetSourceApiExample {

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

import io.swagger.client.api.AssetSourceApi;

public class AssetSourceApiExample {

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

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

[apiInstance apiV1AssetSourcesGetWithCompletionHandler: 
              ^(AssetSourcePagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new AssetSourceApi();

            try
            {
                AssetSourcePagingList result = apiInstance.apiV1AssetSourcesGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetSourceApi.apiV1AssetSourcesGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAssetSourceApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1AssetSourcesGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetSourceApi->apiV1AssetSourcesGet: $@\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.AssetSourceApi()

try: 
    api_response = api_instance.api_v1_asset_sources_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetSourceApi->apiV1AssetSourcesGet: %s\n" % e)

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

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

public class AssetSourceApiExample {

    public static void main(String[] args) {
        
        AssetSourceApi apiInstance = new AssetSourceApi();
        Long id = 789; // Long | 
        try {
            apiInstance.apiV1AssetSourcesIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetSourceApi#apiV1AssetSourcesIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AssetSourceApi;

public class AssetSourceApiExample {

    public static void main(String[] args) {
        AssetSourceApi apiInstance = new AssetSourceApi();
        Long id = 789; // Long | 
        try {
            apiInstance.apiV1AssetSourcesIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetSourceApi#apiV1AssetSourcesIdDelete");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.AssetSourceApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new AssetSourceApi();
            var id = 789;  // Long | 

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

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

$api_instance = new Swagger\Client\ApiAssetSourceApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::AssetSourceApi->new();
my $id = 789; # Long | 

eval { 
    $api_instance->apiV1AssetSourcesIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling AssetSourceApi->apiV1AssetSourcesIdDelete: $@\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.AssetSourceApi()
id = 789 # Long | 

try: 
    api_instance.api_v1_asset_sources_id_delete(id)
except ApiException as e:
    print("Exception when calling AssetSourceApi->apiV1AssetSourcesIdDelete: %s\n" % e)

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

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

public class AssetSourceApiExample {

    public static void main(String[] args) {
        
        AssetSourceApi apiInstance = new AssetSourceApi();
        Long id = 789; // Long | 
        try {
            AssetSource result = apiInstance.apiV1AssetSourcesIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetSourceApi#apiV1AssetSourcesIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AssetSourceApi;

public class AssetSourceApiExample {

    public static void main(String[] args) {
        AssetSourceApi apiInstance = new AssetSourceApi();
        Long id = 789; // Long | 
        try {
            AssetSource result = apiInstance.apiV1AssetSourcesIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetSourceApi#apiV1AssetSourcesIdGet");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.AssetSourceApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new AssetSourceApi();
            var id = 789;  // Long | 

            try
            {
                AssetSource result = apiInstance.apiV1AssetSourcesIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetSourceApi.apiV1AssetSourcesIdGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAssetSourceApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::AssetSourceApi->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->apiV1AssetSourcesIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetSourceApi->apiV1AssetSourcesIdGet: $@\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.AssetSourceApi()
id = 789 # Long | 

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

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

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

public class AssetSourceApiExample {

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

import io.swagger.client.api.AssetSourceApi;

public class AssetSourceApiExample {

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

AssetSource *body = ; //  (optional)

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.AssetSourceApi()
var opts = { 
  'body':  // {{AssetSource}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1AssetSourcesPost(opts, callback);

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

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

            var apiInstance = new AssetSourceApi();
            var body = new AssetSource(); // AssetSource |  (optional) 

            try
            {
                AssetSource result = apiInstance.apiV1AssetSourcesPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetSourceApi.apiV1AssetSourcesPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAssetSourceApi();
$body = ; // AssetSource | 

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

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

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

eval { 
    my $result = $api_instance->apiV1AssetSourcesPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetSourceApi->apiV1AssetSourcesPost: $@\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.AssetSourceApi()
body =  # AssetSource |  (optional)

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

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

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

public class AssetSourceApiExample {

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

import io.swagger.client.api.AssetSourceApi;

public class AssetSourceApiExample {

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

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

[apiInstance apiV1AssetSourcesPutWithCompletionHandler: 
              ^(AssetSource output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new AssetSourceApi();

            try
            {
                AssetSource result = apiInstance.apiV1AssetSourcesPut();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetSourceApi.apiV1AssetSourcesPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAssetSourceApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1AssetSourcesPut();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetSourceApi->apiV1AssetSourcesPut: $@\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.AssetSourceApi()

try: 
    api_response = api_instance.api_v1_asset_sources_put()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetSourceApi->apiV1AssetSourcesPut: %s\n" % e)

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

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

public class AssetSourceApiExample {

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

import io.swagger.client.api.AssetSourceApi;

public class AssetSourceApiExample {

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

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

[apiInstance apiV1AssetSourcesSearchGetWithCompletionHandler: 
              ^(AssetSourcePagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new AssetSourceApi();

            try
            {
                AssetSourcePagingList result = apiInstance.apiV1AssetSourcesSearchGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetSourceApi.apiV1AssetSourcesSearchGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAssetSourceApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1AssetSourcesSearchGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetSourceApi->apiV1AssetSourcesSearchGet: $@\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.AssetSourceApi()

try: 
    api_response = api_instance.api_v1_asset_sources_search_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetSourceApi->apiV1AssetSourcesSearchGet: %s\n" % e)

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

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

public class AuditApiExample {

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

import io.swagger.client.api.AuditApi;

public class AuditApiExample {

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

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

[apiInstance apiV1AuditGetWithCompletionHandler: 
              ^(AuditEntryPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new AuditApi();

            try
            {
                AuditEntryPagingList result = apiInstance.apiV1AuditGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuditApi.apiV1AuditGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAuditApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1AuditGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuditApi->apiV1AuditGet: $@\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.AuditApi()

try: 
    api_response = api_instance.api_v1_audit_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuditApi->apiV1AuditGet: %s\n" % e)

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

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

public class AuditApiExample {

    public static void main(String[] args) {
        
        AuditApi apiInstance = new AuditApi();
        Long id = 789; // Long | 
        try {
            AuditEntry result = apiInstance.apiV1AuditIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuditApi#apiV1AuditIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AuditApi;

public class AuditApiExample {

    public static void main(String[] args) {
        AuditApi apiInstance = new AuditApi();
        Long id = 789; // Long | 
        try {
            AuditEntry result = apiInstance.apiV1AuditIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuditApi#apiV1AuditIdGet");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.AuditApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new AuditApi();
            var id = 789;  // Long | 

            try
            {
                AuditEntry result = apiInstance.apiV1AuditIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuditApi.apiV1AuditIdGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAuditApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::AuditApi->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->apiV1AuditIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuditApi->apiV1AuditIdGet: $@\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.AuditApi()
id = 789 # Long | 

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

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

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

public class AuditApiExample {

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

import io.swagger.client.api.AuditApi;

public class AuditApiExample {

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

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

[apiInstance apiV1AuditSearchGetWithCompletionHandler: 
              ^(AuditEntryPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new AuditApi();

            try
            {
                AuditEntryPagingList result = apiInstance.apiV1AuditSearchGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuditApi.apiV1AuditSearchGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAuditApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1AuditSearchGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuditApi->apiV1AuditSearchGet: $@\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.AuditApi()

try: 
    api_response = api_instance.api_v1_audit_search_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuditApi->apiV1AuditSearchGet: %s\n" % e)

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

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

public class BrandApiExample {

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

import io.swagger.client.api.BrandApi;

public class BrandApiExample {

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

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

[apiInstance apiV1BrandsGetWithCompletionHandler: 
              ^(BrandPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new BrandApi();

            try
            {
                BrandPagingList result = apiInstance.apiV1BrandsGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BrandApi.apiV1BrandsGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiBrandApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1BrandsGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BrandApi->apiV1BrandsGet: $@\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.BrandApi()

try: 
    api_response = api_instance.api_v1_brands_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BrandApi->apiV1BrandsGet: %s\n" % e)

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

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

public class BrandApiExample {

    public static void main(String[] args) {
        
        BrandApi apiInstance = new BrandApi();
        Long id = 789; // Long | 
        try {
            apiInstance.apiV1BrandsIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling BrandApi#apiV1BrandsIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BrandApi;

public class BrandApiExample {

    public static void main(String[] args) {
        BrandApi apiInstance = new BrandApi();
        Long id = 789; // Long | 
        try {
            apiInstance.apiV1BrandsIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling BrandApi#apiV1BrandsIdDelete");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.BrandApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new BrandApi();
            var id = 789;  // Long | 

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

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

$api_instance = new Swagger\Client\ApiBrandApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::BrandApi->new();
my $id = 789; # Long | 

eval { 
    $api_instance->apiV1BrandsIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling BrandApi->apiV1BrandsIdDelete: $@\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.BrandApi()
id = 789 # Long | 

try: 
    api_instance.api_v1_brands_id_delete(id)
except ApiException as e:
    print("Exception when calling BrandApi->apiV1BrandsIdDelete: %s\n" % e)

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

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

public class BrandApiExample {

    public static void main(String[] args) {
        
        BrandApi apiInstance = new BrandApi();
        Long id = 789; // Long | 
        try {
            Brand result = apiInstance.apiV1BrandsIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BrandApi#apiV1BrandsIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BrandApi;

public class BrandApiExample {

    public static void main(String[] args) {
        BrandApi apiInstance = new BrandApi();
        Long id = 789; // Long | 
        try {
            Brand result = apiInstance.apiV1BrandsIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BrandApi#apiV1BrandsIdGet");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.BrandApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new BrandApi();
            var id = 789;  // Long | 

            try
            {
                Brand result = apiInstance.apiV1BrandsIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BrandApi.apiV1BrandsIdGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiBrandApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::BrandApi->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->apiV1BrandsIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BrandApi->apiV1BrandsIdGet: $@\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.BrandApi()
id = 789 # Long | 

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

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

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

public class BrandApiExample {

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

import io.swagger.client.api.BrandApi;

public class BrandApiExample {

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

Brand *body = ; //  (optional)

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.BrandApi()
var opts = { 
  'body':  // {{Brand}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1BrandsPost(opts, callback);

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

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

            var apiInstance = new BrandApi();
            var body = new Brand(); // Brand |  (optional) 

            try
            {
                Brand result = apiInstance.apiV1BrandsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BrandApi.apiV1BrandsPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiBrandApi();
$body = ; // Brand | 

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

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

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

eval { 
    my $result = $api_instance->apiV1BrandsPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BrandApi->apiV1BrandsPost: $@\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.BrandApi()
body =  # Brand |  (optional)

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

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

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

public class BrandApiExample {

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

import io.swagger.client.api.BrandApi;

public class BrandApiExample {

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

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

[apiInstance apiV1BrandsPutWithCompletionHandler: 
              ^(Brand output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new BrandApi();

            try
            {
                Brand result = apiInstance.apiV1BrandsPut();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BrandApi.apiV1BrandsPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiBrandApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1BrandsPut();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BrandApi->apiV1BrandsPut: $@\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.BrandApi()

try: 
    api_response = api_instance.api_v1_brands_put()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BrandApi->apiV1BrandsPut: %s\n" % e)

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

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

public class BrandApiExample {

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

import io.swagger.client.api.BrandApi;

public class BrandApiExample {

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

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

[apiInstance apiV1BrandsSearchGetWithCompletionHandler: 
              ^(BrandPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new BrandApi();

            try
            {
                BrandPagingList result = apiInstance.apiV1BrandsSearchGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BrandApi.apiV1BrandsSearchGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiBrandApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1BrandsSearchGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BrandApi->apiV1BrandsSearchGet: $@\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.BrandApi()

try: 
    api_response = api_instance.api_v1_brands_search_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BrandApi->apiV1BrandsSearchGet: %s\n" % e)

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

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

public class CallServiceApiExample {

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

import io.swagger.client.api.CallServiceApi;

public class CallServiceApiExample {

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

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

[apiInstance apiV1CallServicesGetWithCompletionHandler: 
              ^(CallServicePagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new CallServiceApi();

            try
            {
                CallServicePagingList result = apiInstance.apiV1CallServicesGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CallServiceApi.apiV1CallServicesGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCallServiceApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1CallServicesGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CallServiceApi->apiV1CallServicesGet: $@\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.CallServiceApi()

try: 
    api_response = api_instance.api_v1_call_services_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CallServiceApi->apiV1CallServicesGet: %s\n" % e)

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

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

public class CallServiceApiExample {

    public static void main(String[] args) {
        
        CallServiceApi apiInstance = new CallServiceApi();
        Long id = 789; // Long | 
        try {
            apiInstance.apiV1CallServicesIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling CallServiceApi#apiV1CallServicesIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CallServiceApi;

public class CallServiceApiExample {

    public static void main(String[] args) {
        CallServiceApi apiInstance = new CallServiceApi();
        Long id = 789; // Long | 
        try {
            apiInstance.apiV1CallServicesIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling CallServiceApi#apiV1CallServicesIdDelete");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.CallServiceApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new CallServiceApi();
            var id = 789;  // Long | 

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

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

$api_instance = new Swagger\Client\ApiCallServiceApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::CallServiceApi->new();
my $id = 789; # Long | 

eval { 
    $api_instance->apiV1CallServicesIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling CallServiceApi->apiV1CallServicesIdDelete: $@\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.CallServiceApi()
id = 789 # Long | 

try: 
    api_instance.api_v1_call_services_id_delete(id)
except ApiException as e:
    print("Exception when calling CallServiceApi->apiV1CallServicesIdDelete: %s\n" % e)

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

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

public class CallServiceApiExample {

    public static void main(String[] args) {
        
        CallServiceApi apiInstance = new CallServiceApi();
        Long id = 789; // Long | 
        try {
            CallService result = apiInstance.apiV1CallServicesIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CallServiceApi#apiV1CallServicesIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CallServiceApi;

public class CallServiceApiExample {

    public static void main(String[] args) {
        CallServiceApi apiInstance = new CallServiceApi();
        Long id = 789; // Long | 
        try {
            CallService result = apiInstance.apiV1CallServicesIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CallServiceApi#apiV1CallServicesIdGet");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.CallServiceApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new CallServiceApi();
            var id = 789;  // Long | 

            try
            {
                CallService result = apiInstance.apiV1CallServicesIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CallServiceApi.apiV1CallServicesIdGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCallServiceApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::CallServiceApi->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->apiV1CallServicesIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CallServiceApi->apiV1CallServicesIdGet: $@\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.CallServiceApi()
id = 789 # Long | 

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

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

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

public class CallServiceApiExample {

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

import io.swagger.client.api.CallServiceApi;

public class CallServiceApiExample {

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

CallService *body = ; //  (optional)

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.CallServiceApi()
var opts = { 
  'body':  // {{CallService}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1CallServicesPost(opts, callback);

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

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

            var apiInstance = new CallServiceApi();
            var body = new CallService(); // CallService |  (optional) 

            try
            {
                CallService result = apiInstance.apiV1CallServicesPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CallServiceApi.apiV1CallServicesPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCallServiceApi();
$body = ; // CallService | 

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

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

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

eval { 
    my $result = $api_instance->apiV1CallServicesPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CallServiceApi->apiV1CallServicesPost: $@\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.CallServiceApi()
body =  # CallService |  (optional)

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

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

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

public class CallServiceApiExample {

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

import io.swagger.client.api.CallServiceApi;

public class CallServiceApiExample {

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

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

[apiInstance apiV1CallServicesPutWithCompletionHandler: 
              ^(CallService output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new CallServiceApi();

            try
            {
                CallService result = apiInstance.apiV1CallServicesPut();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CallServiceApi.apiV1CallServicesPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCallServiceApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1CallServicesPut();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CallServiceApi->apiV1CallServicesPut: $@\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.CallServiceApi()

try: 
    api_response = api_instance.api_v1_call_services_put()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CallServiceApi->apiV1CallServicesPut: %s\n" % e)

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

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

public class CallServiceApiExample {

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

import io.swagger.client.api.CallServiceApi;

public class CallServiceApiExample {

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

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

[apiInstance apiV1CallServicesSearchGetWithCompletionHandler: 
              ^(CallServicePagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new CallServiceApi();

            try
            {
                CallServicePagingList result = apiInstance.apiV1CallServicesSearchGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CallServiceApi.apiV1CallServicesSearchGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCallServiceApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1CallServicesSearchGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CallServiceApi->apiV1CallServicesSearchGet: $@\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.CallServiceApi()

try: 
    api_response = api_instance.api_v1_call_services_search_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CallServiceApi->apiV1CallServicesSearchGet: %s\n" % e)

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

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

public class ChatApiExample {

    public static void main(String[] args) {
        
        ChatApi apiInstance = new ChatApi();
        Long customerId = 789; // Long | 
        try {
            MessagePagingList result = apiInstance.apiV1ChatCustomerCustomerIdGet(customerId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ChatApi#apiV1ChatCustomerCustomerIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ChatApi;

public class ChatApiExample {

    public static void main(String[] args) {
        ChatApi apiInstance = new ChatApi();
        Long customerId = 789; // Long | 
        try {
            MessagePagingList result = apiInstance.apiV1ChatCustomerCustomerIdGet(customerId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ChatApi#apiV1ChatCustomerCustomerIdGet");
            e.printStackTrace();
        }
    }
}

Long *customerId = 789; // 

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

[apiInstance apiV1ChatCustomerCustomerIdGetWith:customerId
              completionHandler: ^(MessagePagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.ChatApi()
var customerId = 789; // {{Long}} 

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

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

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

            var apiInstance = new ChatApi();
            var customerId = 789;  // Long | 

            try
            {
                MessagePagingList result = apiInstance.apiV1ChatCustomerCustomerIdGet(customerId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ChatApi.apiV1ChatCustomerCustomerIdGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiChatApi();
$customerId = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::ChatApi->new();
my $customerId = 789; # Long | 

eval { 
    my $result = $api_instance->apiV1ChatCustomerCustomerIdGet(customerId => $customerId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ChatApi->apiV1ChatCustomerCustomerIdGet: $@\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.ChatApi()
customerId = 789 # Long | 

try: 
    api_response = api_instance.api_v1_chat_customer_customer_id_get(customerId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ChatApi->apiV1ChatCustomerCustomerIdGet: %s\n" % e)

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

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

public class ChatApiExample {

    public static void main(String[] args) {
        
        ChatApi apiInstance = new ChatApi();
        Long roomId = 789; // Long | 
        try {
            MessagePagingList result = apiInstance.apiV1ChatRoomIdGet(roomId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ChatApi#apiV1ChatRoomIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ChatApi;

public class ChatApiExample {

    public static void main(String[] args) {
        ChatApi apiInstance = new ChatApi();
        Long roomId = 789; // Long | 
        try {
            MessagePagingList result = apiInstance.apiV1ChatRoomIdGet(roomId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ChatApi#apiV1ChatRoomIdGet");
            e.printStackTrace();
        }
    }
}

Long *roomId = 789; // 

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

[apiInstance apiV1ChatRoomIdGetWith:roomId
              completionHandler: ^(MessagePagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.ChatApi()
var roomId = 789; // {{Long}} 

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

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

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

            var apiInstance = new ChatApi();
            var roomId = 789;  // Long | 

            try
            {
                MessagePagingList result = apiInstance.apiV1ChatRoomIdGet(roomId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ChatApi.apiV1ChatRoomIdGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiChatApi();
$roomId = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::ChatApi->new();
my $roomId = 789; # Long | 

eval { 
    my $result = $api_instance->apiV1ChatRoomIdGet(roomId => $roomId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ChatApi->apiV1ChatRoomIdGet: $@\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.ChatApi()
roomId = 789 # Long | 

try: 
    api_response = api_instance.api_v1_chat_room_id_get(roomId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ChatApi->apiV1ChatRoomIdGet: %s\n" % e)

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

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

public class ChatApiExample {

    public static void main(String[] args) {
        
        ChatApi apiInstance = new ChatApi();
        Long roomId = 789; // Long | 
        Message body = ; // Message | 
        try {
            apiInstance.apiV1ChatRoomIdPost(roomId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ChatApi#apiV1ChatRoomIdPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ChatApi;

public class ChatApiExample {

    public static void main(String[] args) {
        ChatApi apiInstance = new ChatApi();
        Long roomId = 789; // Long | 
        Message body = ; // Message | 
        try {
            apiInstance.apiV1ChatRoomIdPost(roomId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ChatApi#apiV1ChatRoomIdPost");
            e.printStackTrace();
        }
    }
}

Long *roomId = 789; // 
Message *body = ; //  (optional)

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.ChatApi()
var roomId = 789; // {{Long}} 
var opts = { 
  'body':  // {{Message}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiV1ChatRoomIdPost(roomId, opts, callback);

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

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

            var apiInstance = new ChatApi();
            var roomId = 789;  // Long | 
            var body = new Message(); // Message |  (optional) 

            try
            {
                apiInstance.apiV1ChatRoomIdPost(roomId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ChatApi.apiV1ChatRoomIdPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiChatApi();
$roomId = 789; // Long | 
$body = ; // Message | 

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

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

my $api_instance = WWW::SwaggerClient::ChatApi->new();
my $roomId = 789; # Long | 
my $body = WWW::SwaggerClient::Object::Message->new(); # Message | 

eval { 
    $api_instance->apiV1ChatRoomIdPost(roomId => $roomId, body => $body);
};
if ($@) {
    warn "Exception when calling ChatApi->apiV1ChatRoomIdPost: $@\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.ChatApi()
roomId = 789 # Long | 
body =  # Message |  (optional)

try: 
    api_instance.api_v1_chat_room_id_post(roomId, body=body)
except ApiException as e:
    print("Exception when calling ChatApi->apiV1ChatRoomIdPost: %s\n" % e)

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

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

public class CustomersApiExample {

    public static void main(String[] args) {
        
        CustomersApi apiInstance = new CustomersApi();
        Long customerId = 789; // Long | 
        Message body = ; // Message | 
        try {
            apiInstance.apiV1CustomersCustomerIdNotesPost(customerId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CustomersApi#apiV1CustomersCustomerIdNotesPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CustomersApi;

public class CustomersApiExample {

    public static void main(String[] args) {
        CustomersApi apiInstance = new CustomersApi();
        Long customerId = 789; // Long | 
        Message body = ; // Message | 
        try {
            apiInstance.apiV1CustomersCustomerIdNotesPost(customerId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CustomersApi#apiV1CustomersCustomerIdNotesPost");
            e.printStackTrace();
        }
    }
}

Long *customerId = 789; // 
Message *body = ; //  (optional)

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.CustomersApi()
var customerId = 789; // {{Long}} 
var opts = { 
  'body':  // {{Message}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiV1CustomersCustomerIdNotesPost(customerId, opts, callback);

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

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

            var apiInstance = new CustomersApi();
            var customerId = 789;  // Long | 
            var body = new Message(); // Message |  (optional) 

            try
            {
                apiInstance.apiV1CustomersCustomerIdNotesPost(customerId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CustomersApi.apiV1CustomersCustomerIdNotesPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCustomersApi();
$customerId = 789; // Long | 
$body = ; // Message | 

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

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

my $api_instance = WWW::SwaggerClient::CustomersApi->new();
my $customerId = 789; # Long | 
my $body = WWW::SwaggerClient::Object::Message->new(); # Message | 

eval { 
    $api_instance->apiV1CustomersCustomerIdNotesPost(customerId => $customerId, body => $body);
};
if ($@) {
    warn "Exception when calling CustomersApi->apiV1CustomersCustomerIdNotesPost: $@\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.CustomersApi()
customerId = 789 # Long | 
body =  # Message |  (optional)

try: 
    api_instance.api_v1_customers_customer_id_notes_post(customerId, body=body)
except ApiException as e:
    print("Exception when calling CustomersApi->apiV1CustomersCustomerIdNotesPost: %s\n" % e)

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

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

public class CustomersApiExample {

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

import io.swagger.client.api.CustomersApi;

public class CustomersApiExample {

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

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

[apiInstance apiV1CustomersGetWithCompletionHandler: 
              ^(CustomerPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new CustomersApi();

            try
            {
                CustomerPagingList result = apiInstance.apiV1CustomersGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CustomersApi.apiV1CustomersGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCustomersApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1CustomersGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CustomersApi->apiV1CustomersGet: $@\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.CustomersApi()

try: 
    api_response = api_instance.api_v1_customers_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CustomersApi->apiV1CustomersGet: %s\n" % e)

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

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

public class CustomersApiExample {

    public static void main(String[] args) {
        
        CustomersApi apiInstance = new CustomersApi();
        Long id = 789; // Long | 
        try {
            apiInstance.apiV1CustomersIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling CustomersApi#apiV1CustomersIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CustomersApi;

public class CustomersApiExample {

    public static void main(String[] args) {
        CustomersApi apiInstance = new CustomersApi();
        Long id = 789; // Long | 
        try {
            apiInstance.apiV1CustomersIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling CustomersApi#apiV1CustomersIdDelete");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.CustomersApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new CustomersApi();
            var id = 789;  // Long | 

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

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

$api_instance = new Swagger\Client\ApiCustomersApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::CustomersApi->new();
my $id = 789; # Long | 

eval { 
    $api_instance->apiV1CustomersIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling CustomersApi->apiV1CustomersIdDelete: $@\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.CustomersApi()
id = 789 # Long | 

try: 
    api_instance.api_v1_customers_id_delete(id)
except ApiException as e:
    print("Exception when calling CustomersApi->apiV1CustomersIdDelete: %s\n" % e)

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

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

public class CustomersApiExample {

    public static void main(String[] args) {
        
        CustomersApi apiInstance = new CustomersApi();
        Long id = 789; // Long | 
        try {
            Customer result = apiInstance.apiV1CustomersIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CustomersApi#apiV1CustomersIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CustomersApi;

public class CustomersApiExample {

    public static void main(String[] args) {
        CustomersApi apiInstance = new CustomersApi();
        Long id = 789; // Long | 
        try {
            Customer result = apiInstance.apiV1CustomersIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CustomersApi#apiV1CustomersIdGet");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.CustomersApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new CustomersApi();
            var id = 789;  // Long | 

            try
            {
                Customer result = apiInstance.apiV1CustomersIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CustomersApi.apiV1CustomersIdGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCustomersApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::CustomersApi->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->apiV1CustomersIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CustomersApi->apiV1CustomersIdGet: $@\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.CustomersApi()
id = 789 # Long | 

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

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

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

public class CustomersApiExample {

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

import io.swagger.client.api.CustomersApi;

public class CustomersApiExample {

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

Customer *body = ; //  (optional)

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.CustomersApi()
var opts = { 
  'body':  // {{Customer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1CustomersPost(opts, callback);

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

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

            var apiInstance = new CustomersApi();
            var body = new Customer(); // Customer |  (optional) 

            try
            {
                Customer result = apiInstance.apiV1CustomersPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CustomersApi.apiV1CustomersPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCustomersApi();
$body = ; // Customer | 

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

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

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

eval { 
    my $result = $api_instance->apiV1CustomersPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CustomersApi->apiV1CustomersPost: $@\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.CustomersApi()
body =  # Customer |  (optional)

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

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

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

public class CustomersApiExample {

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

import io.swagger.client.api.CustomersApi;

public class CustomersApiExample {

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

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

[apiInstance apiV1CustomersPutWithCompletionHandler: 
              ^(Customer output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new CustomersApi();

            try
            {
                Customer result = apiInstance.apiV1CustomersPut();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CustomersApi.apiV1CustomersPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCustomersApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1CustomersPut();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CustomersApi->apiV1CustomersPut: $@\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.CustomersApi()

try: 
    api_response = api_instance.api_v1_customers_put()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CustomersApi->apiV1CustomersPut: %s\n" % e)

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

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

public class CustomersApiExample {

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

import io.swagger.client.api.CustomersApi;

public class CustomersApiExample {

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

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

[apiInstance apiV1CustomersSearchGetWithCompletionHandler: 
              ^(CustomerPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new CustomersApi();

            try
            {
                CustomerPagingList result = apiInstance.apiV1CustomersSearchGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CustomersApi.apiV1CustomersSearchGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCustomersApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1CustomersSearchGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CustomersApi->apiV1CustomersSearchGet: $@\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.CustomersApi()

try: 
    api_response = api_instance.api_v1_customers_search_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CustomersApi->apiV1CustomersSearchGet: %s\n" % e)

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

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

public class EnvironmentApiExample {

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

import io.swagger.client.api.EnvironmentApi;

public class EnvironmentApiExample {

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

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

[apiInstance routesGetWithCompletionHandler: 
              ^(array[StringStringTuple] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new EnvironmentApi();

            try
            {
                array[StringStringTuple] result = apiInstance.routesGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EnvironmentApi.routesGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiEnvironmentApi();

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

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

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

eval { 
    my $result = $api_instance->routesGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EnvironmentApi->routesGet: $@\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.EnvironmentApi()

try: 
    api_response = api_instance.routes_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EnvironmentApi->routesGet: %s\n" % e)

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

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

public class FulfilmentApiExample {

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

import io.swagger.client.api.FulfilmentApi;

public class FulfilmentApiExample {

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

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

[apiInstance apiV1FulfilmentGetWithCompletionHandler: 
              ^(FulfilmentProviderPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new FulfilmentApi();

            try
            {
                FulfilmentProviderPagingList result = apiInstance.apiV1FulfilmentGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FulfilmentApi.apiV1FulfilmentGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFulfilmentApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1FulfilmentGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FulfilmentApi->apiV1FulfilmentGet: $@\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.FulfilmentApi()

try: 
    api_response = api_instance.api_v1_fulfilment_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FulfilmentApi->apiV1FulfilmentGet: %s\n" % e)

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

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

public class FulfilmentApiExample {

    public static void main(String[] args) {
        
        FulfilmentApi apiInstance = new FulfilmentApi();
        Long id = 789; // Long | 
        try {
            apiInstance.apiV1FulfilmentIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling FulfilmentApi#apiV1FulfilmentIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FulfilmentApi;

public class FulfilmentApiExample {

    public static void main(String[] args) {
        FulfilmentApi apiInstance = new FulfilmentApi();
        Long id = 789; // Long | 
        try {
            apiInstance.apiV1FulfilmentIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling FulfilmentApi#apiV1FulfilmentIdDelete");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.FulfilmentApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new FulfilmentApi();
            var id = 789;  // Long | 

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

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

$api_instance = new Swagger\Client\ApiFulfilmentApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::FulfilmentApi->new();
my $id = 789; # Long | 

eval { 
    $api_instance->apiV1FulfilmentIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling FulfilmentApi->apiV1FulfilmentIdDelete: $@\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.FulfilmentApi()
id = 789 # Long | 

try: 
    api_instance.api_v1_fulfilment_id_delete(id)
except ApiException as e:
    print("Exception when calling FulfilmentApi->apiV1FulfilmentIdDelete: %s\n" % e)

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

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

public class FulfilmentApiExample {

    public static void main(String[] args) {
        
        FulfilmentApi apiInstance = new FulfilmentApi();
        Long id = 789; // Long | 
        try {
            FulfilmentProvider result = apiInstance.apiV1FulfilmentIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FulfilmentApi#apiV1FulfilmentIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FulfilmentApi;

public class FulfilmentApiExample {

    public static void main(String[] args) {
        FulfilmentApi apiInstance = new FulfilmentApi();
        Long id = 789; // Long | 
        try {
            FulfilmentProvider result = apiInstance.apiV1FulfilmentIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FulfilmentApi#apiV1FulfilmentIdGet");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.FulfilmentApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new FulfilmentApi();
            var id = 789;  // Long | 

            try
            {
                FulfilmentProvider result = apiInstance.apiV1FulfilmentIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FulfilmentApi.apiV1FulfilmentIdGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFulfilmentApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::FulfilmentApi->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->apiV1FulfilmentIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FulfilmentApi->apiV1FulfilmentIdGet: $@\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.FulfilmentApi()
id = 789 # Long | 

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

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

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

public class FulfilmentApiExample {

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

import io.swagger.client.api.FulfilmentApi;

public class FulfilmentApiExample {

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

FulfilmentProvider *body = ; //  (optional)

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.FulfilmentApi()
var opts = { 
  'body':  // {{FulfilmentProvider}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1FulfilmentPost(opts, callback);

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

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

            var apiInstance = new FulfilmentApi();
            var body = new FulfilmentProvider(); // FulfilmentProvider |  (optional) 

            try
            {
                FulfilmentProvider result = apiInstance.apiV1FulfilmentPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FulfilmentApi.apiV1FulfilmentPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFulfilmentApi();
$body = ; // FulfilmentProvider | 

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

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

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

eval { 
    my $result = $api_instance->apiV1FulfilmentPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FulfilmentApi->apiV1FulfilmentPost: $@\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.FulfilmentApi()
body =  # FulfilmentProvider |  (optional)

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

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

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

public class FulfilmentApiExample {

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

import io.swagger.client.api.FulfilmentApi;

public class FulfilmentApiExample {

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

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

[apiInstance apiV1FulfilmentPutWithCompletionHandler: 
              ^(FulfilmentProvider output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new FulfilmentApi();

            try
            {
                FulfilmentProvider result = apiInstance.apiV1FulfilmentPut();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FulfilmentApi.apiV1FulfilmentPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFulfilmentApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1FulfilmentPut();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FulfilmentApi->apiV1FulfilmentPut: $@\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.FulfilmentApi()

try: 
    api_response = api_instance.api_v1_fulfilment_put()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FulfilmentApi->apiV1FulfilmentPut: %s\n" % e)

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

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

public class FulfilmentApiExample {

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

import io.swagger.client.api.FulfilmentApi;

public class FulfilmentApiExample {

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

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

[apiInstance apiV1FulfilmentSearchGetWithCompletionHandler: 
              ^(FulfilmentProviderPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new FulfilmentApi();

            try
            {
                FulfilmentProviderPagingList result = apiInstance.apiV1FulfilmentSearchGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FulfilmentApi.apiV1FulfilmentSearchGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFulfilmentApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1FulfilmentSearchGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FulfilmentApi->apiV1FulfilmentSearchGet: $@\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.FulfilmentApi()

try: 
    api_response = api_instance.api_v1_fulfilment_search_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FulfilmentApi->apiV1FulfilmentSearchGet: %s\n" % e)

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

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

public class IntegrationsApiExample {

    public static void main(String[] args) {
        
        IntegrationsApi apiInstance = new IntegrationsApi();
        String className = className_example; // String | 
        try {
            IntegrationTokenResult result = apiInstance.apiV1IntegrationsClassNameTokenGet(className);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling IntegrationsApi#apiV1IntegrationsClassNameTokenGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.IntegrationsApi;

public class IntegrationsApiExample {

    public static void main(String[] args) {
        IntegrationsApi apiInstance = new IntegrationsApi();
        String className = className_example; // String | 
        try {
            IntegrationTokenResult result = apiInstance.apiV1IntegrationsClassNameTokenGet(className);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling IntegrationsApi#apiV1IntegrationsClassNameTokenGet");
            e.printStackTrace();
        }
    }
}

String *className = className_example; // 

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

[apiInstance apiV1IntegrationsClassNameTokenGetWith:className
              completionHandler: ^(IntegrationTokenResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.IntegrationsApi()
var className = className_example; // {{String}} 

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

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

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

            var apiInstance = new IntegrationsApi();
            var className = className_example;  // String | 

            try
            {
                IntegrationTokenResult result = apiInstance.apiV1IntegrationsClassNameTokenGet(className);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling IntegrationsApi.apiV1IntegrationsClassNameTokenGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiIntegrationsApi();
$className = className_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::IntegrationsApi->new();
my $className = className_example; # String | 

eval { 
    my $result = $api_instance->apiV1IntegrationsClassNameTokenGet(className => $className);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling IntegrationsApi->apiV1IntegrationsClassNameTokenGet: $@\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.IntegrationsApi()
className = className_example # String | 

try: 
    api_response = api_instance.api_v1_integrations_class_name_token_get(className)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling IntegrationsApi->apiV1IntegrationsClassNameTokenGet: %s\n" % e)

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

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

public class IntegrationsApiExample {

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

import io.swagger.client.api.IntegrationsApi;

public class IntegrationsApiExample {

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

IntegrationTokenRequest *body = ; //  (optional)

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.IntegrationsApi()
var opts = { 
  'body':  // {{IntegrationTokenRequest}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1IntegrationsCreateTokenPost(opts, callback);

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

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

            var apiInstance = new IntegrationsApi();
            var body = new IntegrationTokenRequest(); // IntegrationTokenRequest |  (optional) 

            try
            {
                IntegrationTokenResult result = apiInstance.apiV1IntegrationsCreateTokenPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling IntegrationsApi.apiV1IntegrationsCreateTokenPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiIntegrationsApi();
$body = ; // IntegrationTokenRequest | 

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

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

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

eval { 
    my $result = $api_instance->apiV1IntegrationsCreateTokenPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling IntegrationsApi->apiV1IntegrationsCreateTokenPost: $@\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.IntegrationsApi()
body =  # IntegrationTokenRequest |  (optional)

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

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

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

public class IntegrationsApiExample {

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

import io.swagger.client.api.IntegrationsApi;

public class IntegrationsApiExample {

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

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

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

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new IntegrationsApi();

            try
            {
                apiInstance.apiV1IntegrationsDelete();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling IntegrationsApi.apiV1IntegrationsDelete: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiIntegrationsApi();

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

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

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

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

try: 
    api_instance.api_v1_integrations_delete()
except ApiException as e:
    print("Exception when calling IntegrationsApi->apiV1IntegrationsDelete: %s\n" % e)

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

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

public class IntegrationsApiExample {

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

import io.swagger.client.api.IntegrationsApi;

public class IntegrationsApiExample {

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

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

[apiInstance apiV1IntegrationsGetWithCompletionHandler: 
              ^(IntegrationPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new IntegrationsApi();

            try
            {
                IntegrationPagingList result = apiInstance.apiV1IntegrationsGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling IntegrationsApi.apiV1IntegrationsGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiIntegrationsApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1IntegrationsGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling IntegrationsApi->apiV1IntegrationsGet: $@\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.IntegrationsApi()

try: 
    api_response = api_instance.api_v1_integrations_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling IntegrationsApi->apiV1IntegrationsGet: %s\n" % e)

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

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

public class IntegrationsApiExample {

    public static void main(String[] args) {
        
        IntegrationsApi apiInstance = new IntegrationsApi();
        Long id = 789; // Long | 
        try {
            Integration result = apiInstance.apiV1IntegrationsIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling IntegrationsApi#apiV1IntegrationsIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.IntegrationsApi;

public class IntegrationsApiExample {

    public static void main(String[] args) {
        IntegrationsApi apiInstance = new IntegrationsApi();
        Long id = 789; // Long | 
        try {
            Integration result = apiInstance.apiV1IntegrationsIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling IntegrationsApi#apiV1IntegrationsIdGet");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.IntegrationsApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new IntegrationsApi();
            var id = 789;  // Long | 

            try
            {
                Integration result = apiInstance.apiV1IntegrationsIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling IntegrationsApi.apiV1IntegrationsIdGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiIntegrationsApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::IntegrationsApi->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->apiV1IntegrationsIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling IntegrationsApi->apiV1IntegrationsIdGet: $@\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.IntegrationsApi()
id = 789 # Long | 

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

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

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

public class InventoryApiExample {

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

import io.swagger.client.api.InventoryApi;

public class InventoryApiExample {

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

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

[apiInstance apiV1InventoryGetWithCompletionHandler: 
              ^(InventoryBatchPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new InventoryApi();

            try
            {
                InventoryBatchPagingList result = apiInstance.apiV1InventoryGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling InventoryApi.apiV1InventoryGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiInventoryApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1InventoryGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling InventoryApi->apiV1InventoryGet: $@\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.InventoryApi()

try: 
    api_response = api_instance.api_v1_inventory_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling InventoryApi->apiV1InventoryGet: %s\n" % e)

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

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

public class InventoryApiExample {

    public static void main(String[] args) {
        
        InventoryApi apiInstance = new InventoryApi();
        Long id = 789; // Long | 
        try {
            apiInstance.apiV1InventoryIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling InventoryApi#apiV1InventoryIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.InventoryApi;

public class InventoryApiExample {

    public static void main(String[] args) {
        InventoryApi apiInstance = new InventoryApi();
        Long id = 789; // Long | 
        try {
            apiInstance.apiV1InventoryIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling InventoryApi#apiV1InventoryIdDelete");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.InventoryApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new InventoryApi();
            var id = 789;  // Long | 

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

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

$api_instance = new Swagger\Client\ApiInventoryApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::InventoryApi->new();
my $id = 789; # Long | 

eval { 
    $api_instance->apiV1InventoryIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling InventoryApi->apiV1InventoryIdDelete: $@\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.InventoryApi()
id = 789 # Long | 

try: 
    api_instance.api_v1_inventory_id_delete(id)
except ApiException as e:
    print("Exception when calling InventoryApi->apiV1InventoryIdDelete: %s\n" % e)

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

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

public class InventoryApiExample {

    public static void main(String[] args) {
        
        InventoryApi apiInstance = new InventoryApi();
        Long id = 789; // Long | 
        try {
            InventoryBatch result = apiInstance.apiV1InventoryIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InventoryApi#apiV1InventoryIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.InventoryApi;

public class InventoryApiExample {

    public static void main(String[] args) {
        InventoryApi apiInstance = new InventoryApi();
        Long id = 789; // Long | 
        try {
            InventoryBatch result = apiInstance.apiV1InventoryIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InventoryApi#apiV1InventoryIdGet");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.InventoryApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new InventoryApi();
            var id = 789;  // Long | 

            try
            {
                InventoryBatch result = apiInstance.apiV1InventoryIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling InventoryApi.apiV1InventoryIdGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiInventoryApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::InventoryApi->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->apiV1InventoryIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling InventoryApi->apiV1InventoryIdGet: $@\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.InventoryApi()
id = 789 # Long | 

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

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

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

public class InventoryApiExample {

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

import io.swagger.client.api.InventoryApi;

public class InventoryApiExample {

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

InventoryBatch *body = ; //  (optional)

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

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

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.InventoryApi()
var opts = { 
  'body':  // {{InventoryBatch}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1InventoryPost(opts, callback);

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

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

            var apiInstance = new InventoryApi();
            var body = new InventoryBatch(); // InventoryBatch |  (optional) 

            try
            {
                InventoryBatch result = apiInstance.apiV1InventoryPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling InventoryApi.apiV1InventoryPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiInventoryApi();
$body = ; // InventoryBatch | 

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

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

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

eval { 
    my $result = $api_instance->apiV1InventoryPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling InventoryApi->apiV1InventoryPost: $@\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.InventoryApi()
body =  # InventoryBatch |  (optional)

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

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

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

public class InventoryApiExample {

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

import io.swagger.client.api.InventoryApi;

public class InventoryApiExample {

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

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

[apiInstance apiV1InventoryPutWithCompletionHandler: 
              ^(InventoryBatch output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new InventoryApi();

            try
            {
                InventoryBatch result = apiInstance.apiV1InventoryPut();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling InventoryApi.apiV1InventoryPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiInventoryApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1InventoryPut();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling InventoryApi->apiV1InventoryPut: $@\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.InventoryApi()

try: 
    api_response = api_instance.api_v1_inventory_put()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling InventoryApi->apiV1InventoryPut: %s\n" % e)

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

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

public class InventoryApiExample {

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

import io.swagger.client.api.InventoryApi;

public class InventoryApiExample {

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

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

[apiInstance apiV1InventorySearchGetWithCompletionHandler: 
              ^(InventoryBatchPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new InventoryApi();

            try
            {
                InventoryBatchPagingList result = apiInstance.apiV1InventorySearchGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling InventoryApi.apiV1InventorySearchGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiInventoryApi();

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

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

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

eval { 
    my $result = $api_instance->apiV1InventorySearchGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling InventoryApi->apiV1InventorySearchGet: $@\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.InventoryApi()

try: 
    api_response = api_instance.api_v1_inventory_search_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling InventoryApi->apiV1InventorySearchGet: %s\n" % e)

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

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

public class JobsApiExample {

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

import io.swagger.client.api.JobsApi;

public class JobsApiExample {

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

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

[apiInstance apiV1JobsGetWithCompletionHandler: 
              ^(JobPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

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

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

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

            var apiInstance = new JobsApi();

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

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

$api_instance = new Swagger\Client\ApiJobsApi();

try {
    $result = $api_instance->apiV1JobsGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JobsApi->apiV1JobsGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobsApi;

my $api_instance = WWW::SwaggerClient::JobsApi->new();

eval { 
    my $result = $api_instance->apiV1JobsGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JobsApi->apiV1JobsGet: $@\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.JobsApi()

try: 
    api_response = api_instance.api_v1_jobs_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JobsApi->apiV1JobsGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JobsApi;

import java.io.File;
import java.util.*;

public class JobsApiExample {

    public static void main(String[] args) {
        
        JobsApi apiInstance = new JobsApi();
        Long id = 789; // Long | 
        try {
            Job result = apiInstance.apiV1JobsIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobsApi#apiV1JobsIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JobsApi;

public class JobsApiExample {

    public static void main(String[] args) {
        JobsApi apiInstance = new JobsApi();
        Long id = 789; // Long | 
        try {
            Job result = apiInstance.apiV1JobsIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobsApi#apiV1JobsIdGet");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

JobsApi *apiInstance = [[JobsApi alloc] init];

[apiInstance apiV1JobsIdGetWith:id
              completionHandler: ^(Job output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.JobsApi()
var id = 789; // {{Long}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1JobsIdGet(id, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1JobsIdGetExample
    {
        public void main()
        {

            var apiInstance = new JobsApi();
            var id = 789;  // Long | 

            try
            {
                Job result = apiInstance.apiV1JobsIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobsApi.apiV1JobsIdGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJobsApi();
$id = 789; // Long | 

try {
    $result = $api_instance->apiV1JobsIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JobsApi->apiV1JobsIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobsApi;

my $api_instance = WWW::SwaggerClient::JobsApi->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->apiV1JobsIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JobsApi->apiV1JobsIdGet: $@\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.JobsApi()
id = 789 # Long | 

try: 
    api_response = api_instance.api_v1_jobs_id_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JobsApi->apiV1JobsIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JobsApi;

import java.io.File;
import java.util.*;

public class JobsApiExample {

    public static void main(String[] args) {
        
        JobsApi apiInstance = new JobsApi();
        try {
            JobPagingList result = apiInstance.apiV1JobsSearchGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobsApi#apiV1JobsSearchGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JobsApi;

public class JobsApiExample {

    public static void main(String[] args) {
        JobsApi apiInstance = new JobsApi();
        try {
            JobPagingList result = apiInstance.apiV1JobsSearchGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobsApi#apiV1JobsSearchGet");
            e.printStackTrace();
        }
    }
}

JobsApi *apiInstance = [[JobsApi alloc] init];

[apiInstance apiV1JobsSearchGetWithCompletionHandler: 
              ^(JobPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.JobsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1JobsSearchGet(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1JobsSearchGetExample
    {
        public void main()
        {

            var apiInstance = new JobsApi();

            try
            {
                JobPagingList result = apiInstance.apiV1JobsSearchGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobsApi.apiV1JobsSearchGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJobsApi();

try {
    $result = $api_instance->apiV1JobsSearchGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JobsApi->apiV1JobsSearchGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobsApi;

my $api_instance = WWW::SwaggerClient::JobsApi->new();

eval { 
    my $result = $api_instance->apiV1JobsSearchGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JobsApi->apiV1JobsSearchGet: $@\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.JobsApi()

try: 
    api_response = api_instance.api_v1_jobs_search_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JobsApi->apiV1JobsSearchGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JourneyApi;

import java.io.File;
import java.util.*;

public class JourneyApiExample {

    public static void main(String[] args) {
        
        JourneyApi apiInstance = new JourneyApi();
        Long customerId = 789; // Long | 
        try {
            JourneyPagingList result = apiInstance.apiV1JourneyCustomerCustomerIdGet(customerId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JourneyApi#apiV1JourneyCustomerCustomerIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JourneyApi;

public class JourneyApiExample {

    public static void main(String[] args) {
        JourneyApi apiInstance = new JourneyApi();
        Long customerId = 789; // Long | 
        try {
            JourneyPagingList result = apiInstance.apiV1JourneyCustomerCustomerIdGet(customerId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JourneyApi#apiV1JourneyCustomerCustomerIdGet");
            e.printStackTrace();
        }
    }
}

Long *customerId = 789; // 

JourneyApi *apiInstance = [[JourneyApi alloc] init];

[apiInstance apiV1JourneyCustomerCustomerIdGetWith:customerId
              completionHandler: ^(JourneyPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.JourneyApi()
var customerId = 789; // {{Long}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1JourneyCustomerCustomerIdGet(customerId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1JourneyCustomerCustomerIdGetExample
    {
        public void main()
        {

            var apiInstance = new JourneyApi();
            var customerId = 789;  // Long | 

            try
            {
                JourneyPagingList result = apiInstance.apiV1JourneyCustomerCustomerIdGet(customerId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JourneyApi.apiV1JourneyCustomerCustomerIdGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJourneyApi();
$customerId = 789; // Long | 

try {
    $result = $api_instance->apiV1JourneyCustomerCustomerIdGet($customerId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JourneyApi->apiV1JourneyCustomerCustomerIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JourneyApi;

my $api_instance = WWW::SwaggerClient::JourneyApi->new();
my $customerId = 789; # Long | 

eval { 
    my $result = $api_instance->apiV1JourneyCustomerCustomerIdGet(customerId => $customerId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JourneyApi->apiV1JourneyCustomerCustomerIdGet: $@\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.JourneyApi()
customerId = 789 # Long | 

try: 
    api_response = api_instance.api_v1_journey_customer_customer_id_get(customerId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JourneyApi->apiV1JourneyCustomerCustomerIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JourneyApi;

import java.io.File;
import java.util.*;

public class JourneyApiExample {

    public static void main(String[] args) {
        
        JourneyApi apiInstance = new JourneyApi();
        try {
            JourneyPagingList result = apiInstance.apiV1JourneyGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JourneyApi#apiV1JourneyGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JourneyApi;

public class JourneyApiExample {

    public static void main(String[] args) {
        JourneyApi apiInstance = new JourneyApi();
        try {
            JourneyPagingList result = apiInstance.apiV1JourneyGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JourneyApi#apiV1JourneyGet");
            e.printStackTrace();
        }
    }
}

JourneyApi *apiInstance = [[JourneyApi alloc] init];

[apiInstance apiV1JourneyGetWithCompletionHandler: 
              ^(JourneyPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.JourneyApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1JourneyGet(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1JourneyGetExample
    {
        public void main()
        {

            var apiInstance = new JourneyApi();

            try
            {
                JourneyPagingList result = apiInstance.apiV1JourneyGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JourneyApi.apiV1JourneyGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJourneyApi();

try {
    $result = $api_instance->apiV1JourneyGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JourneyApi->apiV1JourneyGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JourneyApi;

my $api_instance = WWW::SwaggerClient::JourneyApi->new();

eval { 
    my $result = $api_instance->apiV1JourneyGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JourneyApi->apiV1JourneyGet: $@\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.JourneyApi()

try: 
    api_response = api_instance.api_v1_journey_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JourneyApi->apiV1JourneyGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JourneyApi;

import java.io.File;
import java.util.*;

public class JourneyApiExample {

    public static void main(String[] args) {
        
        JourneyApi apiInstance = new JourneyApi();
        Long id = 789; // Long | 
        Long accessCodeId = 789; // Long | 
        try {
            AccessCode result = apiInstance.apiV1JourneyIdAccessCodeAccessCodeIdDelete(id, accessCodeId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JourneyApi#apiV1JourneyIdAccessCodeAccessCodeIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JourneyApi;

public class JourneyApiExample {

    public static void main(String[] args) {
        JourneyApi apiInstance = new JourneyApi();
        Long id = 789; // Long | 
        Long accessCodeId = 789; // Long | 
        try {
            AccessCode result = apiInstance.apiV1JourneyIdAccessCodeAccessCodeIdDelete(id, accessCodeId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JourneyApi#apiV1JourneyIdAccessCodeAccessCodeIdDelete");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 
Long *accessCodeId = 789; // 

JourneyApi *apiInstance = [[JourneyApi alloc] init];

[apiInstance apiV1JourneyIdAccessCodeAccessCodeIdDeleteWith:id
    accessCodeId:accessCodeId
              completionHandler: ^(AccessCode output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.JourneyApi()
var id = 789; // {{Long}} 
var accessCodeId = 789; // {{Long}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1JourneyIdAccessCodeAccessCodeIdDelete(id, accessCodeId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1JourneyIdAccessCodeAccessCodeIdDeleteExample
    {
        public void main()
        {

            var apiInstance = new JourneyApi();
            var id = 789;  // Long | 
            var accessCodeId = 789;  // Long | 

            try
            {
                AccessCode result = apiInstance.apiV1JourneyIdAccessCodeAccessCodeIdDelete(id, accessCodeId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JourneyApi.apiV1JourneyIdAccessCodeAccessCodeIdDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJourneyApi();
$id = 789; // Long | 
$accessCodeId = 789; // Long | 

try {
    $result = $api_instance->apiV1JourneyIdAccessCodeAccessCodeIdDelete($id, $accessCodeId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JourneyApi->apiV1JourneyIdAccessCodeAccessCodeIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JourneyApi;

my $api_instance = WWW::SwaggerClient::JourneyApi->new();
my $id = 789; # Long | 
my $accessCodeId = 789; # Long | 

eval { 
    my $result = $api_instance->apiV1JourneyIdAccessCodeAccessCodeIdDelete(id => $id, accessCodeId => $accessCodeId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JourneyApi->apiV1JourneyIdAccessCodeAccessCodeIdDelete: $@\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.JourneyApi()
id = 789 # Long | 
accessCodeId = 789 # Long | 

try: 
    api_response = api_instance.api_v1_journey_id_access_code_access_code_id_delete(id, accessCodeId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JourneyApi->apiV1JourneyIdAccessCodeAccessCodeIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JourneyApi;

import java.io.File;
import java.util.*;

public class JourneyApiExample {

    public static void main(String[] args) {
        
        JourneyApi apiInstance = new JourneyApi();
        Long id = 789; // Long | 
        AccessCodeConfiguration body = ; // AccessCodeConfiguration | 
        try {
            AccessCode result = apiInstance.apiV1JourneyIdAccessCodePost(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JourneyApi#apiV1JourneyIdAccessCodePost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JourneyApi;

public class JourneyApiExample {

    public static void main(String[] args) {
        JourneyApi apiInstance = new JourneyApi();
        Long id = 789; // Long | 
        AccessCodeConfiguration body = ; // AccessCodeConfiguration | 
        try {
            AccessCode result = apiInstance.apiV1JourneyIdAccessCodePost(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JourneyApi#apiV1JourneyIdAccessCodePost");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 
AccessCodeConfiguration *body = ; //  (optional)

JourneyApi *apiInstance = [[JourneyApi alloc] init];

[apiInstance apiV1JourneyIdAccessCodePostWith:id
    body:body
              completionHandler: ^(AccessCode output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.JourneyApi()
var id = 789; // {{Long}} 
var opts = { 
  'body':  // {{AccessCodeConfiguration}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1JourneyIdAccessCodePost(id, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1JourneyIdAccessCodePostExample
    {
        public void main()
        {

            var apiInstance = new JourneyApi();
            var id = 789;  // Long | 
            var body = new AccessCodeConfiguration(); // AccessCodeConfiguration |  (optional) 

            try
            {
                AccessCode result = apiInstance.apiV1JourneyIdAccessCodePost(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JourneyApi.apiV1JourneyIdAccessCodePost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJourneyApi();
$id = 789; // Long | 
$body = ; // AccessCodeConfiguration | 

try {
    $result = $api_instance->apiV1JourneyIdAccessCodePost($id, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JourneyApi->apiV1JourneyIdAccessCodePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JourneyApi;

my $api_instance = WWW::SwaggerClient::JourneyApi->new();
my $id = 789; # Long | 
my $body = WWW::SwaggerClient::Object::AccessCodeConfiguration->new(); # AccessCodeConfiguration | 

eval { 
    my $result = $api_instance->apiV1JourneyIdAccessCodePost(id => $id, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JourneyApi->apiV1JourneyIdAccessCodePost: $@\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.JourneyApi()
id = 789 # Long | 
body =  # AccessCodeConfiguration |  (optional)

try: 
    api_response = api_instance.api_v1_journey_id_access_code_post(id, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JourneyApi->apiV1JourneyIdAccessCodePost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JourneyApi;

import java.io.File;
import java.util.*;

public class JourneyApiExample {

    public static void main(String[] args) {
        
        JourneyApi apiInstance = new JourneyApi();
        Long id = 789; // Long | 
        try {
            apiInstance.apiV1JourneyIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling JourneyApi#apiV1JourneyIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JourneyApi;

public class JourneyApiExample {

    public static void main(String[] args) {
        JourneyApi apiInstance = new JourneyApi();
        Long id = 789; // Long | 
        try {
            apiInstance.apiV1JourneyIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling JourneyApi#apiV1JourneyIdDelete");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

JourneyApi *apiInstance = [[JourneyApi alloc] init];

[apiInstance apiV1JourneyIdDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.JourneyApi()
var id = 789; // {{Long}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiV1JourneyIdDelete(id, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1JourneyIdDeleteExample
    {
        public void main()
        {

            var apiInstance = new JourneyApi();
            var id = 789;  // Long | 

            try
            {
                apiInstance.apiV1JourneyIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JourneyApi.apiV1JourneyIdDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJourneyApi();
$id = 789; // Long | 

try {
    $api_instance->apiV1JourneyIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling JourneyApi->apiV1JourneyIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JourneyApi;

my $api_instance = WWW::SwaggerClient::JourneyApi->new();
my $id = 789; # Long | 

eval { 
    $api_instance->apiV1JourneyIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling JourneyApi->apiV1JourneyIdDelete: $@\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.JourneyApi()
id = 789 # Long | 

try: 
    api_instance.api_v1_journey_id_delete(id)
except ApiException as e:
    print("Exception when calling JourneyApi->apiV1JourneyIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JourneyApi;

import java.io.File;
import java.util.*;

public class JourneyApiExample {

    public static void main(String[] args) {
        
        JourneyApi apiInstance = new JourneyApi();
        Long id = 789; // Long | 
        try {
            Journey result = apiInstance.apiV1JourneyIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JourneyApi#apiV1JourneyIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JourneyApi;

public class JourneyApiExample {

    public static void main(String[] args) {
        JourneyApi apiInstance = new JourneyApi();
        Long id = 789; // Long | 
        try {
            Journey result = apiInstance.apiV1JourneyIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JourneyApi#apiV1JourneyIdGet");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

JourneyApi *apiInstance = [[JourneyApi alloc] init];

[apiInstance apiV1JourneyIdGetWith:id
              completionHandler: ^(Journey output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.JourneyApi()
var id = 789; // {{Long}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1JourneyIdGet(id, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1JourneyIdGetExample
    {
        public void main()
        {

            var apiInstance = new JourneyApi();
            var id = 789;  // Long | 

            try
            {
                Journey result = apiInstance.apiV1JourneyIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JourneyApi.apiV1JourneyIdGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJourneyApi();
$id = 789; // Long | 

try {
    $result = $api_instance->apiV1JourneyIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JourneyApi->apiV1JourneyIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JourneyApi;

my $api_instance = WWW::SwaggerClient::JourneyApi->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->apiV1JourneyIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JourneyApi->apiV1JourneyIdGet: $@\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.JourneyApi()
id = 789 # Long | 

try: 
    api_response = api_instance.api_v1_journey_id_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JourneyApi->apiV1JourneyIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JourneyApi;

import java.io.File;
import java.util.*;

public class JourneyApiExample {

    public static void main(String[] args) {
        
        JourneyApi apiInstance = new JourneyApi();
        Journey body = ; // Journey | 
        try {
            Journey result = apiInstance.apiV1JourneyPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JourneyApi#apiV1JourneyPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JourneyApi;

public class JourneyApiExample {

    public static void main(String[] args) {
        JourneyApi apiInstance = new JourneyApi();
        Journey body = ; // Journey | 
        try {
            Journey result = apiInstance.apiV1JourneyPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JourneyApi#apiV1JourneyPost");
            e.printStackTrace();
        }
    }
}

Journey *body = ; //  (optional)

JourneyApi *apiInstance = [[JourneyApi alloc] init];

[apiInstance apiV1JourneyPostWith:body
              completionHandler: ^(Journey output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.JourneyApi()
var opts = { 
  'body':  // {{Journey}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1JourneyPost(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1JourneyPostExample
    {
        public void main()
        {

            var apiInstance = new JourneyApi();
            var body = new Journey(); // Journey |  (optional) 

            try
            {
                Journey result = apiInstance.apiV1JourneyPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JourneyApi.apiV1JourneyPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJourneyApi();
$body = ; // Journey | 

try {
    $result = $api_instance->apiV1JourneyPost($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JourneyApi->apiV1JourneyPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JourneyApi;

my $api_instance = WWW::SwaggerClient::JourneyApi->new();
my $body = WWW::SwaggerClient::Object::Journey->new(); # Journey | 

eval { 
    my $result = $api_instance->apiV1JourneyPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JourneyApi->apiV1JourneyPost: $@\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.JourneyApi()
body =  # Journey |  (optional)

try: 
    api_response = api_instance.api_v1_journey_post(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JourneyApi->apiV1JourneyPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JourneyApi;

import java.io.File;
import java.util.*;

public class JourneyApiExample {

    public static void main(String[] args) {
        
        JourneyApi apiInstance = new JourneyApi();
        try {
            Journey result = apiInstance.apiV1JourneyPut();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JourneyApi#apiV1JourneyPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JourneyApi;

public class JourneyApiExample {

    public static void main(String[] args) {
        JourneyApi apiInstance = new JourneyApi();
        try {
            Journey result = apiInstance.apiV1JourneyPut();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JourneyApi#apiV1JourneyPut");
            e.printStackTrace();
        }
    }
}

JourneyApi *apiInstance = [[JourneyApi alloc] init];

[apiInstance apiV1JourneyPutWithCompletionHandler: 
              ^(Journey output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.JourneyApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1JourneyPut(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1JourneyPutExample
    {
        public void main()
        {

            var apiInstance = new JourneyApi();

            try
            {
                Journey result = apiInstance.apiV1JourneyPut();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JourneyApi.apiV1JourneyPut: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJourneyApi();

try {
    $result = $api_instance->apiV1JourneyPut();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JourneyApi->apiV1JourneyPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JourneyApi;

my $api_instance = WWW::SwaggerClient::JourneyApi->new();

eval { 
    my $result = $api_instance->apiV1JourneyPut();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JourneyApi->apiV1JourneyPut: $@\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.JourneyApi()

try: 
    api_response = api_instance.api_v1_journey_put()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JourneyApi->apiV1JourneyPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JourneyApi;

import java.io.File;
import java.util.*;

public class JourneyApiExample {

    public static void main(String[] args) {
        
        JourneyApi apiInstance = new JourneyApi();
        try {
            JourneyPagingList result = apiInstance.apiV1JourneySearchGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JourneyApi#apiV1JourneySearchGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JourneyApi;

public class JourneyApiExample {

    public static void main(String[] args) {
        JourneyApi apiInstance = new JourneyApi();
        try {
            JourneyPagingList result = apiInstance.apiV1JourneySearchGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JourneyApi#apiV1JourneySearchGet");
            e.printStackTrace();
        }
    }
}

JourneyApi *apiInstance = [[JourneyApi alloc] init];

[apiInstance apiV1JourneySearchGetWithCompletionHandler: 
              ^(JourneyPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.JourneyApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1JourneySearchGet(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1JourneySearchGetExample
    {
        public void main()
        {

            var apiInstance = new JourneyApi();

            try
            {
                JourneyPagingList result = apiInstance.apiV1JourneySearchGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JourneyApi.apiV1JourneySearchGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJourneyApi();

try {
    $result = $api_instance->apiV1JourneySearchGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JourneyApi->apiV1JourneySearchGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JourneyApi;

my $api_instance = WWW::SwaggerClient::JourneyApi->new();

eval { 
    my $result = $api_instance->apiV1JourneySearchGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JourneyApi->apiV1JourneySearchGet: $@\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.JourneyApi()

try: 
    api_response = api_instance.api_v1_journey_search_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JourneyApi->apiV1JourneySearchGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JourneyApi;

import java.io.File;
import java.util.*;

public class JourneyApiExample {

    public static void main(String[] args) {
        
        JourneyApi apiInstance = new JourneyApi();
        AccessCodeEntry body = ; // AccessCodeEntry | 
        try {
            Journey result = apiInstance.apiV1JourneyStartPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JourneyApi#apiV1JourneyStartPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JourneyApi;

public class JourneyApiExample {

    public static void main(String[] args) {
        JourneyApi apiInstance = new JourneyApi();
        AccessCodeEntry body = ; // AccessCodeEntry | 
        try {
            Journey result = apiInstance.apiV1JourneyStartPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JourneyApi#apiV1JourneyStartPost");
            e.printStackTrace();
        }
    }
}

AccessCodeEntry *body = ; //  (optional)

JourneyApi *apiInstance = [[JourneyApi alloc] init];

[apiInstance apiV1JourneyStartPostWith:body
              completionHandler: ^(Journey output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.JourneyApi()
var opts = { 
  'body':  // {{AccessCodeEntry}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1JourneyStartPost(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1JourneyStartPostExample
    {
        public void main()
        {

            var apiInstance = new JourneyApi();
            var body = new AccessCodeEntry(); // AccessCodeEntry |  (optional) 

            try
            {
                Journey result = apiInstance.apiV1JourneyStartPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JourneyApi.apiV1JourneyStartPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJourneyApi();
$body = ; // AccessCodeEntry | 

try {
    $result = $api_instance->apiV1JourneyStartPost($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JourneyApi->apiV1JourneyStartPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JourneyApi;

my $api_instance = WWW::SwaggerClient::JourneyApi->new();
my $body = WWW::SwaggerClient::Object::AccessCodeEntry->new(); # AccessCodeEntry | 

eval { 
    my $result = $api_instance->apiV1JourneyStartPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JourneyApi->apiV1JourneyStartPost: $@\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.JourneyApi()
body =  # AccessCodeEntry |  (optional)

try: 
    api_response = api_instance.api_v1_journey_start_post(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JourneyApi->apiV1JourneyStartPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NotificationApi;

import java.io.File;
import java.util.*;

public class NotificationApiExample {

    public static void main(String[] args) {
        
        NotificationApi apiInstance = new NotificationApi();
        try {
            NotificationPagingList result = apiInstance.apiV1NotificationsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationApi#apiV1NotificationsGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.NotificationApi;

public class NotificationApiExample {

    public static void main(String[] args) {
        NotificationApi apiInstance = new NotificationApi();
        try {
            NotificationPagingList result = apiInstance.apiV1NotificationsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationApi#apiV1NotificationsGet");
            e.printStackTrace();
        }
    }
}

NotificationApi *apiInstance = [[NotificationApi alloc] init];

[apiInstance apiV1NotificationsGetWithCompletionHandler: 
              ^(NotificationPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.NotificationApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1NotificationsGet(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1NotificationsGetExample
    {
        public void main()
        {

            var apiInstance = new NotificationApi();

            try
            {
                NotificationPagingList result = apiInstance.apiV1NotificationsGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NotificationApi.apiV1NotificationsGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiNotificationApi();

try {
    $result = $api_instance->apiV1NotificationsGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling NotificationApi->apiV1NotificationsGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NotificationApi;

my $api_instance = WWW::SwaggerClient::NotificationApi->new();

eval { 
    my $result = $api_instance->apiV1NotificationsGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling NotificationApi->apiV1NotificationsGet: $@\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.NotificationApi()

try: 
    api_response = api_instance.api_v1_notifications_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NotificationApi->apiV1NotificationsGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NotificationApi;

import java.io.File;
import java.util.*;

public class NotificationApiExample {

    public static void main(String[] args) {
        
        NotificationApi apiInstance = new NotificationApi();
        Long id = 789; // Long | 
        try {
            Notification result = apiInstance.apiV1NotificationsIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationApi#apiV1NotificationsIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.NotificationApi;

public class NotificationApiExample {

    public static void main(String[] args) {
        NotificationApi apiInstance = new NotificationApi();
        Long id = 789; // Long | 
        try {
            Notification result = apiInstance.apiV1NotificationsIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationApi#apiV1NotificationsIdGet");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

NotificationApi *apiInstance = [[NotificationApi alloc] init];

[apiInstance apiV1NotificationsIdGetWith:id
              completionHandler: ^(Notification output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.NotificationApi()
var id = 789; // {{Long}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1NotificationsIdGet(id, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1NotificationsIdGetExample
    {
        public void main()
        {

            var apiInstance = new NotificationApi();
            var id = 789;  // Long | 

            try
            {
                Notification result = apiInstance.apiV1NotificationsIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NotificationApi.apiV1NotificationsIdGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiNotificationApi();
$id = 789; // Long | 

try {
    $result = $api_instance->apiV1NotificationsIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling NotificationApi->apiV1NotificationsIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NotificationApi;

my $api_instance = WWW::SwaggerClient::NotificationApi->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->apiV1NotificationsIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling NotificationApi->apiV1NotificationsIdGet: $@\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.NotificationApi()
id = 789 # Long | 

try: 
    api_response = api_instance.api_v1_notifications_id_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NotificationApi->apiV1NotificationsIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NotificationApi;

import java.io.File;
import java.util.*;

public class NotificationApiExample {

    public static void main(String[] args) {
        
        NotificationApi apiInstance = new NotificationApi();
        try {
            NotificationPagingList result = apiInstance.apiV1NotificationsSearchGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationApi#apiV1NotificationsSearchGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.NotificationApi;

public class NotificationApiExample {

    public static void main(String[] args) {
        NotificationApi apiInstance = new NotificationApi();
        try {
            NotificationPagingList result = apiInstance.apiV1NotificationsSearchGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationApi#apiV1NotificationsSearchGet");
            e.printStackTrace();
        }
    }
}

NotificationApi *apiInstance = [[NotificationApi alloc] init];

[apiInstance apiV1NotificationsSearchGetWithCompletionHandler: 
              ^(NotificationPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.NotificationApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1NotificationsSearchGet(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1NotificationsSearchGetExample
    {
        public void main()
        {

            var apiInstance = new NotificationApi();

            try
            {
                NotificationPagingList result = apiInstance.apiV1NotificationsSearchGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NotificationApi.apiV1NotificationsSearchGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiNotificationApi();

try {
    $result = $api_instance->apiV1NotificationsSearchGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling NotificationApi->apiV1NotificationsSearchGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NotificationApi;

my $api_instance = WWW::SwaggerClient::NotificationApi->new();

eval { 
    my $result = $api_instance->apiV1NotificationsSearchGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling NotificationApi->apiV1NotificationsSearchGet: $@\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.NotificationApi()

try: 
    api_response = api_instance.api_v1_notifications_search_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NotificationApi->apiV1NotificationsSearchGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrderApi;

import java.io.File;
import java.util.*;

public class OrderApiExample {

    public static void main(String[] args) {
        
        OrderApi apiInstance = new OrderApi();
        try {
            apiInstance.apiV1OrdersDispatchPost();
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderApi#apiV1OrdersDispatchPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OrderApi;

public class OrderApiExample {

    public static void main(String[] args) {
        OrderApi apiInstance = new OrderApi();
        try {
            apiInstance.apiV1OrdersDispatchPost();
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderApi#apiV1OrdersDispatchPost");
            e.printStackTrace();
        }
    }
}

OrderApi *apiInstance = [[OrderApi alloc] init];

[apiInstance apiV1OrdersDispatchPostWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.OrderApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiV1OrdersDispatchPost(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1OrdersDispatchPostExample
    {
        public void main()
        {

            var apiInstance = new OrderApi();

            try
            {
                apiInstance.apiV1OrdersDispatchPost();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrderApi.apiV1OrdersDispatchPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiOrderApi();

try {
    $api_instance->apiV1OrdersDispatchPost();
} catch (Exception $e) {
    echo 'Exception when calling OrderApi->apiV1OrdersDispatchPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OrderApi;

my $api_instance = WWW::SwaggerClient::OrderApi->new();

eval { 
    $api_instance->apiV1OrdersDispatchPost();
};
if ($@) {
    warn "Exception when calling OrderApi->apiV1OrdersDispatchPost: $@\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.OrderApi()

try: 
    api_instance.api_v1_orders_dispatch_post()
except ApiException as e:
    print("Exception when calling OrderApi->apiV1OrdersDispatchPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrderApi;

import java.io.File;
import java.util.*;

public class OrderApiExample {

    public static void main(String[] args) {
        
        OrderApi apiInstance = new OrderApi();
        try {
            OrderPagingList result = apiInstance.apiV1OrdersGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderApi#apiV1OrdersGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OrderApi;

public class OrderApiExample {

    public static void main(String[] args) {
        OrderApi apiInstance = new OrderApi();
        try {
            OrderPagingList result = apiInstance.apiV1OrdersGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderApi#apiV1OrdersGet");
            e.printStackTrace();
        }
    }
}

OrderApi *apiInstance = [[OrderApi alloc] init];

[apiInstance apiV1OrdersGetWithCompletionHandler: 
              ^(OrderPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.OrderApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1OrdersGet(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1OrdersGetExample
    {
        public void main()
        {

            var apiInstance = new OrderApi();

            try
            {
                OrderPagingList result = apiInstance.apiV1OrdersGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrderApi.apiV1OrdersGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiOrderApi();

try {
    $result = $api_instance->apiV1OrdersGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OrderApi->apiV1OrdersGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OrderApi;

my $api_instance = WWW::SwaggerClient::OrderApi->new();

eval { 
    my $result = $api_instance->apiV1OrdersGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OrderApi->apiV1OrdersGet: $@\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.OrderApi()

try: 
    api_response = api_instance.api_v1_orders_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrderApi->apiV1OrdersGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrderApi;

import java.io.File;
import java.util.*;

public class OrderApiExample {

    public static void main(String[] args) {
        
        OrderApi apiInstance = new OrderApi();
        Long id = 789; // Long | 
        try {
            apiInstance.apiV1OrdersIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderApi#apiV1OrdersIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OrderApi;

public class OrderApiExample {

    public static void main(String[] args) {
        OrderApi apiInstance = new OrderApi();
        Long id = 789; // Long | 
        try {
            apiInstance.apiV1OrdersIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderApi#apiV1OrdersIdDelete");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

OrderApi *apiInstance = [[OrderApi alloc] init];

[apiInstance apiV1OrdersIdDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.OrderApi()
var id = 789; // {{Long}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiV1OrdersIdDelete(id, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1OrdersIdDeleteExample
    {
        public void main()
        {

            var apiInstance = new OrderApi();
            var id = 789;  // Long | 

            try
            {
                apiInstance.apiV1OrdersIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrderApi.apiV1OrdersIdDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiOrderApi();
$id = 789; // Long | 

try {
    $api_instance->apiV1OrdersIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling OrderApi->apiV1OrdersIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OrderApi;

my $api_instance = WWW::SwaggerClient::OrderApi->new();
my $id = 789; # Long | 

eval { 
    $api_instance->apiV1OrdersIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling OrderApi->apiV1OrdersIdDelete: $@\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.OrderApi()
id = 789 # Long | 

try: 
    api_instance.api_v1_orders_id_delete(id)
except ApiException as e:
    print("Exception when calling OrderApi->apiV1OrdersIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrderApi;

import java.io.File;
import java.util.*;

public class OrderApiExample {

    public static void main(String[] args) {
        
        OrderApi apiInstance = new OrderApi();
        Long id = 789; // Long | 
        try {
            Order result = apiInstance.apiV1OrdersIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderApi#apiV1OrdersIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OrderApi;

public class OrderApiExample {

    public static void main(String[] args) {
        OrderApi apiInstance = new OrderApi();
        Long id = 789; // Long | 
        try {
            Order result = apiInstance.apiV1OrdersIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderApi#apiV1OrdersIdGet");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

OrderApi *apiInstance = [[OrderApi alloc] init];

[apiInstance apiV1OrdersIdGetWith:id
              completionHandler: ^(Order output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.OrderApi()
var id = 789; // {{Long}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1OrdersIdGet(id, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1OrdersIdGetExample
    {
        public void main()
        {

            var apiInstance = new OrderApi();
            var id = 789;  // Long | 

            try
            {
                Order result = apiInstance.apiV1OrdersIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrderApi.apiV1OrdersIdGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiOrderApi();
$id = 789; // Long | 

try {
    $result = $api_instance->apiV1OrdersIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OrderApi->apiV1OrdersIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OrderApi;

my $api_instance = WWW::SwaggerClient::OrderApi->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->apiV1OrdersIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OrderApi->apiV1OrdersIdGet: $@\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.OrderApi()
id = 789 # Long | 

try: 
    api_response = api_instance.api_v1_orders_id_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrderApi->apiV1OrdersIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrderApi;

import java.io.File;
import java.util.*;

public class OrderApiExample {

    public static void main(String[] args) {
        
        OrderApi apiInstance = new OrderApi();
        Long orderId = 789; // Long | 
        try {
            apiInstance.apiV1OrdersOrderIdReservePost(orderId);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderApi#apiV1OrdersOrderIdReservePost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OrderApi;

public class OrderApiExample {

    public static void main(String[] args) {
        OrderApi apiInstance = new OrderApi();
        Long orderId = 789; // Long | 
        try {
            apiInstance.apiV1OrdersOrderIdReservePost(orderId);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderApi#apiV1OrdersOrderIdReservePost");
            e.printStackTrace();
        }
    }
}

Long *orderId = 789; // 

OrderApi *apiInstance = [[OrderApi alloc] init];

[apiInstance apiV1OrdersOrderIdReservePostWith:orderId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.OrderApi()
var orderId = 789; // {{Long}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiV1OrdersOrderIdReservePost(orderId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1OrdersOrderIdReservePostExample
    {
        public void main()
        {

            var apiInstance = new OrderApi();
            var orderId = 789;  // Long | 

            try
            {
                apiInstance.apiV1OrdersOrderIdReservePost(orderId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrderApi.apiV1OrdersOrderIdReservePost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiOrderApi();
$orderId = 789; // Long | 

try {
    $api_instance->apiV1OrdersOrderIdReservePost($orderId);
} catch (Exception $e) {
    echo 'Exception when calling OrderApi->apiV1OrdersOrderIdReservePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OrderApi;

my $api_instance = WWW::SwaggerClient::OrderApi->new();
my $orderId = 789; # Long | 

eval { 
    $api_instance->apiV1OrdersOrderIdReservePost(orderId => $orderId);
};
if ($@) {
    warn "Exception when calling OrderApi->apiV1OrdersOrderIdReservePost: $@\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.OrderApi()
orderId = 789 # Long | 

try: 
    api_instance.api_v1_orders_order_id_reserve_post(orderId)
except ApiException as e:
    print("Exception when calling OrderApi->apiV1OrdersOrderIdReservePost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrderApi;

import java.io.File;
import java.util.*;

public class OrderApiExample {

    public static void main(String[] args) {
        
        OrderApi apiInstance = new OrderApi();
        Long orderItemId = 789; // Long | 
        try {
            apiInstance.apiV1OrdersOrderItemIdReserveDelete(orderItemId);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderApi#apiV1OrdersOrderItemIdReserveDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OrderApi;

public class OrderApiExample {

    public static void main(String[] args) {
        OrderApi apiInstance = new OrderApi();
        Long orderItemId = 789; // Long | 
        try {
            apiInstance.apiV1OrdersOrderItemIdReserveDelete(orderItemId);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderApi#apiV1OrdersOrderItemIdReserveDelete");
            e.printStackTrace();
        }
    }
}

Long *orderItemId = 789; // 

OrderApi *apiInstance = [[OrderApi alloc] init];

[apiInstance apiV1OrdersOrderItemIdReserveDeleteWith:orderItemId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.OrderApi()
var orderItemId = 789; // {{Long}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiV1OrdersOrderItemIdReserveDelete(orderItemId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1OrdersOrderItemIdReserveDeleteExample
    {
        public void main()
        {

            var apiInstance = new OrderApi();
            var orderItemId = 789;  // Long | 

            try
            {
                apiInstance.apiV1OrdersOrderItemIdReserveDelete(orderItemId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrderApi.apiV1OrdersOrderItemIdReserveDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiOrderApi();
$orderItemId = 789; // Long | 

try {
    $api_instance->apiV1OrdersOrderItemIdReserveDelete($orderItemId);
} catch (Exception $e) {
    echo 'Exception when calling OrderApi->apiV1OrdersOrderItemIdReserveDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OrderApi;

my $api_instance = WWW::SwaggerClient::OrderApi->new();
my $orderItemId = 789; # Long | 

eval { 
    $api_instance->apiV1OrdersOrderItemIdReserveDelete(orderItemId => $orderItemId);
};
if ($@) {
    warn "Exception when calling OrderApi->apiV1OrdersOrderItemIdReserveDelete: $@\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.OrderApi()
orderItemId = 789 # Long | 

try: 
    api_instance.api_v1_orders_order_item_id_reserve_delete(orderItemId)
except ApiException as e:
    print("Exception when calling OrderApi->apiV1OrdersOrderItemIdReserveDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrderApi;

import java.io.File;
import java.util.*;

public class OrderApiExample {

    public static void main(String[] args) {
        
        OrderApi apiInstance = new OrderApi();
        Order body = ; // Order | 
        try {
            Order result = apiInstance.apiV1OrdersPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderApi#apiV1OrdersPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OrderApi;

public class OrderApiExample {

    public static void main(String[] args) {
        OrderApi apiInstance = new OrderApi();
        Order body = ; // Order | 
        try {
            Order result = apiInstance.apiV1OrdersPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderApi#apiV1OrdersPost");
            e.printStackTrace();
        }
    }
}

Order *body = ; //  (optional)

OrderApi *apiInstance = [[OrderApi alloc] init];

[apiInstance apiV1OrdersPostWith:body
              completionHandler: ^(Order output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.OrderApi()
var opts = { 
  'body':  // {{Order}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1OrdersPost(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1OrdersPostExample
    {
        public void main()
        {

            var apiInstance = new OrderApi();
            var body = new Order(); // Order |  (optional) 

            try
            {
                Order result = apiInstance.apiV1OrdersPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrderApi.apiV1OrdersPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiOrderApi();
$body = ; // Order | 

try {
    $result = $api_instance->apiV1OrdersPost($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OrderApi->apiV1OrdersPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OrderApi;

my $api_instance = WWW::SwaggerClient::OrderApi->new();
my $body = WWW::SwaggerClient::Object::Order->new(); # Order | 

eval { 
    my $result = $api_instance->apiV1OrdersPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OrderApi->apiV1OrdersPost: $@\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.OrderApi()
body =  # Order |  (optional)

try: 
    api_response = api_instance.api_v1_orders_post(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrderApi->apiV1OrdersPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrderApi;

import java.io.File;
import java.util.*;

public class OrderApiExample {

    public static void main(String[] args) {
        
        OrderApi apiInstance = new OrderApi();
        try {
            Order result = apiInstance.apiV1OrdersPut();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderApi#apiV1OrdersPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OrderApi;

public class OrderApiExample {

    public static void main(String[] args) {
        OrderApi apiInstance = new OrderApi();
        try {
            Order result = apiInstance.apiV1OrdersPut();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderApi#apiV1OrdersPut");
            e.printStackTrace();
        }
    }
}

OrderApi *apiInstance = [[OrderApi alloc] init];

[apiInstance apiV1OrdersPutWithCompletionHandler: 
              ^(Order output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.OrderApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1OrdersPut(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1OrdersPutExample
    {
        public void main()
        {

            var apiInstance = new OrderApi();

            try
            {
                Order result = apiInstance.apiV1OrdersPut();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrderApi.apiV1OrdersPut: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiOrderApi();

try {
    $result = $api_instance->apiV1OrdersPut();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OrderApi->apiV1OrdersPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OrderApi;

my $api_instance = WWW::SwaggerClient::OrderApi->new();

eval { 
    my $result = $api_instance->apiV1OrdersPut();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OrderApi->apiV1OrdersPut: $@\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.OrderApi()

try: 
    api_response = api_instance.api_v1_orders_put()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrderApi->apiV1OrdersPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrderApi;

import java.io.File;
import java.util.*;

public class OrderApiExample {

    public static void main(String[] args) {
        
        OrderApi apiInstance = new OrderApi();
        try {
            OrderPagingList result = apiInstance.apiV1OrdersSearchGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderApi#apiV1OrdersSearchGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OrderApi;

public class OrderApiExample {

    public static void main(String[] args) {
        OrderApi apiInstance = new OrderApi();
        try {
            OrderPagingList result = apiInstance.apiV1OrdersSearchGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderApi#apiV1OrdersSearchGet");
            e.printStackTrace();
        }
    }
}

OrderApi *apiInstance = [[OrderApi alloc] init];

[apiInstance apiV1OrdersSearchGetWithCompletionHandler: 
              ^(OrderPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.OrderApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1OrdersSearchGet(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1OrdersSearchGetExample
    {
        public void main()
        {

            var apiInstance = new OrderApi();

            try
            {
                OrderPagingList result = apiInstance.apiV1OrdersSearchGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrderApi.apiV1OrdersSearchGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiOrderApi();

try {
    $result = $api_instance->apiV1OrdersSearchGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OrderApi->apiV1OrdersSearchGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OrderApi;

my $api_instance = WWW::SwaggerClient::OrderApi->new();

eval { 
    my $result = $api_instance->apiV1OrdersSearchGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OrderApi->apiV1OrdersSearchGet: $@\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.OrderApi()

try: 
    api_response = api_instance.api_v1_orders_search_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrderApi->apiV1OrdersSearchGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrderApi;

import java.io.File;
import java.util.*;

public class OrderApiExample {

    public static void main(String[] args) {
        
        OrderApi apiInstance = new OrderApi();
        SessionUpdate body = ; // SessionUpdate | 
        try {
            apiInstance.apiV1OrdersSessionPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderApi#apiV1OrdersSessionPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OrderApi;

public class OrderApiExample {

    public static void main(String[] args) {
        OrderApi apiInstance = new OrderApi();
        SessionUpdate body = ; // SessionUpdate | 
        try {
            apiInstance.apiV1OrdersSessionPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderApi#apiV1OrdersSessionPost");
            e.printStackTrace();
        }
    }
}

SessionUpdate *body = ; //  (optional)

OrderApi *apiInstance = [[OrderApi alloc] init];

[apiInstance apiV1OrdersSessionPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.OrderApi()
var opts = { 
  'body':  // {{SessionUpdate}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiV1OrdersSessionPost(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1OrdersSessionPostExample
    {
        public void main()
        {

            var apiInstance = new OrderApi();
            var body = new SessionUpdate(); // SessionUpdate |  (optional) 

            try
            {
                apiInstance.apiV1OrdersSessionPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrderApi.apiV1OrdersSessionPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiOrderApi();
$body = ; // SessionUpdate | 

try {
    $api_instance->apiV1OrdersSessionPost($body);
} catch (Exception $e) {
    echo 'Exception when calling OrderApi->apiV1OrdersSessionPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OrderApi;

my $api_instance = WWW::SwaggerClient::OrderApi->new();
my $body = WWW::SwaggerClient::Object::SessionUpdate->new(); # SessionUpdate | 

eval { 
    $api_instance->apiV1OrdersSessionPost(body => $body);
};
if ($@) {
    warn "Exception when calling OrderApi->apiV1OrdersSessionPost: $@\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.OrderApi()
body =  # SessionUpdate |  (optional)

try: 
    api_instance.api_v1_orders_session_post(body=body)
except ApiException as e:
    print("Exception when calling OrderApi->apiV1OrdersSessionPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrderApi;

import java.io.File;
import java.util.*;

public class OrderApiExample {

    public static void main(String[] args) {
        
        OrderApi apiInstance = new OrderApi();
        Long orderId = 789; // Long | 
        try {
            Order result = apiInstance.apiV1OrdersVerifyOrderIdGet(orderId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderApi#apiV1OrdersVerifyOrderIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OrderApi;

public class OrderApiExample {

    public static void main(String[] args) {
        OrderApi apiInstance = new OrderApi();
        Long orderId = 789; // Long | 
        try {
            Order result = apiInstance.apiV1OrdersVerifyOrderIdGet(orderId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderApi#apiV1OrdersVerifyOrderIdGet");
            e.printStackTrace();
        }
    }
}

Long *orderId = 789; // 

OrderApi *apiInstance = [[OrderApi alloc] init];

[apiInstance apiV1OrdersVerifyOrderIdGetWith:orderId
              completionHandler: ^(Order output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.OrderApi()
var orderId = 789; // {{Long}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1OrdersVerifyOrderIdGet(orderId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1OrdersVerifyOrderIdGetExample
    {
        public void main()
        {

            var apiInstance = new OrderApi();
            var orderId = 789;  // Long | 

            try
            {
                Order result = apiInstance.apiV1OrdersVerifyOrderIdGet(orderId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrderApi.apiV1OrdersVerifyOrderIdGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiOrderApi();
$orderId = 789; // Long | 

try {
    $result = $api_instance->apiV1OrdersVerifyOrderIdGet($orderId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OrderApi->apiV1OrdersVerifyOrderIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OrderApi;

my $api_instance = WWW::SwaggerClient::OrderApi->new();
my $orderId = 789; # Long | 

eval { 
    my $result = $api_instance->apiV1OrdersVerifyOrderIdGet(orderId => $orderId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OrderApi->apiV1OrdersVerifyOrderIdGet: $@\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.OrderApi()
orderId = 789 # Long | 

try: 
    api_response = api_instance.api_v1_orders_verify_order_id_get(orderId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrderApi->apiV1OrdersVerifyOrderIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProductApi;

import java.io.File;
import java.util.*;

public class ProductApiExample {

    public static void main(String[] args) {
        
        ProductApi apiInstance = new ProductApi();
        try {
            ProductPagingList result = apiInstance.apiV1ProductsFieldsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductApi#apiV1ProductsFieldsGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ProductApi;

public class ProductApiExample {

    public static void main(String[] args) {
        ProductApi apiInstance = new ProductApi();
        try {
            ProductPagingList result = apiInstance.apiV1ProductsFieldsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductApi#apiV1ProductsFieldsGet");
            e.printStackTrace();
        }
    }
}

ProductApi *apiInstance = [[ProductApi alloc] init];

[apiInstance apiV1ProductsFieldsGetWithCompletionHandler: 
              ^(ProductPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.ProductApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1ProductsFieldsGet(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1ProductsFieldsGetExample
    {
        public void main()
        {

            var apiInstance = new ProductApi();

            try
            {
                ProductPagingList result = apiInstance.apiV1ProductsFieldsGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProductApi.apiV1ProductsFieldsGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiProductApi();

try {
    $result = $api_instance->apiV1ProductsFieldsGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProductApi->apiV1ProductsFieldsGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProductApi;

my $api_instance = WWW::SwaggerClient::ProductApi->new();

eval { 
    my $result = $api_instance->apiV1ProductsFieldsGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProductApi->apiV1ProductsFieldsGet: $@\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.ProductApi()

try: 
    api_response = api_instance.api_v1_products_fields_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductApi->apiV1ProductsFieldsGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProductApi;

import java.io.File;
import java.util.*;

public class ProductApiExample {

    public static void main(String[] args) {
        
        ProductApi apiInstance = new ProductApi();
        try {
            ProductPagingList result = apiInstance.apiV1ProductsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductApi#apiV1ProductsGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ProductApi;

public class ProductApiExample {

    public static void main(String[] args) {
        ProductApi apiInstance = new ProductApi();
        try {
            ProductPagingList result = apiInstance.apiV1ProductsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductApi#apiV1ProductsGet");
            e.printStackTrace();
        }
    }
}

ProductApi *apiInstance = [[ProductApi alloc] init];

[apiInstance apiV1ProductsGetWithCompletionHandler: 
              ^(ProductPagingList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ParlaApiSwagger = require('parla_api___swagger');

var api = new ParlaApiSwagger.ProductApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1ProductsGet(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1ProductsGetExample
    {
        public void main()
        {

            var apiInstance = new ProductApi();

            try
            {
                ProductPagingList result = apiInstance.apiV1ProductsGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProductApi.apiV1ProductsGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiProductApi();

try {
    $result = $api_instance->apiV1ProductsGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProductApi->apiV1ProductsGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProductApi;

my $api_instance = WWW::SwaggerClient::ProductApi->new();

eval { 
    my $result = $api_instance->apiV1ProductsGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProductApi->apiV1ProductsGet: $@\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.ProductApi()

try: 
    api_response = api_instance.api_v1_products_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductApi->apiV1ProductsGet: %s\n" % e)