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

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

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

        // Create an instance of the API class
        AdminRestControllerApi apiInstance = new AdminRestControllerApi();
        String page = page_example; // String | page

        try {
            apiInstance.getOrders(page);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminRestControllerApi#getOrders");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AdminRestControllerApi;

public class AdminRestControllerApiExample {
    public static void main(String[] args) {
        AdminRestControllerApi apiInstance = new AdminRestControllerApi();
        String page = page_example; // String | page

        try {
            apiInstance.getOrders(page);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminRestControllerApi#getOrders");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AdminRestControllerApi *apiInstance = [[AdminRestControllerApi alloc] init];
String *page = page_example; // page (optional) (default to null)

// Get a all orders
[apiInstance getOrdersWith:page
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.AdminRestControllerApi()
var opts = {
  'page': page_example // {String} page
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new AdminRestControllerApi();
            var page = page_example;  // String | page (optional)  (default to null)

            try {
                // Get a all orders
                apiInstance.getOrders(page);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminRestControllerApi.getOrders: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminRestControllerApi();
$page = page_example; // String | page

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminRestControllerApi->new();
my $page = page_example; # String | page

eval {
    $api_instance->getOrders(page => $page);
};
if ($@) {
    warn "Exception when calling AdminRestControllerApi->getOrders: $@\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.AdminRestControllerApi()
page = page_example # String | page (optional) (default to null)

try:
    # Get a all orders
    api_instance.get_orders(page=page)
except ApiException as e:
    print("Exception when calling AdminRestControllerApi->getOrders: %s\n" % e)

extern crate AdminRestControllerApi;

pub fn main() {
    let page = page_example; // String

    let mut context = AdminRestControllerApi::Context::default();
    let result = client.getOrders(page, &context).wait();

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

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

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

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

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

        try {
            apiInstance.getStatistics();
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminRestControllerApi#getStatistics");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AdminRestControllerApi;

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

        try {
            apiInstance.getStatistics();
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminRestControllerApi#getStatistics");
            e.printStackTrace();
        }
    }
}

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

// Get a all Statistics
[apiInstance getStatisticsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                // Get a all Statistics
                apiInstance.getStatistics();
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminRestControllerApi.getStatistics: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get a all Statistics
    api_instance.get_statistics()
except ApiException as e:
    print("Exception when calling AdminRestControllerApi->getStatistics: %s\n" % e)

extern crate AdminRestControllerApi;

pub fn main() {

    let mut context = AdminRestControllerApi::Context::default();
    let result = client.getStatistics(&context).wait();

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

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

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

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

        // Create an instance of the API class
        AdminRestControllerApi apiInstance = new AdminRestControllerApi();
        String page = page_example; // String | page

        try {
            apiInstance.getUsers(page);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminRestControllerApi#getUsers");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AdminRestControllerApi;

public class AdminRestControllerApiExample {
    public static void main(String[] args) {
        AdminRestControllerApi apiInstance = new AdminRestControllerApi();
        String page = page_example; // String | page

        try {
            apiInstance.getUsers(page);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminRestControllerApi#getUsers");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AdminRestControllerApi *apiInstance = [[AdminRestControllerApi alloc] init];
String *page = page_example; // page (optional) (default to null)

// Get a all users type customers
[apiInstance getUsersWith:page
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.AdminRestControllerApi()
var opts = {
  'page': page_example // {String} page
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new AdminRestControllerApi();
            var page = page_example;  // String | page (optional)  (default to null)

            try {
                // Get a all users type customers
                apiInstance.getUsers(page);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminRestControllerApi.getUsers: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminRestControllerApi();
$page = page_example; // String | page

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminRestControllerApi->new();
my $page = page_example; # String | page

eval {
    $api_instance->getUsers(page => $page);
};
if ($@) {
    warn "Exception when calling AdminRestControllerApi->getUsers: $@\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.AdminRestControllerApi()
page = page_example # String | page (optional) (default to null)

try:
    # Get a all users type customers
    api_instance.get_users(page=page)
except ApiException as e:
    print("Exception when calling AdminRestControllerApi->getUsers: %s\n" % e)

extern crate AdminRestControllerApi;

pub fn main() {
    let page = page_example; // String

    let mut context = AdminRestControllerApi::Context::default();
    let result = client.getUsers(page, &context).wait();

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

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

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

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

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

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

import org.openapitools.client.api.LoginApiControllerApi;

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

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

// Create an instance of the API class
LoginApiControllerApi *apiInstance = [[LoginApiControllerApi 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.LoginApiControllerApi()
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 LoginApiControllerApi();

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

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

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

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

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

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

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

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

extern crate LoginApiControllerApi;

pub fn main() {

    let mut context = LoginApiControllerApi::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.LoginApiControllerApi;

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

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

        // Create an instance of the API class
        LoginApiControllerApi apiInstance = new LoginApiControllerApi();
        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 LoginApiControllerApi#login");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.LoginApiControllerApi;

public class LoginApiControllerApiExample {
    public static void main(String[] args) {
        LoginApiControllerApi apiInstance = new LoginApiControllerApi();
        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 LoginApiControllerApi#login");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
LoginApiControllerApi *apiInstance = [[LoginApiControllerApi 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.LoginApiControllerApi()
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 LoginApiControllerApi();
            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 LoginApiControllerApi.login: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginApiControllerApi();
$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 LoginApiControllerApi->login: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginApiControllerApi->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 LoginApiControllerApi->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.LoginApiControllerApi()
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 LoginApiControllerApi->login: %s\n" % e)

extern crate LoginApiControllerApi;

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

    let mut context = LoginApiControllerApi::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.LoginApiControllerApi;

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

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

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

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

import org.openapitools.client.api.LoginApiControllerApi;

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

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

// Create an instance of the API class
LoginApiControllerApi *apiInstance = [[LoginApiControllerApi 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.LoginApiControllerApi()
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 LoginApiControllerApi();
            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 LoginApiControllerApi.refreshToken: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->refreshToken(refreshToken => $refreshToken);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LoginApiControllerApi->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.LoginApiControllerApi()
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 LoginApiControllerApi->refreshToken: %s\n" % e)

extern crate LoginApiControllerApi;

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

    let mut context = LoginApiControllerApi::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.ProductsRestControllerApi;

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

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

        // Create an instance of the API class
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        Integer id = 56; // Integer | id of Product to be searched

        try {
            apiInstance.deleteProduct(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#deleteProduct");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ProductsRestControllerApi;

public class ProductsRestControllerApiExample {
    public static void main(String[] args) {
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        Integer id = 56; // Integer | id of Product to be searched

        try {
            apiInstance.deleteProduct(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#deleteProduct");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ProductsRestControllerApi *apiInstance = [[ProductsRestControllerApi alloc] init];
Integer *id = 56; // id of Product to be searched (default to null)

// Delete a Product
[apiInstance deleteProductWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ProductsRestControllerApi()
var id = 56; // {Integer} id of Product to be searched

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProductsRestControllerApi();
            var id = 56;  // Integer | id of Product to be searched (default to null)

            try {
                // Delete a Product
                apiInstance.deleteProduct(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductsRestControllerApi.deleteProduct: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProductsRestControllerApi();
$id = 56; // Integer | id of Product to be searched

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProductsRestControllerApi->new();
my $id = 56; # Integer | id of Product to be searched

eval {
    $api_instance->deleteProduct(id => $id);
};
if ($@) {
    warn "Exception when calling ProductsRestControllerApi->deleteProduct: $@\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.ProductsRestControllerApi()
id = 56 # Integer | id of Product to be searched (default to null)

try:
    # Delete a Product
    api_instance.delete_product(id)
except ApiException as e:
    print("Exception when calling ProductsRestControllerApi->deleteProduct: %s\n" % e)

extern crate ProductsRestControllerApi;

pub fn main() {
    let id = 56; // Integer

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

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

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

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

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

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

        try {
            apiInstance.getAllProducts();
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#getAllProducts");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ProductsRestControllerApi;

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

        try {
            apiInstance.getAllProducts();
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#getAllProducts");
            e.printStackTrace();
        }
    }
}

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

// Get New Six Products
[apiInstance getAllProductsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                // Get New Six Products
                apiInstance.getAllProducts();
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductsRestControllerApi.getAllProducts: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get New Six Products
    api_instance.get_all_products()
except ApiException as e:
    print("Exception when calling ProductsRestControllerApi->getAllProducts: %s\n" % e)

extern crate ProductsRestControllerApi;

pub fn main() {

    let mut context = ProductsRestControllerApi::Context::default();
    let result = client.getAllProducts(&context).wait();

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

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

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

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

        // Create an instance of the API class
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        String page = page_example; // String | page
        String typeProduct = typeProduct_example; // String | typeProduct

        try {
            apiInstance.getComponentsPage(page, typeProduct);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#getComponentsPage");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ProductsRestControllerApi;

public class ProductsRestControllerApiExample {
    public static void main(String[] args) {
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        String page = page_example; // String | page
        String typeProduct = typeProduct_example; // String | typeProduct

        try {
            apiInstance.getComponentsPage(page, typeProduct);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#getComponentsPage");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ProductsRestControllerApi *apiInstance = [[ProductsRestControllerApi alloc] init];
String *page = page_example; // page (optional) (default to null)
String *typeProduct = typeProduct_example; // typeProduct (optional) (default to null)

// Get a component
[apiInstance getComponentsPageWith:page
    typeProduct:typeProduct
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ProductsRestControllerApi()
var opts = {
  'page': page_example, // {String} page
  'typeProduct': typeProduct_example // {String} typeProduct
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProductsRestControllerApi();
            var page = page_example;  // String | page (optional)  (default to null)
            var typeProduct = typeProduct_example;  // String | typeProduct (optional)  (default to null)

            try {
                // Get a component
                apiInstance.getComponentsPage(page, typeProduct);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductsRestControllerApi.getComponentsPage: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProductsRestControllerApi();
$page = page_example; // String | page
$typeProduct = typeProduct_example; // String | typeProduct

try {
    $api_instance->getComponentsPage($page, $typeProduct);
} catch (Exception $e) {
    echo 'Exception when calling ProductsRestControllerApi->getComponentsPage: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProductsRestControllerApi->new();
my $page = page_example; # String | page
my $typeProduct = typeProduct_example; # String | typeProduct

eval {
    $api_instance->getComponentsPage(page => $page, typeProduct => $typeProduct);
};
if ($@) {
    warn "Exception when calling ProductsRestControllerApi->getComponentsPage: $@\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.ProductsRestControllerApi()
page = page_example # String | page (optional) (default to null)
typeProduct = typeProduct_example # String | typeProduct (optional) (default to null)

try:
    # Get a component
    api_instance.get_components_page(page=page, typeProduct=typeProduct)
except ApiException as e:
    print("Exception when calling ProductsRestControllerApi->getComponentsPage: %s\n" % e)

extern crate ProductsRestControllerApi;

pub fn main() {
    let page = page_example; // String
    let typeProduct = typeProduct_example; // String

    let mut context = ProductsRestControllerApi::Context::default();
    let result = client.getComponentsPage(page, typeProduct, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        Integer id = 56; // Integer | id of Product to be searched

        try {
            apiInstance.getImage1(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#getImage1");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ProductsRestControllerApi;

public class ProductsRestControllerApiExample {
    public static void main(String[] args) {
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        Integer id = 56; // Integer | id of Product to be searched

        try {
            apiInstance.getImage1(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#getImage1");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ProductsRestControllerApi *apiInstance = [[ProductsRestControllerApi alloc] init];
Integer *id = 56; // id of Product to be searched (default to null)

// Get a Image 1 Product by its id
[apiInstance getImage1With:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ProductsRestControllerApi()
var id = 56; // {Integer} id of Product to be searched

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProductsRestControllerApi();
            var id = 56;  // Integer | id of Product to be searched (default to null)

            try {
                // Get a Image 1 Product by its id
                apiInstance.getImage1(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductsRestControllerApi.getImage1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProductsRestControllerApi();
$id = 56; // Integer | id of Product to be searched

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProductsRestControllerApi->new();
my $id = 56; # Integer | id of Product to be searched

eval {
    $api_instance->getImage1(id => $id);
};
if ($@) {
    warn "Exception when calling ProductsRestControllerApi->getImage1: $@\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.ProductsRestControllerApi()
id = 56 # Integer | id of Product to be searched (default to null)

try:
    # Get a Image 1 Product by its id
    api_instance.get_image1(id)
except ApiException as e:
    print("Exception when calling ProductsRestControllerApi->getImage1: %s\n" % e)

extern crate ProductsRestControllerApi;

pub fn main() {
    let id = 56; // Integer

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

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

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

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

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

        // Create an instance of the API class
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        Integer id = 56; // Integer | id of Product to be searched

        try {
            apiInstance.getImage2(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#getImage2");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ProductsRestControllerApi;

public class ProductsRestControllerApiExample {
    public static void main(String[] args) {
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        Integer id = 56; // Integer | id of Product to be searched

        try {
            apiInstance.getImage2(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#getImage2");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ProductsRestControllerApi *apiInstance = [[ProductsRestControllerApi alloc] init];
Integer *id = 56; // id of Product to be searched (default to null)

// Get a Image 2 Product by its id
[apiInstance getImage2With:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ProductsRestControllerApi()
var id = 56; // {Integer} id of Product to be searched

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProductsRestControllerApi();
            var id = 56;  // Integer | id of Product to be searched (default to null)

            try {
                // Get a Image 2 Product by its id
                apiInstance.getImage2(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductsRestControllerApi.getImage2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProductsRestControllerApi();
$id = 56; // Integer | id of Product to be searched

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProductsRestControllerApi->new();
my $id = 56; # Integer | id of Product to be searched

eval {
    $api_instance->getImage2(id => $id);
};
if ($@) {
    warn "Exception when calling ProductsRestControllerApi->getImage2: $@\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.ProductsRestControllerApi()
id = 56 # Integer | id of Product to be searched (default to null)

try:
    # Get a Image 2 Product by its id
    api_instance.get_image2(id)
except ApiException as e:
    print("Exception when calling ProductsRestControllerApi->getImage2: %s\n" % e)

extern crate ProductsRestControllerApi;

pub fn main() {
    let id = 56; // Integer

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

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

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

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

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

        // Create an instance of the API class
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        Integer id = 56; // Integer | id of Product to be searched

        try {
            apiInstance.getImage3(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#getImage3");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ProductsRestControllerApi;

public class ProductsRestControllerApiExample {
    public static void main(String[] args) {
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        Integer id = 56; // Integer | id of Product to be searched

        try {
            apiInstance.getImage3(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#getImage3");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ProductsRestControllerApi *apiInstance = [[ProductsRestControllerApi alloc] init];
Integer *id = 56; // id of Product to be searched (default to null)

// Get a Image 3 Product by its id
[apiInstance getImage3With:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ProductsRestControllerApi()
var id = 56; // {Integer} id of Product to be searched

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProductsRestControllerApi();
            var id = 56;  // Integer | id of Product to be searched (default to null)

            try {
                // Get a Image 3 Product by its id
                apiInstance.getImage3(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductsRestControllerApi.getImage3: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProductsRestControllerApi();
$id = 56; // Integer | id of Product to be searched

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProductsRestControllerApi->new();
my $id = 56; # Integer | id of Product to be searched

eval {
    $api_instance->getImage3(id => $id);
};
if ($@) {
    warn "Exception when calling ProductsRestControllerApi->getImage3: $@\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.ProductsRestControllerApi()
id = 56 # Integer | id of Product to be searched (default to null)

try:
    # Get a Image 3 Product by its id
    api_instance.get_image3(id)
except ApiException as e:
    print("Exception when calling ProductsRestControllerApi->getImage3: %s\n" % e)

extern crate ProductsRestControllerApi;

pub fn main() {
    let id = 56; // Integer

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

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

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

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

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

        // Create an instance of the API class
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        String page = page_example; // String | page
        String typeProduct = typeProduct_example; // String | typeProduct

        try {
            apiInstance.getPeripheralsPage(page, typeProduct);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#getPeripheralsPage");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ProductsRestControllerApi;

public class ProductsRestControllerApiExample {
    public static void main(String[] args) {
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        String page = page_example; // String | page
        String typeProduct = typeProduct_example; // String | typeProduct

        try {
            apiInstance.getPeripheralsPage(page, typeProduct);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#getPeripheralsPage");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ProductsRestControllerApi *apiInstance = [[ProductsRestControllerApi alloc] init];
String *page = page_example; // page (optional) (default to null)
String *typeProduct = typeProduct_example; // typeProduct (optional) (default to null)

// Get a peripheral
[apiInstance getPeripheralsPageWith:page
    typeProduct:typeProduct
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ProductsRestControllerApi()
var opts = {
  'page': page_example, // {String} page
  'typeProduct': typeProduct_example // {String} typeProduct
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProductsRestControllerApi();
            var page = page_example;  // String | page (optional)  (default to null)
            var typeProduct = typeProduct_example;  // String | typeProduct (optional)  (default to null)

            try {
                // Get a peripheral
                apiInstance.getPeripheralsPage(page, typeProduct);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductsRestControllerApi.getPeripheralsPage: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProductsRestControllerApi();
$page = page_example; // String | page
$typeProduct = typeProduct_example; // String | typeProduct

try {
    $api_instance->getPeripheralsPage($page, $typeProduct);
} catch (Exception $e) {
    echo 'Exception when calling ProductsRestControllerApi->getPeripheralsPage: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProductsRestControllerApi->new();
my $page = page_example; # String | page
my $typeProduct = typeProduct_example; # String | typeProduct

eval {
    $api_instance->getPeripheralsPage(page => $page, typeProduct => $typeProduct);
};
if ($@) {
    warn "Exception when calling ProductsRestControllerApi->getPeripheralsPage: $@\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.ProductsRestControllerApi()
page = page_example # String | page (optional) (default to null)
typeProduct = typeProduct_example # String | typeProduct (optional) (default to null)

try:
    # Get a peripheral
    api_instance.get_peripherals_page(page=page, typeProduct=typeProduct)
except ApiException as e:
    print("Exception when calling ProductsRestControllerApi->getPeripheralsPage: %s\n" % e)

extern crate ProductsRestControllerApi;

pub fn main() {
    let page = page_example; // String
    let typeProduct = typeProduct_example; // String

    let mut context = ProductsRestControllerApi::Context::default();
    let result = client.getPeripheralsPage(page, typeProduct, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        String page = page_example; // String | page
        String typeProduct = typeProduct_example; // String | typeProduct

        try {
            apiInstance.getPhonesPage(page, typeProduct);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#getPhonesPage");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ProductsRestControllerApi;

public class ProductsRestControllerApiExample {
    public static void main(String[] args) {
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        String page = page_example; // String | page
        String typeProduct = typeProduct_example; // String | typeProduct

        try {
            apiInstance.getPhonesPage(page, typeProduct);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#getPhonesPage");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ProductsRestControllerApi *apiInstance = [[ProductsRestControllerApi alloc] init];
String *page = page_example; // page (optional) (default to null)
String *typeProduct = typeProduct_example; // typeProduct (optional) (default to null)

// Get a phone
[apiInstance getPhonesPageWith:page
    typeProduct:typeProduct
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ProductsRestControllerApi()
var opts = {
  'page': page_example, // {String} page
  'typeProduct': typeProduct_example // {String} typeProduct
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProductsRestControllerApi();
            var page = page_example;  // String | page (optional)  (default to null)
            var typeProduct = typeProduct_example;  // String | typeProduct (optional)  (default to null)

            try {
                // Get a phone
                apiInstance.getPhonesPage(page, typeProduct);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductsRestControllerApi.getPhonesPage: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProductsRestControllerApi();
$page = page_example; // String | page
$typeProduct = typeProduct_example; // String | typeProduct

try {
    $api_instance->getPhonesPage($page, $typeProduct);
} catch (Exception $e) {
    echo 'Exception when calling ProductsRestControllerApi->getPhonesPage: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProductsRestControllerApi->new();
my $page = page_example; # String | page
my $typeProduct = typeProduct_example; # String | typeProduct

eval {
    $api_instance->getPhonesPage(page => $page, typeProduct => $typeProduct);
};
if ($@) {
    warn "Exception when calling ProductsRestControllerApi->getPhonesPage: $@\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.ProductsRestControllerApi()
page = page_example # String | page (optional) (default to null)
typeProduct = typeProduct_example # String | typeProduct (optional) (default to null)

try:
    # Get a phone
    api_instance.get_phones_page(page=page, typeProduct=typeProduct)
except ApiException as e:
    print("Exception when calling ProductsRestControllerApi->getPhonesPage: %s\n" % e)

extern crate ProductsRestControllerApi;

pub fn main() {
    let page = page_example; // String
    let typeProduct = typeProduct_example; // String

    let mut context = ProductsRestControllerApi::Context::default();
    let result = client.getPhonesPage(page, typeProduct, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        Integer id = 56; // Integer | id of Product to be searched

        try {
            apiInstance.getProduct(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#getProduct");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ProductsRestControllerApi;

public class ProductsRestControllerApiExample {
    public static void main(String[] args) {
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        Integer id = 56; // Integer | id of Product to be searched

        try {
            apiInstance.getProduct(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#getProduct");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ProductsRestControllerApi *apiInstance = [[ProductsRestControllerApi alloc] init];
Integer *id = 56; // id of Product to be searched (default to null)

// Get a products by its id
[apiInstance getProductWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ProductsRestControllerApi()
var id = 56; // {Integer} id of Product to be searched

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProductsRestControllerApi();
            var id = 56;  // Integer | id of Product to be searched (default to null)

            try {
                // Get a products by its id
                apiInstance.getProduct(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductsRestControllerApi.getProduct: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProductsRestControllerApi();
$id = 56; // Integer | id of Product to be searched

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProductsRestControllerApi->new();
my $id = 56; # Integer | id of Product to be searched

eval {
    $api_instance->getProduct(id => $id);
};
if ($@) {
    warn "Exception when calling ProductsRestControllerApi->getProduct: $@\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.ProductsRestControllerApi()
id = 56 # Integer | id of Product to be searched (default to null)

try:
    # Get a products by its id
    api_instance.get_product(id)
except ApiException as e:
    print("Exception when calling ProductsRestControllerApi->getProduct: %s\n" % e)

extern crate ProductsRestControllerApi;

pub fn main() {
    let id = 56; // Integer

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

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

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

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

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

        // Create an instance of the API class
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        Integer id = 56; // Integer | id of Product to be searched
        String page = page_example; // String | page

        try {
            apiInstance.getProductRatings(id, page);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#getProductRatings");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ProductsRestControllerApi;

public class ProductsRestControllerApiExample {
    public static void main(String[] args) {
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        Integer id = 56; // Integer | id of Product to be searched
        String page = page_example; // String | page

        try {
            apiInstance.getProductRatings(id, page);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#getProductRatings");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ProductsRestControllerApi *apiInstance = [[ProductsRestControllerApi alloc] init];
Integer *id = 56; // id of Product to be searched (default to null)
String *page = page_example; // page (optional) (default to null)

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ProductsRestControllerApi()
var id = 56; // {Integer} id of Product to be searched
var opts = {
  'page': page_example // {String} page
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProductsRestControllerApi();
            var id = 56;  // Integer | id of Product to be searched (default to null)
            var page = page_example;  // String | page (optional)  (default to null)

            try {
                // Ratings
                apiInstance.getProductRatings(id, page);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductsRestControllerApi.getProductRatings: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProductsRestControllerApi();
$id = 56; // Integer | id of Product to be searched
$page = page_example; // String | page

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProductsRestControllerApi->new();
my $id = 56; # Integer | id of Product to be searched
my $page = page_example; # String | page

eval {
    $api_instance->getProductRatings(id => $id, page => $page);
};
if ($@) {
    warn "Exception when calling ProductsRestControllerApi->getProductRatings: $@\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.ProductsRestControllerApi()
id = 56 # Integer | id of Product to be searched (default to null)
page = page_example # String | page (optional) (default to null)

try:
    # Ratings
    api_instance.get_product_ratings(id, page=page)
except ApiException as e:
    print("Exception when calling ProductsRestControllerApi->getProductRatings: %s\n" % e)

extern crate ProductsRestControllerApi;

pub fn main() {
    let id = 56; // Integer
    let page = page_example; // String

    let mut context = ProductsRestControllerApi::Context::default();
    let result = client.getProductRatings(id, page, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        ProductDetailed productDetailed = ; // ProductDetailed | 

        try {
            apiInstance.registerProduct(productDetailed);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#registerProduct");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ProductsRestControllerApi;

public class ProductsRestControllerApiExample {
    public static void main(String[] args) {
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        ProductDetailed productDetailed = ; // ProductDetailed | 

        try {
            apiInstance.registerProduct(productDetailed);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#registerProduct");
            e.printStackTrace();
        }
    }
}

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

// Create a Products
[apiInstance registerProductWith:productDetailed
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ProductsRestControllerApi()
var productDetailed = ; // {ProductDetailed} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProductsRestControllerApi();
            var productDetailed = new ProductDetailed(); // ProductDetailed | 

            try {
                // Create a Products
                apiInstance.registerProduct(productDetailed);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductsRestControllerApi.registerProduct: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProductsRestControllerApi();
$productDetailed = ; // ProductDetailed | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProductsRestControllerApi->new();
my $productDetailed = WWW::OPenAPIClient::Object::ProductDetailed->new(); # ProductDetailed | 

eval {
    $api_instance->registerProduct(productDetailed => $productDetailed);
};
if ($@) {
    warn "Exception when calling ProductsRestControllerApi->registerProduct: $@\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.ProductsRestControllerApi()
productDetailed =  # ProductDetailed | 

try:
    # Create a Products
    api_instance.register_product(productDetailed)
except ApiException as e:
    print("Exception when calling ProductsRestControllerApi->registerProduct: %s\n" % e)

extern crate ProductsRestControllerApi;

pub fn main() {
    let productDetailed = ; // ProductDetailed

    let mut context = ProductsRestControllerApi::Context::default();
    let result = client.registerProduct(productDetailed, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        Integer id = 56; // Integer | id of Product to be searched
        ProductDetailed productDetailed = ; // ProductDetailed | 

        try {
            apiInstance.replaceProduct(id, productDetailed);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#replaceProduct");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ProductsRestControllerApi;

public class ProductsRestControllerApiExample {
    public static void main(String[] args) {
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        Integer id = 56; // Integer | id of Product to be searched
        ProductDetailed productDetailed = ; // ProductDetailed | 

        try {
            apiInstance.replaceProduct(id, productDetailed);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#replaceProduct");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ProductsRestControllerApi *apiInstance = [[ProductsRestControllerApi alloc] init];
Integer *id = 56; // id of Product to be searched (default to null)
ProductDetailed *productDetailed = ; // 

// Modify a Product
[apiInstance replaceProductWith:id
    productDetailed:productDetailed
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ProductsRestControllerApi()
var id = 56; // {Integer} id of Product to be searched
var productDetailed = ; // {ProductDetailed} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProductsRestControllerApi();
            var id = 56;  // Integer | id of Product to be searched (default to null)
            var productDetailed = new ProductDetailed(); // ProductDetailed | 

            try {
                // Modify a Product
                apiInstance.replaceProduct(id, productDetailed);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductsRestControllerApi.replaceProduct: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProductsRestControllerApi();
$id = 56; // Integer | id of Product to be searched
$productDetailed = ; // ProductDetailed | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProductsRestControllerApi->new();
my $id = 56; # Integer | id of Product to be searched
my $productDetailed = WWW::OPenAPIClient::Object::ProductDetailed->new(); # ProductDetailed | 

eval {
    $api_instance->replaceProduct(id => $id, productDetailed => $productDetailed);
};
if ($@) {
    warn "Exception when calling ProductsRestControllerApi->replaceProduct: $@\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.ProductsRestControllerApi()
id = 56 # Integer | id of Product to be searched (default to null)
productDetailed =  # ProductDetailed | 

try:
    # Modify a Product
    api_instance.replace_product(id, productDetailed)
except ApiException as e:
    print("Exception when calling ProductsRestControllerApi->replaceProduct: %s\n" % e)

extern crate ProductsRestControllerApi;

pub fn main() {
    let id = 56; // Integer
    let productDetailed = ; // ProductDetailed

    let mut context = ProductsRestControllerApi::Context::default();
    let result = client.replaceProduct(id, productDetailed, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        Integer id = 56; // Integer | id of Product to be searched
        InlineObject3 inlineObject3 = ; // InlineObject3 | 

        try {
            apiInstance.uploadImage1(id, inlineObject3);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#uploadImage1");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ProductsRestControllerApi;

public class ProductsRestControllerApiExample {
    public static void main(String[] args) {
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        Integer id = 56; // Integer | id of Product to be searched
        InlineObject3 inlineObject3 = ; // InlineObject3 | 

        try {
            apiInstance.uploadImage1(id, inlineObject3);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#uploadImage1");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ProductsRestControllerApi *apiInstance = [[ProductsRestControllerApi alloc] init];
Integer *id = 56; // id of Product to be searched (default to null)
InlineObject3 *inlineObject3 = ; //  (optional)

// Create a Image 1 Product by its id
[apiInstance uploadImage1With:id
    inlineObject3:inlineObject3
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ProductsRestControllerApi()
var id = 56; // {Integer} id of Product to be searched
var opts = {
  'inlineObject3':  // {InlineObject3} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProductsRestControllerApi();
            var id = 56;  // Integer | id of Product to be searched (default to null)
            var inlineObject3 = new InlineObject3(); // InlineObject3 |  (optional) 

            try {
                // Create a Image 1 Product by its id
                apiInstance.uploadImage1(id, inlineObject3);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductsRestControllerApi.uploadImage1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProductsRestControllerApi();
$id = 56; // Integer | id of Product to be searched
$inlineObject3 = ; // InlineObject3 | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProductsRestControllerApi->new();
my $id = 56; # Integer | id of Product to be searched
my $inlineObject3 = WWW::OPenAPIClient::Object::InlineObject3->new(); # InlineObject3 | 

eval {
    $api_instance->uploadImage1(id => $id, inlineObject3 => $inlineObject3);
};
if ($@) {
    warn "Exception when calling ProductsRestControllerApi->uploadImage1: $@\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.ProductsRestControllerApi()
id = 56 # Integer | id of Product to be searched (default to null)
inlineObject3 =  # InlineObject3 |  (optional)

try:
    # Create a Image 1 Product by its id
    api_instance.upload_image1(id, inlineObject3=inlineObject3)
except ApiException as e:
    print("Exception when calling ProductsRestControllerApi->uploadImage1: %s\n" % e)

extern crate ProductsRestControllerApi;

pub fn main() {
    let id = 56; // Integer
    let inlineObject3 = ; // InlineObject3

    let mut context = ProductsRestControllerApi::Context::default();
    let result = client.uploadImage1(id, inlineObject3, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        Integer id = 56; // Integer | id of Product to be searched
        InlineObject2 inlineObject2 = ; // InlineObject2 | 

        try {
            apiInstance.uploadImage2(id, inlineObject2);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#uploadImage2");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ProductsRestControllerApi;

public class ProductsRestControllerApiExample {
    public static void main(String[] args) {
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        Integer id = 56; // Integer | id of Product to be searched
        InlineObject2 inlineObject2 = ; // InlineObject2 | 

        try {
            apiInstance.uploadImage2(id, inlineObject2);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#uploadImage2");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ProductsRestControllerApi *apiInstance = [[ProductsRestControllerApi alloc] init];
Integer *id = 56; // id of Product to be searched (default to null)
InlineObject2 *inlineObject2 = ; //  (optional)

// Create a Image 2 Product by its id
[apiInstance uploadImage2With:id
    inlineObject2:inlineObject2
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ProductsRestControllerApi()
var id = 56; // {Integer} id of Product to be searched
var opts = {
  'inlineObject2':  // {InlineObject2} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProductsRestControllerApi();
            var id = 56;  // Integer | id of Product to be searched (default to null)
            var inlineObject2 = new InlineObject2(); // InlineObject2 |  (optional) 

            try {
                // Create a Image 2 Product by its id
                apiInstance.uploadImage2(id, inlineObject2);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductsRestControllerApi.uploadImage2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProductsRestControllerApi();
$id = 56; // Integer | id of Product to be searched
$inlineObject2 = ; // InlineObject2 | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProductsRestControllerApi->new();
my $id = 56; # Integer | id of Product to be searched
my $inlineObject2 = WWW::OPenAPIClient::Object::InlineObject2->new(); # InlineObject2 | 

eval {
    $api_instance->uploadImage2(id => $id, inlineObject2 => $inlineObject2);
};
if ($@) {
    warn "Exception when calling ProductsRestControllerApi->uploadImage2: $@\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.ProductsRestControllerApi()
id = 56 # Integer | id of Product to be searched (default to null)
inlineObject2 =  # InlineObject2 |  (optional)

try:
    # Create a Image 2 Product by its id
    api_instance.upload_image2(id, inlineObject2=inlineObject2)
except ApiException as e:
    print("Exception when calling ProductsRestControllerApi->uploadImage2: %s\n" % e)

extern crate ProductsRestControllerApi;

pub fn main() {
    let id = 56; // Integer
    let inlineObject2 = ; // InlineObject2

    let mut context = ProductsRestControllerApi::Context::default();
    let result = client.uploadImage2(id, inlineObject2, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        Integer id = 56; // Integer | id of Product to be searched
        InlineObject1 inlineObject1 = ; // InlineObject1 | 

        try {
            apiInstance.uploadImage3(id, inlineObject1);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#uploadImage3");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ProductsRestControllerApi;

public class ProductsRestControllerApiExample {
    public static void main(String[] args) {
        ProductsRestControllerApi apiInstance = new ProductsRestControllerApi();
        Integer id = 56; // Integer | id of Product to be searched
        InlineObject1 inlineObject1 = ; // InlineObject1 | 

        try {
            apiInstance.uploadImage3(id, inlineObject1);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsRestControllerApi#uploadImage3");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ProductsRestControllerApi *apiInstance = [[ProductsRestControllerApi alloc] init];
Integer *id = 56; // id of Product to be searched (default to null)
InlineObject1 *inlineObject1 = ; //  (optional)

// Create a Image 3 Product by its id
[apiInstance uploadImage3With:id
    inlineObject1:inlineObject1
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ProductsRestControllerApi()
var id = 56; // {Integer} id of Product to be searched
var opts = {
  'inlineObject1':  // {InlineObject1} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProductsRestControllerApi();
            var id = 56;  // Integer | id of Product to be searched (default to null)
            var inlineObject1 = new InlineObject1(); // InlineObject1 |  (optional) 

            try {
                // Create a Image 3 Product by its id
                apiInstance.uploadImage3(id, inlineObject1);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductsRestControllerApi.uploadImage3: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProductsRestControllerApi();
$id = 56; // Integer | id of Product to be searched
$inlineObject1 = ; // InlineObject1 | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProductsRestControllerApi->new();
my $id = 56; # Integer | id of Product to be searched
my $inlineObject1 = WWW::OPenAPIClient::Object::InlineObject1->new(); # InlineObject1 | 

eval {
    $api_instance->uploadImage3(id => $id, inlineObject1 => $inlineObject1);
};
if ($@) {
    warn "Exception when calling ProductsRestControllerApi->uploadImage3: $@\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.ProductsRestControllerApi()
id = 56 # Integer | id of Product to be searched (default to null)
inlineObject1 =  # InlineObject1 |  (optional)

try:
    # Create a Image 3 Product by its id
    api_instance.upload_image3(id, inlineObject1=inlineObject1)
except ApiException as e:
    print("Exception when calling ProductsRestControllerApi->uploadImage3: %s\n" % e)

extern crate ProductsRestControllerApi;

pub fn main() {
    let id = 56; // Integer
    let inlineObject1 = ; // InlineObject1

    let mut context = ProductsRestControllerApi::Context::default();
    let result = client.uploadImage3(id, inlineObject1, &context).wait();

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

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

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

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

        // Create an instance of the API class
        UserRestControlerApi apiInstance = new UserRestControlerApi();
        Integer id = 56; // Integer | id of user to be searched

        try {
            apiInstance.deleteUser(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControlerApi#deleteUser");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.UserRestControlerApi;

public class UserRestControlerApiExample {
    public static void main(String[] args) {
        UserRestControlerApi apiInstance = new UserRestControlerApi();
        Integer id = 56; // Integer | id of user to be searched

        try {
            apiInstance.deleteUser(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControlerApi#deleteUser");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
UserRestControlerApi *apiInstance = [[UserRestControlerApi alloc] init];
Integer *id = 56; // id of user to be searched (default to null)

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControlerApi()
var id = 56; // {Integer} id of user to be searched

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControlerApi();
            var id = 56;  // Integer | id of user to be searched (default to null)

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControlerApi();
$id = 56; // Integer | id of user to be searched

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControlerApi->new();
my $id = 56; # Integer | id of user to be searched

eval {
    $api_instance->deleteUser(id => $id);
};
if ($@) {
    warn "Exception when calling UserRestControlerApi->deleteUser: $@\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.UserRestControlerApi()
id = 56 # Integer | id of user to be searched (default to null)

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

extern crate UserRestControlerApi;

pub fn main() {
    let id = 56; // Integer

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

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

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

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

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

        // Create an instance of the API class
        UserRestControlerApi apiInstance = new UserRestControlerApi();
        Integer id = 56; // Integer | id of user to be searched

        try {
            apiInstance.getImageProfile(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControlerApi#getImageProfile");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.UserRestControlerApi;

public class UserRestControlerApiExample {
    public static void main(String[] args) {
        UserRestControlerApi apiInstance = new UserRestControlerApi();
        Integer id = 56; // Integer | id of user to be searched

        try {
            apiInstance.getImageProfile(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControlerApi#getImageProfile");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
UserRestControlerApi *apiInstance = [[UserRestControlerApi alloc] init];
Integer *id = 56; // id of user to be searched (default to null)

// Get a profile image user by id
[apiInstance getImageProfileWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControlerApi()
var id = 56; // {Integer} id of user to be searched

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControlerApi();
            var id = 56;  // Integer | id of user to be searched (default to null)

            try {
                // Get a profile image user by id
                apiInstance.getImageProfile(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControlerApi.getImageProfile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControlerApi();
$id = 56; // Integer | id of user to be searched

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControlerApi->new();
my $id = 56; # Integer | id of user to be searched

eval {
    $api_instance->getImageProfile(id => $id);
};
if ($@) {
    warn "Exception when calling UserRestControlerApi->getImageProfile: $@\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.UserRestControlerApi()
id = 56 # Integer | id of user to be searched (default to null)

try:
    # Get a profile image user by id
    api_instance.get_image_profile(id)
except ApiException as e:
    print("Exception when calling UserRestControlerApi->getImageProfile: %s\n" % e)

extern crate UserRestControlerApi;

pub fn main() {
    let id = 56; // Integer

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

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

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

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

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

        // Create an instance of the API class
        UserRestControlerApi apiInstance = new UserRestControlerApi();
        Integer id = 56; // Integer | id of user to be searched
        String page = page_example; // String | page

        try {
            apiInstance.getOrdersUsers(id, page);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControlerApi#getOrdersUsers");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.UserRestControlerApi;

public class UserRestControlerApiExample {
    public static void main(String[] args) {
        UserRestControlerApi apiInstance = new UserRestControlerApi();
        Integer id = 56; // Integer | id of user to be searched
        String page = page_example; // String | page

        try {
            apiInstance.getOrdersUsers(id, page);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControlerApi#getOrdersUsers");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
UserRestControlerApi *apiInstance = [[UserRestControlerApi alloc] init];
Integer *id = 56; // id of user to be searched (default to null)
String *page = page_example; // page (optional) (default to null)

// Get ordes by iduser
[apiInstance getOrdersUsersWith:id
    page:page
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControlerApi()
var id = 56; // {Integer} id of user to be searched
var opts = {
  'page': page_example // {String} page
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControlerApi();
            var id = 56;  // Integer | id of user to be searched (default to null)
            var page = page_example;  // String | page (optional)  (default to null)

            try {
                // Get ordes by iduser
                apiInstance.getOrdersUsers(id, page);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControlerApi.getOrdersUsers: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControlerApi();
$id = 56; // Integer | id of user to be searched
$page = page_example; // String | page

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControlerApi->new();
my $id = 56; # Integer | id of user to be searched
my $page = page_example; # String | page

eval {
    $api_instance->getOrdersUsers(id => $id, page => $page);
};
if ($@) {
    warn "Exception when calling UserRestControlerApi->getOrdersUsers: $@\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.UserRestControlerApi()
id = 56 # Integer | id of user to be searched (default to null)
page = page_example # String | page (optional) (default to null)

try:
    # Get ordes by iduser
    api_instance.get_orders_users(id, page=page)
except ApiException as e:
    print("Exception when calling UserRestControlerApi->getOrdersUsers: %s\n" % e)

extern crate UserRestControlerApi;

pub fn main() {
    let id = 56; // Integer
    let page = page_example; // String

    let mut context = UserRestControlerApi::Context::default();
    let result = client.getOrdersUsers(id, page, &context).wait();

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

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

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

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

        // Create an instance of the API class
        UserRestControlerApi apiInstance = new UserRestControlerApi();
        Integer id = 56; // Integer | id of user to be searched

        try {
            apiInstance.getUsersById(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControlerApi#getUsersById");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.UserRestControlerApi;

public class UserRestControlerApiExample {
    public static void main(String[] args) {
        UserRestControlerApi apiInstance = new UserRestControlerApi();
        Integer id = 56; // Integer | id of user to be searched

        try {
            apiInstance.getUsersById(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControlerApi#getUsersById");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
UserRestControlerApi *apiInstance = [[UserRestControlerApi alloc] init];
Integer *id = 56; // id of user to be searched (default to null)

// Get a user by its id
[apiInstance getUsersByIdWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControlerApi()
var id = 56; // {Integer} id of user to be searched

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControlerApi();
            var id = 56;  // Integer | id of user to be searched (default to null)

            try {
                // Get a user by its id
                apiInstance.getUsersById(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControlerApi.getUsersById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControlerApi();
$id = 56; // Integer | id of user to be searched

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControlerApi->new();
my $id = 56; # Integer | id of user to be searched

eval {
    $api_instance->getUsersById(id => $id);
};
if ($@) {
    warn "Exception when calling UserRestControlerApi->getUsersById: $@\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.UserRestControlerApi()
id = 56 # Integer | id of user to be searched (default to null)

try:
    # Get a user by its id
    api_instance.get_users_by_id(id)
except ApiException as e:
    print("Exception when calling UserRestControlerApi->getUsersById: %s\n" % e)

extern crate UserRestControlerApi;

pub fn main() {
    let id = 56; // Integer

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

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

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

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

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

        // Create an instance of the API class
        UserRestControlerApi apiInstance = new UserRestControlerApi();
        Integer id = 56; // Integer | id of user to be searched
        array[Product_Detailed] productDetailed = ; // array[Product_Detailed] | 

        try {
            apiInstance.orderUser(id, productDetailed);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControlerApi#orderUser");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.UserRestControlerApi;

public class UserRestControlerApiExample {
    public static void main(String[] args) {
        UserRestControlerApi apiInstance = new UserRestControlerApi();
        Integer id = 56; // Integer | id of user to be searched
        array[Product_Detailed] productDetailed = ; // array[Product_Detailed] | 

        try {
            apiInstance.orderUser(id, productDetailed);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControlerApi#orderUser");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
UserRestControlerApi *apiInstance = [[UserRestControlerApi alloc] init];
Integer *id = 56; // id of user to be searched (default to null)
array[Product_Detailed] *productDetailed = ; // 

// Create a order
[apiInstance orderUserWith:id
    productDetailed:productDetailed
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControlerApi()
var id = 56; // {Integer} id of user to be searched
var productDetailed = ; // {array[Product_Detailed]} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControlerApi();
            var id = 56;  // Integer | id of user to be searched (default to null)
            var productDetailed = new array[Product_Detailed](); // array[Product_Detailed] | 

            try {
                // Create a order
                apiInstance.orderUser(id, productDetailed);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControlerApi.orderUser: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControlerApi();
$id = 56; // Integer | id of user to be searched
$productDetailed = ; // array[Product_Detailed] | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControlerApi->new();
my $id = 56; # Integer | id of user to be searched
my $productDetailed = [WWW::OPenAPIClient::Object::array[Product_Detailed]->new()]; # array[Product_Detailed] | 

eval {
    $api_instance->orderUser(id => $id, productDetailed => $productDetailed);
};
if ($@) {
    warn "Exception when calling UserRestControlerApi->orderUser: $@\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.UserRestControlerApi()
id = 56 # Integer | id of user to be searched (default to null)
productDetailed =  # array[Product_Detailed] | 

try:
    # Create a order
    api_instance.order_user(id, productDetailed)
except ApiException as e:
    print("Exception when calling UserRestControlerApi->orderUser: %s\n" % e)

extern crate UserRestControlerApi;

pub fn main() {
    let id = 56; // Integer
    let productDetailed = ; // array[Product_Detailed]

    let mut context = UserRestControlerApi::Context::default();
    let result = client.orderUser(id, productDetailed, &context).wait();

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

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

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

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

        // Create an instance of the API class
        UserRestControlerApi apiInstance = new UserRestControlerApi();
        UserDetailed userDetailed = ; // UserDetailed | 

        try {
            apiInstance.registerUser(userDetailed);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControlerApi#registerUser");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.UserRestControlerApi;

public class UserRestControlerApiExample {
    public static void main(String[] args) {
        UserRestControlerApi apiInstance = new UserRestControlerApi();
        UserDetailed userDetailed = ; // UserDetailed | 

        try {
            apiInstance.registerUser(userDetailed);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControlerApi#registerUser");
            e.printStackTrace();
        }
    }
}

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

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControlerApi()
var userDetailed = ; // {UserDetailed} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControlerApi();
            var userDetailed = new UserDetailed(); // UserDetailed | 

            try {
                // Create a user
                apiInstance.registerUser(userDetailed);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControlerApi.registerUser: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControlerApi();
$userDetailed = ; // UserDetailed | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControlerApi->new();
my $userDetailed = WWW::OPenAPIClient::Object::UserDetailed->new(); # UserDetailed | 

eval {
    $api_instance->registerUser(userDetailed => $userDetailed);
};
if ($@) {
    warn "Exception when calling UserRestControlerApi->registerUser: $@\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.UserRestControlerApi()
userDetailed =  # UserDetailed | 

try:
    # Create a user
    api_instance.register_user(userDetailed)
except ApiException as e:
    print("Exception when calling UserRestControlerApi->registerUser: %s\n" % e)

extern crate UserRestControlerApi;

pub fn main() {
    let userDetailed = ; // UserDetailed

    let mut context = UserRestControlerApi::Context::default();
    let result = client.registerUser(userDetailed, &context).wait();

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

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

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

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

        // Create an instance of the API class
        UserRestControlerApi apiInstance = new UserRestControlerApi();
        Integer id = 56; // Integer | id of user to be searched
        UserDetailed userDetailed = ; // UserDetailed | 

        try {
            apiInstance.replaceUser(id, userDetailed);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControlerApi#replaceUser");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.UserRestControlerApi;

public class UserRestControlerApiExample {
    public static void main(String[] args) {
        UserRestControlerApi apiInstance = new UserRestControlerApi();
        Integer id = 56; // Integer | id of user to be searched
        UserDetailed userDetailed = ; // UserDetailed | 

        try {
            apiInstance.replaceUser(id, userDetailed);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControlerApi#replaceUser");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
UserRestControlerApi *apiInstance = [[UserRestControlerApi alloc] init];
Integer *id = 56; // id of user to be searched (default to null)
UserDetailed *userDetailed = ; // 

// Modify a user
[apiInstance replaceUserWith:id
    userDetailed:userDetailed
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControlerApi()
var id = 56; // {Integer} id of user to be searched
var userDetailed = ; // {UserDetailed} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControlerApi();
            var id = 56;  // Integer | id of user to be searched (default to null)
            var userDetailed = new UserDetailed(); // UserDetailed | 

            try {
                // Modify a user
                apiInstance.replaceUser(id, userDetailed);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControlerApi.replaceUser: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControlerApi();
$id = 56; // Integer | id of user to be searched
$userDetailed = ; // UserDetailed | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControlerApi->new();
my $id = 56; # Integer | id of user to be searched
my $userDetailed = WWW::OPenAPIClient::Object::UserDetailed->new(); # UserDetailed | 

eval {
    $api_instance->replaceUser(id => $id, userDetailed => $userDetailed);
};
if ($@) {
    warn "Exception when calling UserRestControlerApi->replaceUser: $@\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.UserRestControlerApi()
id = 56 # Integer | id of user to be searched (default to null)
userDetailed =  # UserDetailed | 

try:
    # Modify a user
    api_instance.replace_user(id, userDetailed)
except ApiException as e:
    print("Exception when calling UserRestControlerApi->replaceUser: %s\n" % e)

extern crate UserRestControlerApi;

pub fn main() {
    let id = 56; // Integer
    let userDetailed = ; // UserDetailed

    let mut context = UserRestControlerApi::Context::default();
    let result = client.replaceUser(id, userDetailed, &context).wait();

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

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

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

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

        // Create an instance of the API class
        UserRestControlerApi apiInstance = new UserRestControlerApi();
        Integer id = 56; // Integer | id of user to be searched
        InlineObject inlineObject = ; // InlineObject | 

        try {
            apiInstance.uploadImageProfile(id, inlineObject);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControlerApi#uploadImageProfile");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.UserRestControlerApi;

public class UserRestControlerApiExample {
    public static void main(String[] args) {
        UserRestControlerApi apiInstance = new UserRestControlerApi();
        Integer id = 56; // Integer | id of user to be searched
        InlineObject inlineObject = ; // InlineObject | 

        try {
            apiInstance.uploadImageProfile(id, inlineObject);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControlerApi#uploadImageProfile");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
UserRestControlerApi *apiInstance = [[UserRestControlerApi alloc] init];
Integer *id = 56; // id of user to be searched (default to null)
InlineObject *inlineObject = ; //  (optional)

// create a profile image user by id
[apiInstance uploadImageProfileWith:id
    inlineObject:inlineObject
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControlerApi()
var id = 56; // {Integer} id of user to be searched
var opts = {
  'inlineObject':  // {InlineObject} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControlerApi();
            var id = 56;  // Integer | id of user to be searched (default to null)
            var inlineObject = new InlineObject(); // InlineObject |  (optional) 

            try {
                // create a profile image user by id
                apiInstance.uploadImageProfile(id, inlineObject);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControlerApi.uploadImageProfile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControlerApi();
$id = 56; // Integer | id of user to be searched
$inlineObject = ; // InlineObject | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControlerApi->new();
my $id = 56; # Integer | id of user to be searched
my $inlineObject = WWW::OPenAPIClient::Object::InlineObject->new(); # InlineObject | 

eval {
    $api_instance->uploadImageProfile(id => $id, inlineObject => $inlineObject);
};
if ($@) {
    warn "Exception when calling UserRestControlerApi->uploadImageProfile: $@\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.UserRestControlerApi()
id = 56 # Integer | id of user to be searched (default to null)
inlineObject =  # InlineObject |  (optional)

try:
    # create a profile image user by id
    api_instance.upload_image_profile(id, inlineObject=inlineObject)
except ApiException as e:
    print("Exception when calling UserRestControlerApi->uploadImageProfile: %s\n" % e)

extern crate UserRestControlerApi;

pub fn main() {
    let id = 56; // Integer
    let inlineObject = ; // InlineObject

    let mut context = UserRestControlerApi::Context::default();
    let result = client.uploadImageProfile(id, inlineObject, &context).wait();

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