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

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

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

        // Create an instance of the API class
        CounterofferRestControllerApi apiInstance = new CounterofferRestControllerApi();
        Long id = 789; // Long | 

        try {
            'String' result = apiInstance.acceptCounteroffer(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CounterofferRestControllerApi#acceptCounteroffer");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CounterofferRestControllerApi;

public class CounterofferRestControllerApiExample {
    public static void main(String[] args) {
        CounterofferRestControllerApi apiInstance = new CounterofferRestControllerApi();
        Long id = 789; // Long | 

        try {
            'String' result = apiInstance.acceptCounteroffer(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CounterofferRestControllerApi#acceptCounteroffer");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CounterofferRestControllerApi *apiInstance = [[CounterofferRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.CounterofferRestControllerApi()
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.acceptCounteroffer(id, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new CounterofferRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                'String' result = apiInstance.acceptCounteroffer(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CounterofferRestControllerApi.acceptCounteroffer: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CounterofferRestControllerApi();
$id = 789; // Long | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CounterofferRestControllerApi->new();
my $id = 789; # Long | 

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

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

# Create an instance of the API class
api_instance = openapi_client.CounterofferRestControllerApi()
id = 789 # Long |  (default to null)

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

extern crate CounterofferRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = CounterofferRestControllerApi::Context::default();
    let result = client.acceptCounteroffer(id, &context).wait();

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

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

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

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

        // Create an instance of the API class
        CounterofferRestControllerApi apiInstance = new CounterofferRestControllerApi();
        Long id = 789; // Long | 

        try {
            'String' result = apiInstance.addCounteroffer(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CounterofferRestControllerApi#addCounteroffer");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CounterofferRestControllerApi;

public class CounterofferRestControllerApiExample {
    public static void main(String[] args) {
        CounterofferRestControllerApi apiInstance = new CounterofferRestControllerApi();
        Long id = 789; // Long | 

        try {
            'String' result = apiInstance.addCounteroffer(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CounterofferRestControllerApi#addCounteroffer");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CounterofferRestControllerApi *apiInstance = [[CounterofferRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.CounterofferRestControllerApi()
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.addCounteroffer(id, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new CounterofferRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                'String' result = apiInstance.addCounteroffer(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CounterofferRestControllerApi.addCounteroffer: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CounterofferRestControllerApi();
$id = 789; // Long | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CounterofferRestControllerApi->new();
my $id = 789; # Long | 

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

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

# Create an instance of the API class
api_instance = openapi_client.CounterofferRestControllerApi()
id = 789 # Long |  (default to null)

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

extern crate CounterofferRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = CounterofferRestControllerApi::Context::default();
    let result = client.addCounteroffer(id, &context).wait();

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

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

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

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

        // Create an instance of the API class
        CounterofferRestControllerApi apiInstance = new CounterofferRestControllerApi();
        Long id = 789; // Long | 
        Float body = 3.4; // Float | 

        try {
            Counteroffer result = apiInstance.createCounteroffer(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CounterofferRestControllerApi#createCounteroffer");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CounterofferRestControllerApi;

public class CounterofferRestControllerApiExample {
    public static void main(String[] args) {
        CounterofferRestControllerApi apiInstance = new CounterofferRestControllerApi();
        Long id = 789; // Long | 
        Float body = 3.4; // Float | 

        try {
            Counteroffer result = apiInstance.createCounteroffer(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CounterofferRestControllerApi#createCounteroffer");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CounterofferRestControllerApi *apiInstance = [[CounterofferRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
Float *body = 3.4; // 

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.CounterofferRestControllerApi()
var id = 789; // {Long} 
var body = 3.4; // {Float} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new CounterofferRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var body = 3.4;  // Float | 

            try {
                Counteroffer result = apiInstance.createCounteroffer(id, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CounterofferRestControllerApi.createCounteroffer: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CounterofferRestControllerApi();
$id = 789; // Long | 
$body = 3.4; // Float | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CounterofferRestControllerApi->new();
my $id = 789; # Long | 
my $body = WWW::OPenAPIClient::Object::Float->new(); # Float | 

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

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

# Create an instance of the API class
api_instance = openapi_client.CounterofferRestControllerApi()
id = 789 # Long |  (default to null)
body = 3.4 # Float | 

try:
    api_response = api_instance.create_counteroffer(id, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CounterofferRestControllerApi->createCounteroffer: %s\n" % e)

extern crate CounterofferRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let body = 3.4; // Float

    let mut context = CounterofferRestControllerApi::Context::default();
    let result = client.createCounteroffer(id, body, &context).wait();

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

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

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

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

        // Create an instance of the API class
        CounterofferRestControllerApi apiInstance = new CounterofferRestControllerApi();
        Long id = 789; // Long | 

        try {
            Transaction result = apiInstance.createTransaction(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CounterofferRestControllerApi#createTransaction");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CounterofferRestControllerApi;

public class CounterofferRestControllerApiExample {
    public static void main(String[] args) {
        CounterofferRestControllerApi apiInstance = new CounterofferRestControllerApi();
        Long id = 789; // Long | 

        try {
            Transaction result = apiInstance.createTransaction(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CounterofferRestControllerApi#createTransaction");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CounterofferRestControllerApi *apiInstance = [[CounterofferRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.CounterofferRestControllerApi()
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.createTransaction(id, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new CounterofferRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                Transaction result = apiInstance.createTransaction(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CounterofferRestControllerApi.createTransaction: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CounterofferRestControllerApi();
$id = 789; // Long | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CounterofferRestControllerApi->new();
my $id = 789; # Long | 

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

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

# Create an instance of the API class
api_instance = openapi_client.CounterofferRestControllerApi()
id = 789 # Long |  (default to null)

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

extern crate CounterofferRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = CounterofferRestControllerApi::Context::default();
    let result = client.createTransaction(id, &context).wait();

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

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

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

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

        // Create an instance of the API class
        LoginRestControllerApi apiInstance = new LoginRestControllerApi();

        try {
            AuthResponse result = apiInstance.logOut();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginRestControllerApi#logOut");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.LoginRestControllerApi;

public class LoginRestControllerApiExample {
    public static void main(String[] args) {
        LoginRestControllerApi apiInstance = new LoginRestControllerApi();

        try {
            AuthResponse result = apiInstance.logOut();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginRestControllerApi#logOut");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
LoginRestControllerApi *apiInstance = [[LoginRestControllerApi alloc] init];

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.LoginRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.logOut(callback);

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

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

            // Create an instance of the API class
            var apiInstance = new LoginRestControllerApi();

            try {
                AuthResponse result = apiInstance.logOut();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginRestControllerApi.logOut: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginRestControllerApi();

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginRestControllerApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.LoginRestControllerApi()

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

extern crate LoginRestControllerApi;

pub fn main() {

    let mut context = LoginRestControllerApi::Context::default();
    let result = client.logOut(&context).wait();

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

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

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

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

        // Create an instance of the API class
        LoginRestControllerApi apiInstance = new LoginRestControllerApi();
        LoginRequest loginRequest = ; // LoginRequest | 
        String accessToken = accessToken_example; // String | 
        String refreshToken = refreshToken_example; // String | 

        try {
            AuthResponse result = apiInstance.login(loginRequest, accessToken, refreshToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginRestControllerApi#login");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.LoginRestControllerApi;

public class LoginRestControllerApiExample {
    public static void main(String[] args) {
        LoginRestControllerApi apiInstance = new LoginRestControllerApi();
        LoginRequest loginRequest = ; // LoginRequest | 
        String accessToken = accessToken_example; // String | 
        String refreshToken = refreshToken_example; // String | 

        try {
            AuthResponse result = apiInstance.login(loginRequest, accessToken, refreshToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginRestControllerApi#login");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
LoginRestControllerApi *apiInstance = [[LoginRestControllerApi alloc] init];
LoginRequest *loginRequest = ; // 
String *accessToken = accessToken_example; //  (optional) (default to null)
String *refreshToken = refreshToken_example; //  (optional) (default to null)

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.LoginRestControllerApi()
var loginRequest = ; // {LoginRequest} 
var opts = {
  'accessToken': accessToken_example, // {String} 
  'refreshToken': refreshToken_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new LoginRestControllerApi();
            var loginRequest = new LoginRequest(); // LoginRequest | 
            var accessToken = accessToken_example;  // String |  (optional)  (default to null)
            var refreshToken = refreshToken_example;  // String |  (optional)  (default to null)

            try {
                AuthResponse result = apiInstance.login(loginRequest, accessToken, refreshToken);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginRestControllerApi.login: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginRestControllerApi();
$loginRequest = ; // LoginRequest | 
$accessToken = accessToken_example; // String | 
$refreshToken = refreshToken_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginRestControllerApi->new();
my $loginRequest = WWW::OPenAPIClient::Object::LoginRequest->new(); # LoginRequest | 
my $accessToken = accessToken_example; # String | 
my $refreshToken = refreshToken_example; # String | 

eval {
    my $result = $api_instance->login(loginRequest => $loginRequest, accessToken => $accessToken, refreshToken => $refreshToken);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LoginRestControllerApi->login: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.LoginRestControllerApi()
loginRequest =  # LoginRequest | 
accessToken = accessToken_example # String |  (optional) (default to null)
refreshToken = refreshToken_example # String |  (optional) (default to null)

try:
    api_response = api_instance.login(loginRequest, accessToken=accessToken, refreshToken=refreshToken)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LoginRestControllerApi->login: %s\n" % e)

extern crate LoginRestControllerApi;

pub fn main() {
    let loginRequest = ; // LoginRequest
    let accessToken = accessToken_example; // String
    let refreshToken = refreshToken_example; // String

    let mut context = LoginRestControllerApi::Context::default();
    let result = client.login(loginRequest, accessToken, refreshToken, &context).wait();

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

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

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

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

        // Create an instance of the API class
        LoginRestControllerApi apiInstance = new LoginRestControllerApi();
        String refreshToken = refreshToken_example; // String | 

        try {
            AuthResponse result = apiInstance.refreshToken(refreshToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginRestControllerApi#refreshToken");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.LoginRestControllerApi;

public class LoginRestControllerApiExample {
    public static void main(String[] args) {
        LoginRestControllerApi apiInstance = new LoginRestControllerApi();
        String refreshToken = refreshToken_example; // String | 

        try {
            AuthResponse result = apiInstance.refreshToken(refreshToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginRestControllerApi#refreshToken");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
LoginRestControllerApi *apiInstance = [[LoginRestControllerApi alloc] init];
String *refreshToken = refreshToken_example; //  (optional) (default to null)

[apiInstance refreshTokenWith:refreshToken
              completionHandler: ^(AuthResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.LoginRestControllerApi()
var opts = {
  'refreshToken': refreshToken_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new LoginRestControllerApi();
            var refreshToken = refreshToken_example;  // String |  (optional)  (default to null)

            try {
                AuthResponse result = apiInstance.refreshToken(refreshToken);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginRestControllerApi.refreshToken: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginRestControllerApi();
$refreshToken = refreshToken_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginRestControllerApi->new();
my $refreshToken = refreshToken_example; # String | 

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

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

# Create an instance of the API class
api_instance = openapi_client.LoginRestControllerApi()
refreshToken = refreshToken_example # String |  (optional) (default to null)

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

extern crate LoginRestControllerApi;

pub fn main() {
    let refreshToken = refreshToken_example; // String

    let mut context = LoginRestControllerApi::Context::default();
    let result = client.refreshToken(refreshToken, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ProductRestControllerApi apiInstance = new ProductRestControllerApi();
        Product product = ; // Product | 

        try {
            Product result = apiInstance.createProduct(product);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#createProduct");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ProductRestControllerApi;

public class ProductRestControllerApiExample {
    public static void main(String[] args) {
        ProductRestControllerApi apiInstance = new ProductRestControllerApi();
        Product product = ; // Product | 

        try {
            Product result = apiInstance.createProduct(product);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#createProduct");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ProductRestControllerApi *apiInstance = [[ProductRestControllerApi alloc] init];
Product *product = ; // 

[apiInstance createProductWith:product
              completionHandler: ^(Product output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ProductRestControllerApi()
var product = ; // {Product} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProductRestControllerApi();
            var product = new Product(); // Product | 

            try {
                Product result = apiInstance.createProduct(product);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductRestControllerApi.createProduct: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProductRestControllerApi();
$product = ; // Product | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProductRestControllerApi->new();
my $product = WWW::OPenAPIClient::Object::Product->new(); # Product | 

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

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

# Create an instance of the API class
api_instance = openapi_client.ProductRestControllerApi()
product =  # Product | 

try:
    api_response = api_instance.create_product(product)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductRestControllerApi->createProduct: %s\n" % e)

extern crate ProductRestControllerApi;

pub fn main() {
    let product = ; // Product

    let mut context = ProductRestControllerApi::Context::default();
    let result = client.createProduct(product, &context).wait();

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