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

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

public class ErrorServiceImplApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        ErrorServiceImplApi apiInstance = new ErrorServiceImplApi();
        String code = code_example; // String | 

        try {
            PayloadDtoErrorDto result = apiInstance.errorErrorByCodeGet(code);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ErrorServiceImplApi#errorErrorByCodeGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String code = new String(); // String | 

try {
    final result = await api_instance.errorErrorByCodeGet(code);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->errorErrorByCodeGet: $e\n');
}

import org.openapitools.client.api.ErrorServiceImplApi;

public class ErrorServiceImplApiExample {
    public static void main(String[] args) {
        ErrorServiceImplApi apiInstance = new ErrorServiceImplApi();
        String code = code_example; // String | 

        try {
            PayloadDtoErrorDto result = apiInstance.errorErrorByCodeGet(code);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ErrorServiceImplApi#errorErrorByCodeGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ErrorServiceImplApi *apiInstance = [[ErrorServiceImplApi alloc] init];
String *code = code_example; //  (optional) (default to null)

[apiInstance errorErrorByCodeGetWith:code
              completionHandler: ^(PayloadDtoErrorDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.ErrorServiceImplApi()
var opts = {
  'code': code_example // {String} 
};

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

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

namespace Example
{
    public class errorErrorByCodeGetExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new ErrorServiceImplApi();
            var code = code_example;  // String |  (optional)  (default to null)

            try {
                PayloadDtoErrorDto result = apiInstance.errorErrorByCodeGet(code);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ErrorServiceImplApi.errorErrorByCodeGet: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ErrorServiceImplApi();
$code = code_example; // String | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ErrorServiceImplApi->new();
my $code = code_example; # String | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ErrorServiceImplApi()
code = code_example # String |  (optional) (default to null)

try:
    api_response = api_instance.error_error_by_code_get(code=code)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ErrorServiceImplApi->errorErrorByCodeGet: %s\n" % e)

extern crate ErrorServiceImplApi;

pub fn main() {
    let code = code_example; // String

    let mut context = ErrorServiceImplApi::Context::default();
    let result = client.errorErrorByCodeGet(code, &context).wait();

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

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

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

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

        // Create an instance of the API class
        RestAuthenticationServiceApi apiInstance = new RestAuthenticationServiceApi();
        AuthenticationRequestDto authenticationRequestDto = ; // AuthenticationRequestDto | 

        try {
            PayloadDtoAuthenticationResponseDto result = apiInstance.v1AuthenticatePost(authenticationRequestDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestAuthenticationServiceApi#v1AuthenticatePost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AuthenticationRequestDto authenticationRequestDto = new AuthenticationRequestDto(); // AuthenticationRequestDto | 

try {
    final result = await api_instance.v1AuthenticatePost(authenticationRequestDto);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1AuthenticatePost: $e\n');
}

import org.openapitools.client.api.RestAuthenticationServiceApi;

public class RestAuthenticationServiceApiExample {
    public static void main(String[] args) {
        RestAuthenticationServiceApi apiInstance = new RestAuthenticationServiceApi();
        AuthenticationRequestDto authenticationRequestDto = ; // AuthenticationRequestDto | 

        try {
            PayloadDtoAuthenticationResponseDto result = apiInstance.v1AuthenticatePost(authenticationRequestDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestAuthenticationServiceApi#v1AuthenticatePost");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
RestAuthenticationServiceApi *apiInstance = [[RestAuthenticationServiceApi alloc] init];
AuthenticationRequestDto *authenticationRequestDto = ; //  (optional)

[apiInstance v1AuthenticatePostWith:authenticationRequestDto
              completionHandler: ^(PayloadDtoAuthenticationResponseDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestAuthenticationServiceApi()
var opts = {
  'authenticationRequestDto':  // {AuthenticationRequestDto} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new RestAuthenticationServiceApi();
            var authenticationRequestDto = new AuthenticationRequestDto(); // AuthenticationRequestDto |  (optional) 

            try {
                PayloadDtoAuthenticationResponseDto result = apiInstance.v1AuthenticatePost(authenticationRequestDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestAuthenticationServiceApi.v1AuthenticatePost: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestAuthenticationServiceApi();
$authenticationRequestDto = ; // AuthenticationRequestDto | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestAuthenticationServiceApi->new();
my $authenticationRequestDto = WWW::OPenAPIClient::Object::AuthenticationRequestDto->new(); # AuthenticationRequestDto | 

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

try:
    api_response = api_instance.v1_authenticate_post(authenticationRequestDto=authenticationRequestDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestAuthenticationServiceApi->v1AuthenticatePost: %s\n" % e)

extern crate RestAuthenticationServiceApi;

pub fn main() {
    let authenticationRequestDto = ; // AuthenticationRequestDto

    let mut context = RestAuthenticationServiceApi::Context::default();
    let result = client.v1AuthenticatePost(authenticationRequestDto, &context).wait();

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

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

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

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

        // Create an instance of the API class
        RestAuthenticationServiceApi apiInstance = new RestAuthenticationServiceApi();
        RefreshRequestDto refreshRequestDto = ; // RefreshRequestDto | 

        try {
            PayloadDtoRefreshResponseDto result = apiInstance.v1RefreshPost(refreshRequestDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestAuthenticationServiceApi#v1RefreshPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final RefreshRequestDto refreshRequestDto = new RefreshRequestDto(); // RefreshRequestDto | 

try {
    final result = await api_instance.v1RefreshPost(refreshRequestDto);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1RefreshPost: $e\n');
}

import org.openapitools.client.api.RestAuthenticationServiceApi;

public class RestAuthenticationServiceApiExample {
    public static void main(String[] args) {
        RestAuthenticationServiceApi apiInstance = new RestAuthenticationServiceApi();
        RefreshRequestDto refreshRequestDto = ; // RefreshRequestDto | 

        try {
            PayloadDtoRefreshResponseDto result = apiInstance.v1RefreshPost(refreshRequestDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestAuthenticationServiceApi#v1RefreshPost");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
RestAuthenticationServiceApi *apiInstance = [[RestAuthenticationServiceApi alloc] init];
RefreshRequestDto *refreshRequestDto = ; //  (optional)

[apiInstance v1RefreshPostWith:refreshRequestDto
              completionHandler: ^(PayloadDtoRefreshResponseDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestAuthenticationServiceApi()
var opts = {
  'refreshRequestDto':  // {RefreshRequestDto} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new RestAuthenticationServiceApi();
            var refreshRequestDto = new RefreshRequestDto(); // RefreshRequestDto |  (optional) 

            try {
                PayloadDtoRefreshResponseDto result = apiInstance.v1RefreshPost(refreshRequestDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestAuthenticationServiceApi.v1RefreshPost: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestAuthenticationServiceApi();
$refreshRequestDto = ; // RefreshRequestDto | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestAuthenticationServiceApi->new();
my $refreshRequestDto = WWW::OPenAPIClient::Object::RefreshRequestDto->new(); # RefreshRequestDto | 

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

try:
    api_response = api_instance.v1_refresh_post(refreshRequestDto=refreshRequestDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestAuthenticationServiceApi->v1RefreshPost: %s\n" % e)

extern crate RestAuthenticationServiceApi;

pub fn main() {
    let refreshRequestDto = ; // RefreshRequestDto

    let mut context = RestAuthenticationServiceApi::Context::default();
    let result = client.v1RefreshPost(refreshRequestDto, &context).wait();

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

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

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

public class RestCashServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestCashServiceApi apiInstance = new RestCashServiceApi();
        date endDateFrom = 2013-10-20; // date | 
        date endDateTo = 2013-10-20; // date | 
        Integer firstResult = 56; // Integer | 
        String host = host_example; // String | 
        Integer maxResults = 56; // Integer | 
        date startDateFrom = 2013-10-20; // date | 
        date startDateTo = 2013-10-20; // date | 
        Integer zFrom = 56; // Integer | 

        try {
            PayloadDtoListClosedCashDto result = apiInstance.v1ClosedCashGet(endDateFrom, endDateTo, firstResult, host, maxResults, startDateFrom, startDateTo, zFrom);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCashServiceApi#v1ClosedCashGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final date endDateFrom = new date(); // date | 
final date endDateTo = new date(); // date | 
final Integer firstResult = new Integer(); // Integer | 
final String host = new String(); // String | 
final Integer maxResults = new Integer(); // Integer | 
final date startDateFrom = new date(); // date | 
final date startDateTo = new date(); // date | 
final Integer zFrom = new Integer(); // Integer | 

try {
    final result = await api_instance.v1ClosedCashGet(endDateFrom, endDateTo, firstResult, host, maxResults, startDateFrom, startDateTo, zFrom);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1ClosedCashGet: $e\n');
}

import org.openapitools.client.api.RestCashServiceApi;

public class RestCashServiceApiExample {
    public static void main(String[] args) {
        RestCashServiceApi apiInstance = new RestCashServiceApi();
        date endDateFrom = 2013-10-20; // date | 
        date endDateTo = 2013-10-20; // date | 
        Integer firstResult = 56; // Integer | 
        String host = host_example; // String | 
        Integer maxResults = 56; // Integer | 
        date startDateFrom = 2013-10-20; // date | 
        date startDateTo = 2013-10-20; // date | 
        Integer zFrom = 56; // Integer | 

        try {
            PayloadDtoListClosedCashDto result = apiInstance.v1ClosedCashGet(endDateFrom, endDateTo, firstResult, host, maxResults, startDateFrom, startDateTo, zFrom);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCashServiceApi#v1ClosedCashGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestCashServiceApi *apiInstance = [[RestCashServiceApi alloc] init];
date *endDateFrom = 2013-10-20; //  (optional) (default to null)
date *endDateTo = 2013-10-20; //  (optional) (default to null)
Integer *firstResult = 56; //  (optional) (default to null)
String *host = host_example; //  (optional) (default to null)
Integer *maxResults = 56; //  (optional) (default to null)
date *startDateFrom = 2013-10-20; //  (optional) (default to null)
date *startDateTo = 2013-10-20; //  (optional) (default to null)
Integer *zFrom = 56; //  (optional) (default to null)

[apiInstance v1ClosedCashGetWith:endDateFrom
    endDateTo:endDateTo
    firstResult:firstResult
    host:host
    maxResults:maxResults
    startDateFrom:startDateFrom
    startDateTo:startDateTo
    zFrom:zFrom
              completionHandler: ^(PayloadDtoListClosedCashDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestCashServiceApi()
var opts = {
  'endDateFrom': 2013-10-20, // {date} 
  'endDateTo': 2013-10-20, // {date} 
  'firstResult': 56, // {Integer} 
  'host': host_example, // {String} 
  'maxResults': 56, // {Integer} 
  'startDateFrom': 2013-10-20, // {date} 
  'startDateTo': 2013-10-20, // {date} 
  'zFrom': 56 // {Integer} 
};

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

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

namespace Example
{
    public class v1ClosedCashGetExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestCashServiceApi();
            var endDateFrom = 2013-10-20;  // date |  (optional)  (default to null)
            var endDateTo = 2013-10-20;  // date |  (optional)  (default to null)
            var firstResult = 56;  // Integer |  (optional)  (default to null)
            var host = host_example;  // String |  (optional)  (default to null)
            var maxResults = 56;  // Integer |  (optional)  (default to null)
            var startDateFrom = 2013-10-20;  // date |  (optional)  (default to null)
            var startDateTo = 2013-10-20;  // date |  (optional)  (default to null)
            var zFrom = 56;  // Integer |  (optional)  (default to null)

            try {
                PayloadDtoListClosedCashDto result = apiInstance.v1ClosedCashGet(endDateFrom, endDateTo, firstResult, host, maxResults, startDateFrom, startDateTo, zFrom);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestCashServiceApi.v1ClosedCashGet: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestCashServiceApi();
$endDateFrom = 2013-10-20; // date | 
$endDateTo = 2013-10-20; // date | 
$firstResult = 56; // Integer | 
$host = host_example; // String | 
$maxResults = 56; // Integer | 
$startDateFrom = 2013-10-20; // date | 
$startDateTo = 2013-10-20; // date | 
$zFrom = 56; // Integer | 

try {
    $result = $api_instance->v1ClosedCashGet($endDateFrom, $endDateTo, $firstResult, $host, $maxResults, $startDateFrom, $startDateTo, $zFrom);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RestCashServiceApi->v1ClosedCashGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestCashServiceApi->new();
my $endDateFrom = 2013-10-20; # date | 
my $endDateTo = 2013-10-20; # date | 
my $firstResult = 56; # Integer | 
my $host = host_example; # String | 
my $maxResults = 56; # Integer | 
my $startDateFrom = 2013-10-20; # date | 
my $startDateTo = 2013-10-20; # date | 
my $zFrom = 56; # Integer | 

eval {
    my $result = $api_instance->v1ClosedCashGet(endDateFrom => $endDateFrom, endDateTo => $endDateTo, firstResult => $firstResult, host => $host, maxResults => $maxResults, startDateFrom => $startDateFrom, startDateTo => $startDateTo, zFrom => $zFrom);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestCashServiceApi->v1ClosedCashGet: $@\n";
}

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestCashServiceApi()
endDateFrom = 2013-10-20 # date |  (optional) (default to null)
endDateTo = 2013-10-20 # date |  (optional) (default to null)
firstResult = 56 # Integer |  (optional) (default to null)
host = host_example # String |  (optional) (default to null)
maxResults = 56 # Integer |  (optional) (default to null)
startDateFrom = 2013-10-20 # date |  (optional) (default to null)
startDateTo = 2013-10-20 # date |  (optional) (default to null)
zFrom = 56 # Integer |  (optional) (default to null)

try:
    api_response = api_instance.v1_closed_cash_get(endDateFrom=endDateFrom, endDateTo=endDateTo, firstResult=firstResult, host=host, maxResults=maxResults, startDateFrom=startDateFrom, startDateTo=startDateTo, zFrom=zFrom)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestCashServiceApi->v1ClosedCashGet: %s\n" % e)

extern crate RestCashServiceApi;

pub fn main() {
    let endDateFrom = 2013-10-20; // date
    let endDateTo = 2013-10-20; // date
    let firstResult = 56; // Integer
    let host = host_example; // String
    let maxResults = 56; // Integer
    let startDateFrom = 2013-10-20; // date
    let startDateTo = 2013-10-20; // date
    let zFrom = 56; // Integer

    let mut context = RestCashServiceApi::Context::default();
    let result = client.v1ClosedCashGet(endDateFrom, endDateTo, firstResult, host, maxResults, startDateFrom, startDateTo, zFrom, &context).wait();

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

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

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

public class RestCustomerServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestCustomerServiceApi apiInstance = new RestCustomerServiceApi();
        String customerId = customerId_example; // String | 
        Integer firstResult = 56; // Integer | 
        Integer maxResults = 56; // Integer | 
        String perceptionId = perceptionId_example; // String | 

        try {
            PayloadDtoListCustomerPerceptionDto result = apiInstance.v1CustomerPerceptionsGet(customerId, firstResult, maxResults, perceptionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCustomerServiceApi#v1CustomerPerceptionsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String customerId = new String(); // String | 
final Integer firstResult = new Integer(); // Integer | 
final Integer maxResults = new Integer(); // Integer | 
final String perceptionId = new String(); // String | 

try {
    final result = await api_instance.v1CustomerPerceptionsGet(customerId, firstResult, maxResults, perceptionId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CustomerPerceptionsGet: $e\n');
}

import org.openapitools.client.api.RestCustomerServiceApi;

public class RestCustomerServiceApiExample {
    public static void main(String[] args) {
        RestCustomerServiceApi apiInstance = new RestCustomerServiceApi();
        String customerId = customerId_example; // String | 
        Integer firstResult = 56; // Integer | 
        Integer maxResults = 56; // Integer | 
        String perceptionId = perceptionId_example; // String | 

        try {
            PayloadDtoListCustomerPerceptionDto result = apiInstance.v1CustomerPerceptionsGet(customerId, firstResult, maxResults, perceptionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCustomerServiceApi#v1CustomerPerceptionsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestCustomerServiceApi *apiInstance = [[RestCustomerServiceApi alloc] init];
String *customerId = customerId_example; //  (optional) (default to null)
Integer *firstResult = 56; //  (optional) (default to null)
Integer *maxResults = 56; //  (optional) (default to null)
String *perceptionId = perceptionId_example; //  (optional) (default to null)

[apiInstance v1CustomerPerceptionsGetWith:customerId
    firstResult:firstResult
    maxResults:maxResults
    perceptionId:perceptionId
              completionHandler: ^(PayloadDtoListCustomerPerceptionDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestCustomerServiceApi()
var opts = {
  'customerId': customerId_example, // {String} 
  'firstResult': 56, // {Integer} 
  'maxResults': 56, // {Integer} 
  'perceptionId': perceptionId_example // {String} 
};

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

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

namespace Example
{
    public class v1CustomerPerceptionsGetExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestCustomerServiceApi();
            var customerId = customerId_example;  // String |  (optional)  (default to null)
            var firstResult = 56;  // Integer |  (optional)  (default to null)
            var maxResults = 56;  // Integer |  (optional)  (default to null)
            var perceptionId = perceptionId_example;  // String |  (optional)  (default to null)

            try {
                PayloadDtoListCustomerPerceptionDto result = apiInstance.v1CustomerPerceptionsGet(customerId, firstResult, maxResults, perceptionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestCustomerServiceApi.v1CustomerPerceptionsGet: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestCustomerServiceApi();
$customerId = customerId_example; // String | 
$firstResult = 56; // Integer | 
$maxResults = 56; // Integer | 
$perceptionId = perceptionId_example; // String | 

try {
    $result = $api_instance->v1CustomerPerceptionsGet($customerId, $firstResult, $maxResults, $perceptionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RestCustomerServiceApi->v1CustomerPerceptionsGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestCustomerServiceApi->new();
my $customerId = customerId_example; # String | 
my $firstResult = 56; # Integer | 
my $maxResults = 56; # Integer | 
my $perceptionId = perceptionId_example; # String | 

eval {
    my $result = $api_instance->v1CustomerPerceptionsGet(customerId => $customerId, firstResult => $firstResult, maxResults => $maxResults, perceptionId => $perceptionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestCustomerServiceApi->v1CustomerPerceptionsGet: $@\n";
}

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestCustomerServiceApi()
customerId = customerId_example # String |  (optional) (default to null)
firstResult = 56 # Integer |  (optional) (default to null)
maxResults = 56 # Integer |  (optional) (default to null)
perceptionId = perceptionId_example # String |  (optional) (default to null)

try:
    api_response = api_instance.v1_customer_perceptions_get(customerId=customerId, firstResult=firstResult, maxResults=maxResults, perceptionId=perceptionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestCustomerServiceApi->v1CustomerPerceptionsGet: %s\n" % e)

extern crate RestCustomerServiceApi;

pub fn main() {
    let customerId = customerId_example; // String
    let firstResult = 56; // Integer
    let maxResults = 56; // Integer
    let perceptionId = perceptionId_example; // String

    let mut context = RestCustomerServiceApi::Context::default();
    let result = client.v1CustomerPerceptionsGet(customerId, firstResult, maxResults, perceptionId, &context).wait();

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

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

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

public class RestCustomerServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestCustomerServiceApi apiInstance = new RestCustomerServiceApi();
        array[CustomerPerceptionDto] customerPerceptionDto = ; // array[CustomerPerceptionDto] | 

        try {
            PayloadDtoVoid result = apiInstance.v1CustomerPerceptionsPost(customerPerceptionDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCustomerServiceApi#v1CustomerPerceptionsPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[CustomerPerceptionDto] customerPerceptionDto = new array[CustomerPerceptionDto](); // array[CustomerPerceptionDto] | 

try {
    final result = await api_instance.v1CustomerPerceptionsPost(customerPerceptionDto);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CustomerPerceptionsPost: $e\n');
}

import org.openapitools.client.api.RestCustomerServiceApi;

public class RestCustomerServiceApiExample {
    public static void main(String[] args) {
        RestCustomerServiceApi apiInstance = new RestCustomerServiceApi();
        array[CustomerPerceptionDto] customerPerceptionDto = ; // array[CustomerPerceptionDto] | 

        try {
            PayloadDtoVoid result = apiInstance.v1CustomerPerceptionsPost(customerPerceptionDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCustomerServiceApi#v1CustomerPerceptionsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestCustomerServiceApi *apiInstance = [[RestCustomerServiceApi alloc] init];
array[CustomerPerceptionDto] *customerPerceptionDto = ; //  (optional)

[apiInstance v1CustomerPerceptionsPostWith:customerPerceptionDto
              completionHandler: ^(PayloadDtoVoid output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestCustomerServiceApi()
var opts = {
  'customerPerceptionDto':  // {array[CustomerPerceptionDto]} 
};

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

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

namespace Example
{
    public class v1CustomerPerceptionsPostExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestCustomerServiceApi();
            var customerPerceptionDto = new array[CustomerPerceptionDto](); // array[CustomerPerceptionDto] |  (optional) 

            try {
                PayloadDtoVoid result = apiInstance.v1CustomerPerceptionsPost(customerPerceptionDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestCustomerServiceApi.v1CustomerPerceptionsPost: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestCustomerServiceApi();
$customerPerceptionDto = ; // array[CustomerPerceptionDto] | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestCustomerServiceApi->new();
my $customerPerceptionDto = [WWW::OPenAPIClient::Object::array[CustomerPerceptionDto]->new()]; # array[CustomerPerceptionDto] | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestCustomerServiceApi()
customerPerceptionDto =  # array[CustomerPerceptionDto] |  (optional)

try:
    api_response = api_instance.v1_customer_perceptions_post(customerPerceptionDto=customerPerceptionDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestCustomerServiceApi->v1CustomerPerceptionsPost: %s\n" % e)

extern crate RestCustomerServiceApi;

pub fn main() {
    let customerPerceptionDto = ; // array[CustomerPerceptionDto]

    let mut context = RestCustomerServiceApi::Context::default();
    let result = client.v1CustomerPerceptionsPost(customerPerceptionDto, &context).wait();

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

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

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

public class RestCustomerServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestCustomerServiceApi apiInstance = new RestCustomerServiceApi();
        Integer firstResult = 56; // Integer | 
        String id = id_example; // String | 
        Boolean isCustomer = true; // Boolean | 
        Integer maxResults = 56; // Integer | 
        String personTypeId = personTypeId_example; // String | 
        String searchKey = searchKey_example; // String | 
        String taxId = taxId_example; // String | 

        try {
            PayloadDtoListCustomerDto result = apiInstance.v1CustomersGet(firstResult, id, isCustomer, maxResults, personTypeId, searchKey, taxId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCustomerServiceApi#v1CustomersGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer firstResult = new Integer(); // Integer | 
final String id = new String(); // String | 
final Boolean isCustomer = new Boolean(); // Boolean | 
final Integer maxResults = new Integer(); // Integer | 
final String personTypeId = new String(); // String | 
final String searchKey = new String(); // String | 
final String taxId = new String(); // String | 

try {
    final result = await api_instance.v1CustomersGet(firstResult, id, isCustomer, maxResults, personTypeId, searchKey, taxId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CustomersGet: $e\n');
}

import org.openapitools.client.api.RestCustomerServiceApi;

public class RestCustomerServiceApiExample {
    public static void main(String[] args) {
        RestCustomerServiceApi apiInstance = new RestCustomerServiceApi();
        Integer firstResult = 56; // Integer | 
        String id = id_example; // String | 
        Boolean isCustomer = true; // Boolean | 
        Integer maxResults = 56; // Integer | 
        String personTypeId = personTypeId_example; // String | 
        String searchKey = searchKey_example; // String | 
        String taxId = taxId_example; // String | 

        try {
            PayloadDtoListCustomerDto result = apiInstance.v1CustomersGet(firstResult, id, isCustomer, maxResults, personTypeId, searchKey, taxId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCustomerServiceApi#v1CustomersGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestCustomerServiceApi *apiInstance = [[RestCustomerServiceApi alloc] init];
Integer *firstResult = 56; //  (optional) (default to null)
String *id = id_example; //  (optional) (default to null)
Boolean *isCustomer = true; //  (optional) (default to null)
Integer *maxResults = 56; //  (optional) (default to null)
String *personTypeId = personTypeId_example; //  (optional) (default to null)
String *searchKey = searchKey_example; //  (optional) (default to null)
String *taxId = taxId_example; //  (optional) (default to null)

[apiInstance v1CustomersGetWith:firstResult
    id:id
    isCustomer:isCustomer
    maxResults:maxResults
    personTypeId:personTypeId
    searchKey:searchKey
    taxId:taxId
              completionHandler: ^(PayloadDtoListCustomerDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestCustomerServiceApi()
var opts = {
  'firstResult': 56, // {Integer} 
  'id': id_example, // {String} 
  'isCustomer': true, // {Boolean} 
  'maxResults': 56, // {Integer} 
  'personTypeId': personTypeId_example, // {String} 
  'searchKey': searchKey_example, // {String} 
  'taxId': taxId_example // {String} 
};

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

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

namespace Example
{
    public class v1CustomersGetExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestCustomerServiceApi();
            var firstResult = 56;  // Integer |  (optional)  (default to null)
            var id = id_example;  // String |  (optional)  (default to null)
            var isCustomer = true;  // Boolean |  (optional)  (default to null)
            var maxResults = 56;  // Integer |  (optional)  (default to null)
            var personTypeId = personTypeId_example;  // String |  (optional)  (default to null)
            var searchKey = searchKey_example;  // String |  (optional)  (default to null)
            var taxId = taxId_example;  // String |  (optional)  (default to null)

            try {
                PayloadDtoListCustomerDto result = apiInstance.v1CustomersGet(firstResult, id, isCustomer, maxResults, personTypeId, searchKey, taxId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestCustomerServiceApi.v1CustomersGet: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestCustomerServiceApi();
$firstResult = 56; // Integer | 
$id = id_example; // String | 
$isCustomer = true; // Boolean | 
$maxResults = 56; // Integer | 
$personTypeId = personTypeId_example; // String | 
$searchKey = searchKey_example; // String | 
$taxId = taxId_example; // String | 

try {
    $result = $api_instance->v1CustomersGet($firstResult, $id, $isCustomer, $maxResults, $personTypeId, $searchKey, $taxId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RestCustomerServiceApi->v1CustomersGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestCustomerServiceApi->new();
my $firstResult = 56; # Integer | 
my $id = id_example; # String | 
my $isCustomer = true; # Boolean | 
my $maxResults = 56; # Integer | 
my $personTypeId = personTypeId_example; # String | 
my $searchKey = searchKey_example; # String | 
my $taxId = taxId_example; # String | 

eval {
    my $result = $api_instance->v1CustomersGet(firstResult => $firstResult, id => $id, isCustomer => $isCustomer, maxResults => $maxResults, personTypeId => $personTypeId, searchKey => $searchKey, taxId => $taxId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestCustomerServiceApi->v1CustomersGet: $@\n";
}

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestCustomerServiceApi()
firstResult = 56 # Integer |  (optional) (default to null)
id = id_example # String |  (optional) (default to null)
isCustomer = true # Boolean |  (optional) (default to null)
maxResults = 56 # Integer |  (optional) (default to null)
personTypeId = personTypeId_example # String |  (optional) (default to null)
searchKey = searchKey_example # String |  (optional) (default to null)
taxId = taxId_example # String |  (optional) (default to null)

try:
    api_response = api_instance.v1_customers_get(firstResult=firstResult, id=id, isCustomer=isCustomer, maxResults=maxResults, personTypeId=personTypeId, searchKey=searchKey, taxId=taxId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestCustomerServiceApi->v1CustomersGet: %s\n" % e)

extern crate RestCustomerServiceApi;

pub fn main() {
    let firstResult = 56; // Integer
    let id = id_example; // String
    let isCustomer = true; // Boolean
    let maxResults = 56; // Integer
    let personTypeId = personTypeId_example; // String
    let searchKey = searchKey_example; // String
    let taxId = taxId_example; // String

    let mut context = RestCustomerServiceApi::Context::default();
    let result = client.v1CustomersGet(firstResult, id, isCustomer, maxResults, personTypeId, searchKey, taxId, &context).wait();

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

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

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

public class RestCustomerServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestCustomerServiceApi apiInstance = new RestCustomerServiceApi();
        array[CustomerDto] customerDto = ; // array[CustomerDto] | 

        try {
            PayloadDtoVoid result = apiInstance.v1CustomersPost(customerDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCustomerServiceApi#v1CustomersPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[CustomerDto] customerDto = new array[CustomerDto](); // array[CustomerDto] | 

try {
    final result = await api_instance.v1CustomersPost(customerDto);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CustomersPost: $e\n');
}

import org.openapitools.client.api.RestCustomerServiceApi;

public class RestCustomerServiceApiExample {
    public static void main(String[] args) {
        RestCustomerServiceApi apiInstance = new RestCustomerServiceApi();
        array[CustomerDto] customerDto = ; // array[CustomerDto] | 

        try {
            PayloadDtoVoid result = apiInstance.v1CustomersPost(customerDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCustomerServiceApi#v1CustomersPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestCustomerServiceApi *apiInstance = [[RestCustomerServiceApi alloc] init];
array[CustomerDto] *customerDto = ; //  (optional)

[apiInstance v1CustomersPostWith:customerDto
              completionHandler: ^(PayloadDtoVoid output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestCustomerServiceApi()
var opts = {
  'customerDto':  // {array[CustomerDto]} 
};

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

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

namespace Example
{
    public class v1CustomersPostExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestCustomerServiceApi();
            var customerDto = new array[CustomerDto](); // array[CustomerDto] |  (optional) 

            try {
                PayloadDtoVoid result = apiInstance.v1CustomersPost(customerDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestCustomerServiceApi.v1CustomersPost: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestCustomerServiceApi();
$customerDto = ; // array[CustomerDto] | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestCustomerServiceApi->new();
my $customerDto = [WWW::OPenAPIClient::Object::array[CustomerDto]->new()]; # array[CustomerDto] | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestCustomerServiceApi()
customerDto =  # array[CustomerDto] |  (optional)

try:
    api_response = api_instance.v1_customers_post(customerDto=customerDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestCustomerServiceApi->v1CustomersPost: %s\n" % e)

extern crate RestCustomerServiceApi;

pub fn main() {
    let customerDto = ; // array[CustomerDto]

    let mut context = RestCustomerServiceApi::Context::default();
    let result = client.v1CustomersPost(customerDto, &context).wait();

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

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

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

public class RestCustomerServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestCustomerServiceApi apiInstance = new RestCustomerServiceApi();
        Integer firstResult = 56; // Integer | 
        String id = id_example; // String | 
        Integer maxResults = 56; // Integer | 
        String taxId = taxId_example; // String | 

        try {
            PayloadDtoListPerceptionDto result = apiInstance.v1PerceptionsGet(firstResult, id, maxResults, taxId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCustomerServiceApi#v1PerceptionsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer firstResult = new Integer(); // Integer | 
final String id = new String(); // String | 
final Integer maxResults = new Integer(); // Integer | 
final String taxId = new String(); // String | 

try {
    final result = await api_instance.v1PerceptionsGet(firstResult, id, maxResults, taxId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1PerceptionsGet: $e\n');
}

import org.openapitools.client.api.RestCustomerServiceApi;

public class RestCustomerServiceApiExample {
    public static void main(String[] args) {
        RestCustomerServiceApi apiInstance = new RestCustomerServiceApi();
        Integer firstResult = 56; // Integer | 
        String id = id_example; // String | 
        Integer maxResults = 56; // Integer | 
        String taxId = taxId_example; // String | 

        try {
            PayloadDtoListPerceptionDto result = apiInstance.v1PerceptionsGet(firstResult, id, maxResults, taxId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCustomerServiceApi#v1PerceptionsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestCustomerServiceApi *apiInstance = [[RestCustomerServiceApi alloc] init];
Integer *firstResult = 56; //  (optional) (default to null)
String *id = id_example; //  (optional) (default to null)
Integer *maxResults = 56; //  (optional) (default to null)
String *taxId = taxId_example; //  (optional) (default to null)

[apiInstance v1PerceptionsGetWith:firstResult
    id:id
    maxResults:maxResults
    taxId:taxId
              completionHandler: ^(PayloadDtoListPerceptionDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestCustomerServiceApi()
var opts = {
  'firstResult': 56, // {Integer} 
  'id': id_example, // {String} 
  'maxResults': 56, // {Integer} 
  'taxId': taxId_example // {String} 
};

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

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

namespace Example
{
    public class v1PerceptionsGetExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestCustomerServiceApi();
            var firstResult = 56;  // Integer |  (optional)  (default to null)
            var id = id_example;  // String |  (optional)  (default to null)
            var maxResults = 56;  // Integer |  (optional)  (default to null)
            var taxId = taxId_example;  // String |  (optional)  (default to null)

            try {
                PayloadDtoListPerceptionDto result = apiInstance.v1PerceptionsGet(firstResult, id, maxResults, taxId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestCustomerServiceApi.v1PerceptionsGet: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestCustomerServiceApi();
$firstResult = 56; // Integer | 
$id = id_example; // String | 
$maxResults = 56; // Integer | 
$taxId = taxId_example; // String | 

try {
    $result = $api_instance->v1PerceptionsGet($firstResult, $id, $maxResults, $taxId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RestCustomerServiceApi->v1PerceptionsGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestCustomerServiceApi->new();
my $firstResult = 56; # Integer | 
my $id = id_example; # String | 
my $maxResults = 56; # Integer | 
my $taxId = taxId_example; # String | 

eval {
    my $result = $api_instance->v1PerceptionsGet(firstResult => $firstResult, id => $id, maxResults => $maxResults, taxId => $taxId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestCustomerServiceApi->v1PerceptionsGet: $@\n";
}

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestCustomerServiceApi()
firstResult = 56 # Integer |  (optional) (default to null)
id = id_example # String |  (optional) (default to null)
maxResults = 56 # Integer |  (optional) (default to null)
taxId = taxId_example # String |  (optional) (default to null)

try:
    api_response = api_instance.v1_perceptions_get(firstResult=firstResult, id=id, maxResults=maxResults, taxId=taxId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestCustomerServiceApi->v1PerceptionsGet: %s\n" % e)

extern crate RestCustomerServiceApi;

pub fn main() {
    let firstResult = 56; // Integer
    let id = id_example; // String
    let maxResults = 56; // Integer
    let taxId = taxId_example; // String

    let mut context = RestCustomerServiceApi::Context::default();
    let result = client.v1PerceptionsGet(firstResult, id, maxResults, taxId, &context).wait();

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

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

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

public class RestCustomerServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestCustomerServiceApi apiInstance = new RestCustomerServiceApi();
        array[PerceptionDto] perceptionDto = ; // array[PerceptionDto] | 

        try {
            PayloadDtoVoid result = apiInstance.v1PerceptionsPost(perceptionDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCustomerServiceApi#v1PerceptionsPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[PerceptionDto] perceptionDto = new array[PerceptionDto](); // array[PerceptionDto] | 

try {
    final result = await api_instance.v1PerceptionsPost(perceptionDto);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1PerceptionsPost: $e\n');
}

import org.openapitools.client.api.RestCustomerServiceApi;

public class RestCustomerServiceApiExample {
    public static void main(String[] args) {
        RestCustomerServiceApi apiInstance = new RestCustomerServiceApi();
        array[PerceptionDto] perceptionDto = ; // array[PerceptionDto] | 

        try {
            PayloadDtoVoid result = apiInstance.v1PerceptionsPost(perceptionDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCustomerServiceApi#v1PerceptionsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestCustomerServiceApi *apiInstance = [[RestCustomerServiceApi alloc] init];
array[PerceptionDto] *perceptionDto = ; //  (optional)

[apiInstance v1PerceptionsPostWith:perceptionDto
              completionHandler: ^(PayloadDtoVoid output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestCustomerServiceApi()
var opts = {
  'perceptionDto':  // {array[PerceptionDto]} 
};

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

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

namespace Example
{
    public class v1PerceptionsPostExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestCustomerServiceApi();
            var perceptionDto = new array[PerceptionDto](); // array[PerceptionDto] |  (optional) 

            try {
                PayloadDtoVoid result = apiInstance.v1PerceptionsPost(perceptionDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestCustomerServiceApi.v1PerceptionsPost: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestCustomerServiceApi();
$perceptionDto = ; // array[PerceptionDto] | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestCustomerServiceApi->new();
my $perceptionDto = [WWW::OPenAPIClient::Object::array[PerceptionDto]->new()]; # array[PerceptionDto] | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestCustomerServiceApi()
perceptionDto =  # array[PerceptionDto] |  (optional)

try:
    api_response = api_instance.v1_perceptions_post(perceptionDto=perceptionDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestCustomerServiceApi->v1PerceptionsPost: %s\n" % e)

extern crate RestCustomerServiceApi;

pub fn main() {
    let perceptionDto = ; // array[PerceptionDto]

    let mut context = RestCustomerServiceApi::Context::default();
    let result = client.v1PerceptionsPost(perceptionDto, &context).wait();

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

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

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

public class RestCustomerServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestCustomerServiceApi apiInstance = new RestCustomerServiceApi();
        array[PerceptionTaxDto] perceptionTaxDto = ; // array[PerceptionTaxDto] | 

        try {
            PayloadDtoVoid result = apiInstance.v1PerceptionsTaxesPost(perceptionTaxDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCustomerServiceApi#v1PerceptionsTaxesPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[PerceptionTaxDto] perceptionTaxDto = new array[PerceptionTaxDto](); // array[PerceptionTaxDto] | 

try {
    final result = await api_instance.v1PerceptionsTaxesPost(perceptionTaxDto);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1PerceptionsTaxesPost: $e\n');
}

import org.openapitools.client.api.RestCustomerServiceApi;

public class RestCustomerServiceApiExample {
    public static void main(String[] args) {
        RestCustomerServiceApi apiInstance = new RestCustomerServiceApi();
        array[PerceptionTaxDto] perceptionTaxDto = ; // array[PerceptionTaxDto] | 

        try {
            PayloadDtoVoid result = apiInstance.v1PerceptionsTaxesPost(perceptionTaxDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCustomerServiceApi#v1PerceptionsTaxesPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestCustomerServiceApi *apiInstance = [[RestCustomerServiceApi alloc] init];
array[PerceptionTaxDto] *perceptionTaxDto = ; //  (optional)

[apiInstance v1PerceptionsTaxesPostWith:perceptionTaxDto
              completionHandler: ^(PayloadDtoVoid output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestCustomerServiceApi()
var opts = {
  'perceptionTaxDto':  // {array[PerceptionTaxDto]} 
};

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

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

namespace Example
{
    public class v1PerceptionsTaxesPostExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestCustomerServiceApi();
            var perceptionTaxDto = new array[PerceptionTaxDto](); // array[PerceptionTaxDto] |  (optional) 

            try {
                PayloadDtoVoid result = apiInstance.v1PerceptionsTaxesPost(perceptionTaxDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestCustomerServiceApi.v1PerceptionsTaxesPost: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestCustomerServiceApi();
$perceptionTaxDto = ; // array[PerceptionTaxDto] | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestCustomerServiceApi->new();
my $perceptionTaxDto = [WWW::OPenAPIClient::Object::array[PerceptionTaxDto]->new()]; # array[PerceptionTaxDto] | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestCustomerServiceApi()
perceptionTaxDto =  # array[PerceptionTaxDto] |  (optional)

try:
    api_response = api_instance.v1_perceptions_taxes_post(perceptionTaxDto=perceptionTaxDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestCustomerServiceApi->v1PerceptionsTaxesPost: %s\n" % e)

extern crate RestCustomerServiceApi;

pub fn main() {
    let perceptionTaxDto = ; // array[PerceptionTaxDto]

    let mut context = RestCustomerServiceApi::Context::default();
    let result = client.v1PerceptionsTaxesPost(perceptionTaxDto, &context).wait();

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

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

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

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

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

        try {
            PayloadDtoListErrorCodeDto result = apiInstance.v1MetadataErrorCodesGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestMetadataServiceApi#v1MetadataErrorCodesGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.v1MetadataErrorCodesGet();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1MetadataErrorCodesGet: $e\n');
}

import org.openapitools.client.api.RestMetadataServiceApi;

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

        try {
            PayloadDtoListErrorCodeDto result = apiInstance.v1MetadataErrorCodesGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestMetadataServiceApi#v1MetadataErrorCodesGet");
            e.printStackTrace();
        }
    }
}

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

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

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');

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

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

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

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

            try {
                PayloadDtoListErrorCodeDto result = apiInstance.v1MetadataErrorCodesGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestMetadataServiceApi.v1MetadataErrorCodesGet: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate RestMetadataServiceApi;

pub fn main() {

    let mut context = RestMetadataServiceApi::Context::default();
    let result = client.v1MetadataErrorCodesGet(&context).wait();

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

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

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

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        Integer firstResult = 56; // Integer | 
        String id = id_example; // String | 
        Integer maxResults = 56; // Integer | 

        try {
            PayloadDtoListBrandDto result = apiInstance.v1BrandsGet(firstResult, id, maxResults);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1BrandsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer firstResult = new Integer(); // Integer | 
final String id = new String(); // String | 
final Integer maxResults = new Integer(); // Integer | 

try {
    final result = await api_instance.v1BrandsGet(firstResult, id, maxResults);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1BrandsGet: $e\n');
}

import org.openapitools.client.api.RestProductServiceApi;

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        Integer firstResult = 56; // Integer | 
        String id = id_example; // String | 
        Integer maxResults = 56; // Integer | 

        try {
            PayloadDtoListBrandDto result = apiInstance.v1BrandsGet(firstResult, id, maxResults);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1BrandsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestProductServiceApi *apiInstance = [[RestProductServiceApi alloc] init];
Integer *firstResult = 56; //  (optional) (default to null)
String *id = id_example; //  (optional) (default to null)
Integer *maxResults = 56; //  (optional) (default to null)

[apiInstance v1BrandsGetWith:firstResult
    id:id
    maxResults:maxResults
              completionHandler: ^(PayloadDtoListBrandDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestProductServiceApi()
var opts = {
  'firstResult': 56, // {Integer} 
  'id': id_example, // {String} 
  'maxResults': 56 // {Integer} 
};

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

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

namespace Example
{
    public class v1BrandsGetExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestProductServiceApi();
            var firstResult = 56;  // Integer |  (optional)  (default to null)
            var id = id_example;  // String |  (optional)  (default to null)
            var maxResults = 56;  // Integer |  (optional)  (default to null)

            try {
                PayloadDtoListBrandDto result = apiInstance.v1BrandsGet(firstResult, id, maxResults);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProductServiceApi.v1BrandsGet: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProductServiceApi();
$firstResult = 56; // Integer | 
$id = id_example; // String | 
$maxResults = 56; // Integer | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestProductServiceApi->new();
my $firstResult = 56; # Integer | 
my $id = id_example; # String | 
my $maxResults = 56; # Integer | 

eval {
    my $result = $api_instance->v1BrandsGet(firstResult => $firstResult, id => $id, maxResults => $maxResults);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestProductServiceApi->v1BrandsGet: $@\n";
}

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestProductServiceApi()
firstResult = 56 # Integer |  (optional) (default to null)
id = id_example # String |  (optional) (default to null)
maxResults = 56 # Integer |  (optional) (default to null)

try:
    api_response = api_instance.v1_brands_get(firstResult=firstResult, id=id, maxResults=maxResults)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProductServiceApi->v1BrandsGet: %s\n" % e)

extern crate RestProductServiceApi;

pub fn main() {
    let firstResult = 56; // Integer
    let id = id_example; // String
    let maxResults = 56; // Integer

    let mut context = RestProductServiceApi::Context::default();
    let result = client.v1BrandsGet(firstResult, id, maxResults, &context).wait();

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

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

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

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        array[BrandDto] brandDto = ; // array[BrandDto] | 

        try {
            PayloadDtoVoid result = apiInstance.v1BrandsPost(brandDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1BrandsPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[BrandDto] brandDto = new array[BrandDto](); // array[BrandDto] | 

try {
    final result = await api_instance.v1BrandsPost(brandDto);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1BrandsPost: $e\n');
}

import org.openapitools.client.api.RestProductServiceApi;

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        array[BrandDto] brandDto = ; // array[BrandDto] | 

        try {
            PayloadDtoVoid result = apiInstance.v1BrandsPost(brandDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1BrandsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestProductServiceApi *apiInstance = [[RestProductServiceApi alloc] init];
array[BrandDto] *brandDto = ; //  (optional)

[apiInstance v1BrandsPostWith:brandDto
              completionHandler: ^(PayloadDtoVoid output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestProductServiceApi()
var opts = {
  'brandDto':  // {array[BrandDto]} 
};

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

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

namespace Example
{
    public class v1BrandsPostExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestProductServiceApi();
            var brandDto = new array[BrandDto](); // array[BrandDto] |  (optional) 

            try {
                PayloadDtoVoid result = apiInstance.v1BrandsPost(brandDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProductServiceApi.v1BrandsPost: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProductServiceApi();
$brandDto = ; // array[BrandDto] | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestProductServiceApi->new();
my $brandDto = [WWW::OPenAPIClient::Object::array[BrandDto]->new()]; # array[BrandDto] | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestProductServiceApi()
brandDto =  # array[BrandDto] |  (optional)

try:
    api_response = api_instance.v1_brands_post(brandDto=brandDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProductServiceApi->v1BrandsPost: %s\n" % e)

extern crate RestProductServiceApi;

pub fn main() {
    let brandDto = ; // array[BrandDto]

    let mut context = RestProductServiceApi::Context::default();
    let result = client.v1BrandsPost(brandDto, &context).wait();

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

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

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

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        Integer firstResult = 56; // Integer | 
        String id = id_example; // String | 
        Integer maxResults = 56; // Integer | 

        try {
            PayloadDtoListCategoryDto result = apiInstance.v1CategoriesGet(firstResult, id, maxResults);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1CategoriesGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer firstResult = new Integer(); // Integer | 
final String id = new String(); // String | 
final Integer maxResults = new Integer(); // Integer | 

try {
    final result = await api_instance.v1CategoriesGet(firstResult, id, maxResults);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CategoriesGet: $e\n');
}

import org.openapitools.client.api.RestProductServiceApi;

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        Integer firstResult = 56; // Integer | 
        String id = id_example; // String | 
        Integer maxResults = 56; // Integer | 

        try {
            PayloadDtoListCategoryDto result = apiInstance.v1CategoriesGet(firstResult, id, maxResults);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1CategoriesGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestProductServiceApi *apiInstance = [[RestProductServiceApi alloc] init];
Integer *firstResult = 56; //  (optional) (default to null)
String *id = id_example; //  (optional) (default to null)
Integer *maxResults = 56; //  (optional) (default to null)

[apiInstance v1CategoriesGetWith:firstResult
    id:id
    maxResults:maxResults
              completionHandler: ^(PayloadDtoListCategoryDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestProductServiceApi()
var opts = {
  'firstResult': 56, // {Integer} 
  'id': id_example, // {String} 
  'maxResults': 56 // {Integer} 
};

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

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

namespace Example
{
    public class v1CategoriesGetExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestProductServiceApi();
            var firstResult = 56;  // Integer |  (optional)  (default to null)
            var id = id_example;  // String |  (optional)  (default to null)
            var maxResults = 56;  // Integer |  (optional)  (default to null)

            try {
                PayloadDtoListCategoryDto result = apiInstance.v1CategoriesGet(firstResult, id, maxResults);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProductServiceApi.v1CategoriesGet: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProductServiceApi();
$firstResult = 56; // Integer | 
$id = id_example; // String | 
$maxResults = 56; // Integer | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestProductServiceApi->new();
my $firstResult = 56; # Integer | 
my $id = id_example; # String | 
my $maxResults = 56; # Integer | 

eval {
    my $result = $api_instance->v1CategoriesGet(firstResult => $firstResult, id => $id, maxResults => $maxResults);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestProductServiceApi->v1CategoriesGet: $@\n";
}

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestProductServiceApi()
firstResult = 56 # Integer |  (optional) (default to null)
id = id_example # String |  (optional) (default to null)
maxResults = 56 # Integer |  (optional) (default to null)

try:
    api_response = api_instance.v1_categories_get(firstResult=firstResult, id=id, maxResults=maxResults)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProductServiceApi->v1CategoriesGet: %s\n" % e)

extern crate RestProductServiceApi;

pub fn main() {
    let firstResult = 56; // Integer
    let id = id_example; // String
    let maxResults = 56; // Integer

    let mut context = RestProductServiceApi::Context::default();
    let result = client.v1CategoriesGet(firstResult, id, maxResults, &context).wait();

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

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

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

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        array[CategoryDto] categoryDto = ; // array[CategoryDto] | 

        try {
            PayloadDtoVoid result = apiInstance.v1CategoriesPost(categoryDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1CategoriesPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[CategoryDto] categoryDto = new array[CategoryDto](); // array[CategoryDto] | 

try {
    final result = await api_instance.v1CategoriesPost(categoryDto);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CategoriesPost: $e\n');
}

import org.openapitools.client.api.RestProductServiceApi;

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        array[CategoryDto] categoryDto = ; // array[CategoryDto] | 

        try {
            PayloadDtoVoid result = apiInstance.v1CategoriesPost(categoryDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1CategoriesPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestProductServiceApi *apiInstance = [[RestProductServiceApi alloc] init];
array[CategoryDto] *categoryDto = ; //  (optional)

[apiInstance v1CategoriesPostWith:categoryDto
              completionHandler: ^(PayloadDtoVoid output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestProductServiceApi()
var opts = {
  'categoryDto':  // {array[CategoryDto]} 
};

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

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

namespace Example
{
    public class v1CategoriesPostExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestProductServiceApi();
            var categoryDto = new array[CategoryDto](); // array[CategoryDto] |  (optional) 

            try {
                PayloadDtoVoid result = apiInstance.v1CategoriesPost(categoryDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProductServiceApi.v1CategoriesPost: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProductServiceApi();
$categoryDto = ; // array[CategoryDto] | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestProductServiceApi->new();
my $categoryDto = [WWW::OPenAPIClient::Object::array[CategoryDto]->new()]; # array[CategoryDto] | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestProductServiceApi()
categoryDto =  # array[CategoryDto] |  (optional)

try:
    api_response = api_instance.v1_categories_post(categoryDto=categoryDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProductServiceApi->v1CategoriesPost: %s\n" % e)

extern crate RestProductServiceApi;

pub fn main() {
    let categoryDto = ; // array[CategoryDto]

    let mut context = RestProductServiceApi::Context::default();
    let result = client.v1CategoriesPost(categoryDto, &context).wait();

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

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

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

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        Integer firstResult = 56; // Integer | 
        String locationId = locationId_example; // String | 
        Integer maxResults = 56; // Integer | 
        String productId = productId_example; // String | 

        try {
            PayloadDtoListCurrentStockDto result = apiInstance.v1CurrentStockGet(firstResult, locationId, maxResults, productId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1CurrentStockGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer firstResult = new Integer(); // Integer | 
final String locationId = new String(); // String | 
final Integer maxResults = new Integer(); // Integer | 
final String productId = new String(); // String | 

try {
    final result = await api_instance.v1CurrentStockGet(firstResult, locationId, maxResults, productId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CurrentStockGet: $e\n');
}

import org.openapitools.client.api.RestProductServiceApi;

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        Integer firstResult = 56; // Integer | 
        String locationId = locationId_example; // String | 
        Integer maxResults = 56; // Integer | 
        String productId = productId_example; // String | 

        try {
            PayloadDtoListCurrentStockDto result = apiInstance.v1CurrentStockGet(firstResult, locationId, maxResults, productId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1CurrentStockGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestProductServiceApi *apiInstance = [[RestProductServiceApi alloc] init];
Integer *firstResult = 56; //  (optional) (default to null)
String *locationId = locationId_example; //  (optional) (default to null)
Integer *maxResults = 56; //  (optional) (default to null)
String *productId = productId_example; //  (optional) (default to null)

[apiInstance v1CurrentStockGetWith:firstResult
    locationId:locationId
    maxResults:maxResults
    productId:productId
              completionHandler: ^(PayloadDtoListCurrentStockDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestProductServiceApi()
var opts = {
  'firstResult': 56, // {Integer} 
  'locationId': locationId_example, // {String} 
  'maxResults': 56, // {Integer} 
  'productId': productId_example // {String} 
};

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

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

namespace Example
{
    public class v1CurrentStockGetExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestProductServiceApi();
            var firstResult = 56;  // Integer |  (optional)  (default to null)
            var locationId = locationId_example;  // String |  (optional)  (default to null)
            var maxResults = 56;  // Integer |  (optional)  (default to null)
            var productId = productId_example;  // String |  (optional)  (default to null)

            try {
                PayloadDtoListCurrentStockDto result = apiInstance.v1CurrentStockGet(firstResult, locationId, maxResults, productId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProductServiceApi.v1CurrentStockGet: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProductServiceApi();
$firstResult = 56; // Integer | 
$locationId = locationId_example; // String | 
$maxResults = 56; // Integer | 
$productId = productId_example; // String | 

try {
    $result = $api_instance->v1CurrentStockGet($firstResult, $locationId, $maxResults, $productId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RestProductServiceApi->v1CurrentStockGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestProductServiceApi->new();
my $firstResult = 56; # Integer | 
my $locationId = locationId_example; # String | 
my $maxResults = 56; # Integer | 
my $productId = productId_example; # String | 

eval {
    my $result = $api_instance->v1CurrentStockGet(firstResult => $firstResult, locationId => $locationId, maxResults => $maxResults, productId => $productId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestProductServiceApi->v1CurrentStockGet: $@\n";
}

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestProductServiceApi()
firstResult = 56 # Integer |  (optional) (default to null)
locationId = locationId_example # String |  (optional) (default to null)
maxResults = 56 # Integer |  (optional) (default to null)
productId = productId_example # String |  (optional) (default to null)

try:
    api_response = api_instance.v1_current_stock_get(firstResult=firstResult, locationId=locationId, maxResults=maxResults, productId=productId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProductServiceApi->v1CurrentStockGet: %s\n" % e)

extern crate RestProductServiceApi;

pub fn main() {
    let firstResult = 56; // Integer
    let locationId = locationId_example; // String
    let maxResults = 56; // Integer
    let productId = productId_example; // String

    let mut context = RestProductServiceApi::Context::default();
    let result = client.v1CurrentStockGet(firstResult, locationId, maxResults, productId, &context).wait();

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

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

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

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        Integer firstResult = 56; // Integer | 
        String id = id_example; // String | 
        Integer maxResults = 56; // Integer | 

        try {
            PayloadDtoListFamilyDto result = apiInstance.v1FamiliesGet(firstResult, id, maxResults);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1FamiliesGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer firstResult = new Integer(); // Integer | 
final String id = new String(); // String | 
final Integer maxResults = new Integer(); // Integer | 

try {
    final result = await api_instance.v1FamiliesGet(firstResult, id, maxResults);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1FamiliesGet: $e\n');
}

import org.openapitools.client.api.RestProductServiceApi;

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        Integer firstResult = 56; // Integer | 
        String id = id_example; // String | 
        Integer maxResults = 56; // Integer | 

        try {
            PayloadDtoListFamilyDto result = apiInstance.v1FamiliesGet(firstResult, id, maxResults);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1FamiliesGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestProductServiceApi *apiInstance = [[RestProductServiceApi alloc] init];
Integer *firstResult = 56; //  (optional) (default to null)
String *id = id_example; //  (optional) (default to null)
Integer *maxResults = 56; //  (optional) (default to null)

[apiInstance v1FamiliesGetWith:firstResult
    id:id
    maxResults:maxResults
              completionHandler: ^(PayloadDtoListFamilyDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestProductServiceApi()
var opts = {
  'firstResult': 56, // {Integer} 
  'id': id_example, // {String} 
  'maxResults': 56 // {Integer} 
};

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

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

namespace Example
{
    public class v1FamiliesGetExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestProductServiceApi();
            var firstResult = 56;  // Integer |  (optional)  (default to null)
            var id = id_example;  // String |  (optional)  (default to null)
            var maxResults = 56;  // Integer |  (optional)  (default to null)

            try {
                PayloadDtoListFamilyDto result = apiInstance.v1FamiliesGet(firstResult, id, maxResults);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProductServiceApi.v1FamiliesGet: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProductServiceApi();
$firstResult = 56; // Integer | 
$id = id_example; // String | 
$maxResults = 56; // Integer | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestProductServiceApi->new();
my $firstResult = 56; # Integer | 
my $id = id_example; # String | 
my $maxResults = 56; # Integer | 

eval {
    my $result = $api_instance->v1FamiliesGet(firstResult => $firstResult, id => $id, maxResults => $maxResults);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestProductServiceApi->v1FamiliesGet: $@\n";
}

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestProductServiceApi()
firstResult = 56 # Integer |  (optional) (default to null)
id = id_example # String |  (optional) (default to null)
maxResults = 56 # Integer |  (optional) (default to null)

try:
    api_response = api_instance.v1_families_get(firstResult=firstResult, id=id, maxResults=maxResults)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProductServiceApi->v1FamiliesGet: %s\n" % e)

extern crate RestProductServiceApi;

pub fn main() {
    let firstResult = 56; // Integer
    let id = id_example; // String
    let maxResults = 56; // Integer

    let mut context = RestProductServiceApi::Context::default();
    let result = client.v1FamiliesGet(firstResult, id, maxResults, &context).wait();

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

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

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

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        array[FamilyDto] familyDto = ; // array[FamilyDto] | 

        try {
            PayloadDtoVoid result = apiInstance.v1FamiliesPost(familyDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1FamiliesPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[FamilyDto] familyDto = new array[FamilyDto](); // array[FamilyDto] | 

try {
    final result = await api_instance.v1FamiliesPost(familyDto);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1FamiliesPost: $e\n');
}

import org.openapitools.client.api.RestProductServiceApi;

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        array[FamilyDto] familyDto = ; // array[FamilyDto] | 

        try {
            PayloadDtoVoid result = apiInstance.v1FamiliesPost(familyDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1FamiliesPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestProductServiceApi *apiInstance = [[RestProductServiceApi alloc] init];
array[FamilyDto] *familyDto = ; //  (optional)

[apiInstance v1FamiliesPostWith:familyDto
              completionHandler: ^(PayloadDtoVoid output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestProductServiceApi()
var opts = {
  'familyDto':  // {array[FamilyDto]} 
};

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

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

namespace Example
{
    public class v1FamiliesPostExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestProductServiceApi();
            var familyDto = new array[FamilyDto](); // array[FamilyDto] |  (optional) 

            try {
                PayloadDtoVoid result = apiInstance.v1FamiliesPost(familyDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProductServiceApi.v1FamiliesPost: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProductServiceApi();
$familyDto = ; // array[FamilyDto] | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestProductServiceApi->new();
my $familyDto = [WWW::OPenAPIClient::Object::array[FamilyDto]->new()]; # array[FamilyDto] | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestProductServiceApi()
familyDto =  # array[FamilyDto] |  (optional)

try:
    api_response = api_instance.v1_families_post(familyDto=familyDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProductServiceApi->v1FamiliesPost: %s\n" % e)

extern crate RestProductServiceApi;

pub fn main() {
    let familyDto = ; // array[FamilyDto]

    let mut context = RestProductServiceApi::Context::default();
    let result = client.v1FamiliesPost(familyDto, &context).wait();

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

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

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

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        Integer firstResult = 56; // Integer | 
        String id = id_example; // String | 
        Boolean isActive = true; // Boolean | 
        Integer maxResults = 56; // Integer | 
        String paymentTypeId = paymentTypeId_example; // String | 

        try {
            PayloadDtoListPaymentMethodDto result = apiInstance.v1PaymentMethodsGet(firstResult, id, isActive, maxResults, paymentTypeId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1PaymentMethodsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer firstResult = new Integer(); // Integer | 
final String id = new String(); // String | 
final Boolean isActive = new Boolean(); // Boolean | 
final Integer maxResults = new Integer(); // Integer | 
final String paymentTypeId = new String(); // String | 

try {
    final result = await api_instance.v1PaymentMethodsGet(firstResult, id, isActive, maxResults, paymentTypeId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1PaymentMethodsGet: $e\n');
}

import org.openapitools.client.api.RestProductServiceApi;

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        Integer firstResult = 56; // Integer | 
        String id = id_example; // String | 
        Boolean isActive = true; // Boolean | 
        Integer maxResults = 56; // Integer | 
        String paymentTypeId = paymentTypeId_example; // String | 

        try {
            PayloadDtoListPaymentMethodDto result = apiInstance.v1PaymentMethodsGet(firstResult, id, isActive, maxResults, paymentTypeId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1PaymentMethodsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestProductServiceApi *apiInstance = [[RestProductServiceApi alloc] init];
Integer *firstResult = 56; //  (optional) (default to null)
String *id = id_example; //  (optional) (default to null)
Boolean *isActive = true; //  (optional) (default to null)
Integer *maxResults = 56; //  (optional) (default to null)
String *paymentTypeId = paymentTypeId_example; //  (optional) (default to null)

[apiInstance v1PaymentMethodsGetWith:firstResult
    id:id
    isActive:isActive
    maxResults:maxResults
    paymentTypeId:paymentTypeId
              completionHandler: ^(PayloadDtoListPaymentMethodDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestProductServiceApi()
var opts = {
  'firstResult': 56, // {Integer} 
  'id': id_example, // {String} 
  'isActive': true, // {Boolean} 
  'maxResults': 56, // {Integer} 
  'paymentTypeId': paymentTypeId_example // {String} 
};

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

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

namespace Example
{
    public class v1PaymentMethodsGetExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestProductServiceApi();
            var firstResult = 56;  // Integer |  (optional)  (default to null)
            var id = id_example;  // String |  (optional)  (default to null)
            var isActive = true;  // Boolean |  (optional)  (default to null)
            var maxResults = 56;  // Integer |  (optional)  (default to null)
            var paymentTypeId = paymentTypeId_example;  // String |  (optional)  (default to null)

            try {
                PayloadDtoListPaymentMethodDto result = apiInstance.v1PaymentMethodsGet(firstResult, id, isActive, maxResults, paymentTypeId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProductServiceApi.v1PaymentMethodsGet: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProductServiceApi();
$firstResult = 56; // Integer | 
$id = id_example; // String | 
$isActive = true; // Boolean | 
$maxResults = 56; // Integer | 
$paymentTypeId = paymentTypeId_example; // String | 

try {
    $result = $api_instance->v1PaymentMethodsGet($firstResult, $id, $isActive, $maxResults, $paymentTypeId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RestProductServiceApi->v1PaymentMethodsGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestProductServiceApi->new();
my $firstResult = 56; # Integer | 
my $id = id_example; # String | 
my $isActive = true; # Boolean | 
my $maxResults = 56; # Integer | 
my $paymentTypeId = paymentTypeId_example; # String | 

eval {
    my $result = $api_instance->v1PaymentMethodsGet(firstResult => $firstResult, id => $id, isActive => $isActive, maxResults => $maxResults, paymentTypeId => $paymentTypeId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestProductServiceApi->v1PaymentMethodsGet: $@\n";
}

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestProductServiceApi()
firstResult = 56 # Integer |  (optional) (default to null)
id = id_example # String |  (optional) (default to null)
isActive = true # Boolean |  (optional) (default to null)
maxResults = 56 # Integer |  (optional) (default to null)
paymentTypeId = paymentTypeId_example # String |  (optional) (default to null)

try:
    api_response = api_instance.v1_payment_methods_get(firstResult=firstResult, id=id, isActive=isActive, maxResults=maxResults, paymentTypeId=paymentTypeId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProductServiceApi->v1PaymentMethodsGet: %s\n" % e)

extern crate RestProductServiceApi;

pub fn main() {
    let firstResult = 56; // Integer
    let id = id_example; // String
    let isActive = true; // Boolean
    let maxResults = 56; // Integer
    let paymentTypeId = paymentTypeId_example; // String

    let mut context = RestProductServiceApi::Context::default();
    let result = client.v1PaymentMethodsGet(firstResult, id, isActive, maxResults, paymentTypeId, &context).wait();

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

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

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

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        array[PaymentMethodDto] paymentMethodDto = ; // array[PaymentMethodDto] | 

        try {
            PayloadDtoVoid result = apiInstance.v1PaymentMethodsPost(paymentMethodDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1PaymentMethodsPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[PaymentMethodDto] paymentMethodDto = new array[PaymentMethodDto](); // array[PaymentMethodDto] | 

try {
    final result = await api_instance.v1PaymentMethodsPost(paymentMethodDto);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1PaymentMethodsPost: $e\n');
}

import org.openapitools.client.api.RestProductServiceApi;

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        array[PaymentMethodDto] paymentMethodDto = ; // array[PaymentMethodDto] | 

        try {
            PayloadDtoVoid result = apiInstance.v1PaymentMethodsPost(paymentMethodDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1PaymentMethodsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestProductServiceApi *apiInstance = [[RestProductServiceApi alloc] init];
array[PaymentMethodDto] *paymentMethodDto = ; //  (optional)

[apiInstance v1PaymentMethodsPostWith:paymentMethodDto
              completionHandler: ^(PayloadDtoVoid output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestProductServiceApi()
var opts = {
  'paymentMethodDto':  // {array[PaymentMethodDto]} 
};

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

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

namespace Example
{
    public class v1PaymentMethodsPostExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestProductServiceApi();
            var paymentMethodDto = new array[PaymentMethodDto](); // array[PaymentMethodDto] |  (optional) 

            try {
                PayloadDtoVoid result = apiInstance.v1PaymentMethodsPost(paymentMethodDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProductServiceApi.v1PaymentMethodsPost: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProductServiceApi();
$paymentMethodDto = ; // array[PaymentMethodDto] | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestProductServiceApi->new();
my $paymentMethodDto = [WWW::OPenAPIClient::Object::array[PaymentMethodDto]->new()]; # array[PaymentMethodDto] | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestProductServiceApi()
paymentMethodDto =  # array[PaymentMethodDto] |  (optional)

try:
    api_response = api_instance.v1_payment_methods_post(paymentMethodDto=paymentMethodDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProductServiceApi->v1PaymentMethodsPost: %s\n" % e)

extern crate RestProductServiceApi;

pub fn main() {
    let paymentMethodDto = ; // array[PaymentMethodDto]

    let mut context = RestProductServiceApi::Context::default();
    let result = client.v1PaymentMethodsPost(paymentMethodDto, &context).wait();

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

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

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

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        Integer firstResult = 56; // Integer | 
        String id = id_example; // String | 
        Boolean isActive = true; // Boolean | 
        Integer maxResults = 56; // Integer | 
        array[String] paymentMethodIds = ; // array[String] | 

        try {
            PayloadDtoListPlanDto result = apiInstance.v1PlansGet(firstResult, id, isActive, maxResults, paymentMethodIds);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1PlansGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer firstResult = new Integer(); // Integer | 
final String id = new String(); // String | 
final Boolean isActive = new Boolean(); // Boolean | 
final Integer maxResults = new Integer(); // Integer | 
final array[String] paymentMethodIds = new array[String](); // array[String] | 

try {
    final result = await api_instance.v1PlansGet(firstResult, id, isActive, maxResults, paymentMethodIds);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1PlansGet: $e\n');
}

import org.openapitools.client.api.RestProductServiceApi;

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        Integer firstResult = 56; // Integer | 
        String id = id_example; // String | 
        Boolean isActive = true; // Boolean | 
        Integer maxResults = 56; // Integer | 
        array[String] paymentMethodIds = ; // array[String] | 

        try {
            PayloadDtoListPlanDto result = apiInstance.v1PlansGet(firstResult, id, isActive, maxResults, paymentMethodIds);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1PlansGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestProductServiceApi *apiInstance = [[RestProductServiceApi alloc] init];
Integer *firstResult = 56; //  (optional) (default to null)
String *id = id_example; //  (optional) (default to null)
Boolean *isActive = true; //  (optional) (default to null)
Integer *maxResults = 56; //  (optional) (default to null)
array[String] *paymentMethodIds = ; //  (optional) (default to null)

[apiInstance v1PlansGetWith:firstResult
    id:id
    isActive:isActive
    maxResults:maxResults
    paymentMethodIds:paymentMethodIds
              completionHandler: ^(PayloadDtoListPlanDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestProductServiceApi()
var opts = {
  'firstResult': 56, // {Integer} 
  'id': id_example, // {String} 
  'isActive': true, // {Boolean} 
  'maxResults': 56, // {Integer} 
  'paymentMethodIds':  // {array[String]} 
};

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

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

namespace Example
{
    public class v1PlansGetExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestProductServiceApi();
            var firstResult = 56;  // Integer |  (optional)  (default to null)
            var id = id_example;  // String |  (optional)  (default to null)
            var isActive = true;  // Boolean |  (optional)  (default to null)
            var maxResults = 56;  // Integer |  (optional)  (default to null)
            var paymentMethodIds = new array[String](); // array[String] |  (optional)  (default to null)

            try {
                PayloadDtoListPlanDto result = apiInstance.v1PlansGet(firstResult, id, isActive, maxResults, paymentMethodIds);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProductServiceApi.v1PlansGet: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProductServiceApi();
$firstResult = 56; // Integer | 
$id = id_example; // String | 
$isActive = true; // Boolean | 
$maxResults = 56; // Integer | 
$paymentMethodIds = ; // array[String] | 

try {
    $result = $api_instance->v1PlansGet($firstResult, $id, $isActive, $maxResults, $paymentMethodIds);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RestProductServiceApi->v1PlansGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestProductServiceApi->new();
my $firstResult = 56; # Integer | 
my $id = id_example; # String | 
my $isActive = true; # Boolean | 
my $maxResults = 56; # Integer | 
my $paymentMethodIds = []; # array[String] | 

eval {
    my $result = $api_instance->v1PlansGet(firstResult => $firstResult, id => $id, isActive => $isActive, maxResults => $maxResults, paymentMethodIds => $paymentMethodIds);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestProductServiceApi->v1PlansGet: $@\n";
}

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestProductServiceApi()
firstResult = 56 # Integer |  (optional) (default to null)
id = id_example # String |  (optional) (default to null)
isActive = true # Boolean |  (optional) (default to null)
maxResults = 56 # Integer |  (optional) (default to null)
paymentMethodIds =  # array[String] |  (optional) (default to null)

try:
    api_response = api_instance.v1_plans_get(firstResult=firstResult, id=id, isActive=isActive, maxResults=maxResults, paymentMethodIds=paymentMethodIds)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProductServiceApi->v1PlansGet: %s\n" % e)

extern crate RestProductServiceApi;

pub fn main() {
    let firstResult = 56; // Integer
    let id = id_example; // String
    let isActive = true; // Boolean
    let maxResults = 56; // Integer
    let paymentMethodIds = ; // array[String]

    let mut context = RestProductServiceApi::Context::default();
    let result = client.v1PlansGet(firstResult, id, isActive, maxResults, paymentMethodIds, &context).wait();

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

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

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

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        array[PlanDto] planDto = ; // array[PlanDto] | 

        try {
            PayloadDtoVoid result = apiInstance.v1PlansPost(planDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1PlansPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[PlanDto] planDto = new array[PlanDto](); // array[PlanDto] | 

try {
    final result = await api_instance.v1PlansPost(planDto);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1PlansPost: $e\n');
}

import org.openapitools.client.api.RestProductServiceApi;

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        array[PlanDto] planDto = ; // array[PlanDto] | 

        try {
            PayloadDtoVoid result = apiInstance.v1PlansPost(planDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1PlansPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestProductServiceApi *apiInstance = [[RestProductServiceApi alloc] init];
array[PlanDto] *planDto = ; //  (optional)

[apiInstance v1PlansPostWith:planDto
              completionHandler: ^(PayloadDtoVoid output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestProductServiceApi()
var opts = {
  'planDto':  // {array[PlanDto]} 
};

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

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

namespace Example
{
    public class v1PlansPostExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestProductServiceApi();
            var planDto = new array[PlanDto](); // array[PlanDto] |  (optional) 

            try {
                PayloadDtoVoid result = apiInstance.v1PlansPost(planDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProductServiceApi.v1PlansPost: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProductServiceApi();
$planDto = ; // array[PlanDto] | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestProductServiceApi->new();
my $planDto = [WWW::OPenAPIClient::Object::array[PlanDto]->new()]; # array[PlanDto] | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestProductServiceApi()
planDto =  # array[PlanDto] |  (optional)

try:
    api_response = api_instance.v1_plans_post(planDto=planDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProductServiceApi->v1PlansPost: %s\n" % e)

extern crate RestProductServiceApi;

pub fn main() {
    let planDto = ; // array[PlanDto]

    let mut context = RestProductServiceApi::Context::default();
    let result = client.v1PlansPost(planDto, &context).wait();

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

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

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

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        array[String] branchIds = ; // array[String] | 
        Integer firstResult = 56; // Integer | 
        String id = id_example; // String | 
        Boolean isActive = true; // Boolean | 
        Integer maxResults = 56; // Integer | 

        try {
            PayloadDtoListPriceListDto result = apiInstance.v1PriceListGet(branchIds, firstResult, id, isActive, maxResults);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1PriceListGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[String] branchIds = new array[String](); // array[String] | 
final Integer firstResult = new Integer(); // Integer | 
final String id = new String(); // String | 
final Boolean isActive = new Boolean(); // Boolean | 
final Integer maxResults = new Integer(); // Integer | 

try {
    final result = await api_instance.v1PriceListGet(branchIds, firstResult, id, isActive, maxResults);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1PriceListGet: $e\n');
}

import org.openapitools.client.api.RestProductServiceApi;

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        array[String] branchIds = ; // array[String] | 
        Integer firstResult = 56; // Integer | 
        String id = id_example; // String | 
        Boolean isActive = true; // Boolean | 
        Integer maxResults = 56; // Integer | 

        try {
            PayloadDtoListPriceListDto result = apiInstance.v1PriceListGet(branchIds, firstResult, id, isActive, maxResults);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1PriceListGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestProductServiceApi *apiInstance = [[RestProductServiceApi alloc] init];
array[String] *branchIds = ; //  (optional) (default to null)
Integer *firstResult = 56; //  (optional) (default to null)
String *id = id_example; //  (optional) (default to null)
Boolean *isActive = true; //  (optional) (default to null)
Integer *maxResults = 56; //  (optional) (default to null)

[apiInstance v1PriceListGetWith:branchIds
    firstResult:firstResult
    id:id
    isActive:isActive
    maxResults:maxResults
              completionHandler: ^(PayloadDtoListPriceListDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestProductServiceApi()
var opts = {
  'branchIds': , // {array[String]} 
  'firstResult': 56, // {Integer} 
  'id': id_example, // {String} 
  'isActive': true, // {Boolean} 
  'maxResults': 56 // {Integer} 
};

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

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

namespace Example
{
    public class v1PriceListGetExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestProductServiceApi();
            var branchIds = new array[String](); // array[String] |  (optional)  (default to null)
            var firstResult = 56;  // Integer |  (optional)  (default to null)
            var id = id_example;  // String |  (optional)  (default to null)
            var isActive = true;  // Boolean |  (optional)  (default to null)
            var maxResults = 56;  // Integer |  (optional)  (default to null)

            try {
                PayloadDtoListPriceListDto result = apiInstance.v1PriceListGet(branchIds, firstResult, id, isActive, maxResults);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProductServiceApi.v1PriceListGet: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProductServiceApi();
$branchIds = ; // array[String] | 
$firstResult = 56; // Integer | 
$id = id_example; // String | 
$isActive = true; // Boolean | 
$maxResults = 56; // Integer | 

try {
    $result = $api_instance->v1PriceListGet($branchIds, $firstResult, $id, $isActive, $maxResults);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RestProductServiceApi->v1PriceListGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestProductServiceApi->new();
my $branchIds = []; # array[String] | 
my $firstResult = 56; # Integer | 
my $id = id_example; # String | 
my $isActive = true; # Boolean | 
my $maxResults = 56; # Integer | 

eval {
    my $result = $api_instance->v1PriceListGet(branchIds => $branchIds, firstResult => $firstResult, id => $id, isActive => $isActive, maxResults => $maxResults);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestProductServiceApi->v1PriceListGet: $@\n";
}

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestProductServiceApi()
branchIds =  # array[String] |  (optional) (default to null)
firstResult = 56 # Integer |  (optional) (default to null)
id = id_example # String |  (optional) (default to null)
isActive = true # Boolean |  (optional) (default to null)
maxResults = 56 # Integer |  (optional) (default to null)

try:
    api_response = api_instance.v1_price_list_get(branchIds=branchIds, firstResult=firstResult, id=id, isActive=isActive, maxResults=maxResults)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProductServiceApi->v1PriceListGet: %s\n" % e)

extern crate RestProductServiceApi;

pub fn main() {
    let branchIds = ; // array[String]
    let firstResult = 56; // Integer
    let id = id_example; // String
    let isActive = true; // Boolean
    let maxResults = 56; // Integer

    let mut context = RestProductServiceApi::Context::default();
    let result = client.v1PriceListGet(branchIds, firstResult, id, isActive, maxResults, &context).wait();

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

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

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

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        array[PriceListDto] priceListDto = ; // array[PriceListDto] | 

        try {
            PayloadDtoVoid result = apiInstance.v1PriceListPost(priceListDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1PriceListPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[PriceListDto] priceListDto = new array[PriceListDto](); // array[PriceListDto] | 

try {
    final result = await api_instance.v1PriceListPost(priceListDto);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1PriceListPost: $e\n');
}

import org.openapitools.client.api.RestProductServiceApi;

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        array[PriceListDto] priceListDto = ; // array[PriceListDto] | 

        try {
            PayloadDtoVoid result = apiInstance.v1PriceListPost(priceListDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1PriceListPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestProductServiceApi *apiInstance = [[RestProductServiceApi alloc] init];
array[PriceListDto] *priceListDto = ; //  (optional)

[apiInstance v1PriceListPostWith:priceListDto
              completionHandler: ^(PayloadDtoVoid output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestProductServiceApi()
var opts = {
  'priceListDto':  // {array[PriceListDto]} 
};

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

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

namespace Example
{
    public class v1PriceListPostExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestProductServiceApi();
            var priceListDto = new array[PriceListDto](); // array[PriceListDto] |  (optional) 

            try {
                PayloadDtoVoid result = apiInstance.v1PriceListPost(priceListDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProductServiceApi.v1PriceListPost: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProductServiceApi();
$priceListDto = ; // array[PriceListDto] | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestProductServiceApi->new();
my $priceListDto = [WWW::OPenAPIClient::Object::array[PriceListDto]->new()]; # array[PriceListDto] | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestProductServiceApi()
priceListDto =  # array[PriceListDto] |  (optional)

try:
    api_response = api_instance.v1_price_list_post(priceListDto=priceListDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProductServiceApi->v1PriceListPost: %s\n" % e)

extern crate RestProductServiceApi;

pub fn main() {
    let priceListDto = ; // array[PriceListDto]

    let mut context = RestProductServiceApi::Context::default();
    let result = client.v1PriceListPost(priceListDto, &context).wait();

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

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

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

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        String brandId = brandId_example; // String | 
        String categoryId = categoryId_example; // String | 
        String code = code_example; // String | 
        String familyId = familyId_example; // String | 
        Integer firstResult = 56; // Integer | 
        String id = id_example; // String | 
        Boolean isActive = true; // Boolean | 
        Boolean isWeb = true; // Boolean | 
        Date lastModificationFrom = 2013-10-20T19:20:30+01:00; // Date | 
        Date lastModificationTo = 2013-10-20T19:20:30+01:00; // Date | 
        Integer maxResults = 56; // Integer | 
        String reference = reference_example; // String | 

        try {
            PayloadDtoListProductDetailDto result = apiInstance.v1ProductsGet(brandId, categoryId, code, familyId, firstResult, id, isActive, isWeb, lastModificationFrom, lastModificationTo, maxResults, reference);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1ProductsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String brandId = new String(); // String | 
final String categoryId = new String(); // String | 
final String code = new String(); // String | 
final String familyId = new String(); // String | 
final Integer firstResult = new Integer(); // Integer | 
final String id = new String(); // String | 
final Boolean isActive = new Boolean(); // Boolean | 
final Boolean isWeb = new Boolean(); // Boolean | 
final Date lastModificationFrom = new Date(); // Date | 
final Date lastModificationTo = new Date(); // Date | 
final Integer maxResults = new Integer(); // Integer | 
final String reference = new String(); // String | 

try {
    final result = await api_instance.v1ProductsGet(brandId, categoryId, code, familyId, firstResult, id, isActive, isWeb, lastModificationFrom, lastModificationTo, maxResults, reference);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1ProductsGet: $e\n');
}

import org.openapitools.client.api.RestProductServiceApi;

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        String brandId = brandId_example; // String | 
        String categoryId = categoryId_example; // String | 
        String code = code_example; // String | 
        String familyId = familyId_example; // String | 
        Integer firstResult = 56; // Integer | 
        String id = id_example; // String | 
        Boolean isActive = true; // Boolean | 
        Boolean isWeb = true; // Boolean | 
        Date lastModificationFrom = 2013-10-20T19:20:30+01:00; // Date | 
        Date lastModificationTo = 2013-10-20T19:20:30+01:00; // Date | 
        Integer maxResults = 56; // Integer | 
        String reference = reference_example; // String | 

        try {
            PayloadDtoListProductDetailDto result = apiInstance.v1ProductsGet(brandId, categoryId, code, familyId, firstResult, id, isActive, isWeb, lastModificationFrom, lastModificationTo, maxResults, reference);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1ProductsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestProductServiceApi *apiInstance = [[RestProductServiceApi alloc] init];
String *brandId = brandId_example; //  (optional) (default to null)
String *categoryId = categoryId_example; //  (optional) (default to null)
String *code = code_example; //  (optional) (default to null)
String *familyId = familyId_example; //  (optional) (default to null)
Integer *firstResult = 56; //  (optional) (default to null)
String *id = id_example; //  (optional) (default to null)
Boolean *isActive = true; //  (optional) (default to null)
Boolean *isWeb = true; //  (optional) (default to null)
Date *lastModificationFrom = 2013-10-20T19:20:30+01:00; //  (optional) (default to null)
Date *lastModificationTo = 2013-10-20T19:20:30+01:00; //  (optional) (default to null)
Integer *maxResults = 56; //  (optional) (default to null)
String *reference = reference_example; //  (optional) (default to null)

[apiInstance v1ProductsGetWith:brandId
    categoryId:categoryId
    code:code
    familyId:familyId
    firstResult:firstResult
    id:id
    isActive:isActive
    isWeb:isWeb
    lastModificationFrom:lastModificationFrom
    lastModificationTo:lastModificationTo
    maxResults:maxResults
    reference:reference
              completionHandler: ^(PayloadDtoListProductDetailDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestProductServiceApi()
var opts = {
  'brandId': brandId_example, // {String} 
  'categoryId': categoryId_example, // {String} 
  'code': code_example, // {String} 
  'familyId': familyId_example, // {String} 
  'firstResult': 56, // {Integer} 
  'id': id_example, // {String} 
  'isActive': true, // {Boolean} 
  'isWeb': true, // {Boolean} 
  'lastModificationFrom': 2013-10-20T19:20:30+01:00, // {Date} 
  'lastModificationTo': 2013-10-20T19:20:30+01:00, // {Date} 
  'maxResults': 56, // {Integer} 
  'reference': reference_example // {String} 
};

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

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

namespace Example
{
    public class v1ProductsGetExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestProductServiceApi();
            var brandId = brandId_example;  // String |  (optional)  (default to null)
            var categoryId = categoryId_example;  // String |  (optional)  (default to null)
            var code = code_example;  // String |  (optional)  (default to null)
            var familyId = familyId_example;  // String |  (optional)  (default to null)
            var firstResult = 56;  // Integer |  (optional)  (default to null)
            var id = id_example;  // String |  (optional)  (default to null)
            var isActive = true;  // Boolean |  (optional)  (default to null)
            var isWeb = true;  // Boolean |  (optional)  (default to null)
            var lastModificationFrom = 2013-10-20T19:20:30+01:00;  // Date |  (optional)  (default to null)
            var lastModificationTo = 2013-10-20T19:20:30+01:00;  // Date |  (optional)  (default to null)
            var maxResults = 56;  // Integer |  (optional)  (default to null)
            var reference = reference_example;  // String |  (optional)  (default to null)

            try {
                PayloadDtoListProductDetailDto result = apiInstance.v1ProductsGet(brandId, categoryId, code, familyId, firstResult, id, isActive, isWeb, lastModificationFrom, lastModificationTo, maxResults, reference);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProductServiceApi.v1ProductsGet: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProductServiceApi();
$brandId = brandId_example; // String | 
$categoryId = categoryId_example; // String | 
$code = code_example; // String | 
$familyId = familyId_example; // String | 
$firstResult = 56; // Integer | 
$id = id_example; // String | 
$isActive = true; // Boolean | 
$isWeb = true; // Boolean | 
$lastModificationFrom = 2013-10-20T19:20:30+01:00; // Date | 
$lastModificationTo = 2013-10-20T19:20:30+01:00; // Date | 
$maxResults = 56; // Integer | 
$reference = reference_example; // String | 

try {
    $result = $api_instance->v1ProductsGet($brandId, $categoryId, $code, $familyId, $firstResult, $id, $isActive, $isWeb, $lastModificationFrom, $lastModificationTo, $maxResults, $reference);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RestProductServiceApi->v1ProductsGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestProductServiceApi->new();
my $brandId = brandId_example; # String | 
my $categoryId = categoryId_example; # String | 
my $code = code_example; # String | 
my $familyId = familyId_example; # String | 
my $firstResult = 56; # Integer | 
my $id = id_example; # String | 
my $isActive = true; # Boolean | 
my $isWeb = true; # Boolean | 
my $lastModificationFrom = 2013-10-20T19:20:30+01:00; # Date | 
my $lastModificationTo = 2013-10-20T19:20:30+01:00; # Date | 
my $maxResults = 56; # Integer | 
my $reference = reference_example; # String | 

eval {
    my $result = $api_instance->v1ProductsGet(brandId => $brandId, categoryId => $categoryId, code => $code, familyId => $familyId, firstResult => $firstResult, id => $id, isActive => $isActive, isWeb => $isWeb, lastModificationFrom => $lastModificationFrom, lastModificationTo => $lastModificationTo, maxResults => $maxResults, reference => $reference);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestProductServiceApi->v1ProductsGet: $@\n";
}

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestProductServiceApi()
brandId = brandId_example # String |  (optional) (default to null)
categoryId = categoryId_example # String |  (optional) (default to null)
code = code_example # String |  (optional) (default to null)
familyId = familyId_example # String |  (optional) (default to null)
firstResult = 56 # Integer |  (optional) (default to null)
id = id_example # String |  (optional) (default to null)
isActive = true # Boolean |  (optional) (default to null)
isWeb = true # Boolean |  (optional) (default to null)
lastModificationFrom = 2013-10-20T19:20:30+01:00 # Date |  (optional) (default to null)
lastModificationTo = 2013-10-20T19:20:30+01:00 # Date |  (optional) (default to null)
maxResults = 56 # Integer |  (optional) (default to null)
reference = reference_example # String |  (optional) (default to null)

try:
    api_response = api_instance.v1_products_get(brandId=brandId, categoryId=categoryId, code=code, familyId=familyId, firstResult=firstResult, id=id, isActive=isActive, isWeb=isWeb, lastModificationFrom=lastModificationFrom, lastModificationTo=lastModificationTo, maxResults=maxResults, reference=reference)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProductServiceApi->v1ProductsGet: %s\n" % e)

extern crate RestProductServiceApi;

pub fn main() {
    let brandId = brandId_example; // String
    let categoryId = categoryId_example; // String
    let code = code_example; // String
    let familyId = familyId_example; // String
    let firstResult = 56; // Integer
    let id = id_example; // String
    let isActive = true; // Boolean
    let isWeb = true; // Boolean
    let lastModificationFrom = 2013-10-20T19:20:30+01:00; // Date
    let lastModificationTo = 2013-10-20T19:20:30+01:00; // Date
    let maxResults = 56; // Integer
    let reference = reference_example; // String

    let mut context = RestProductServiceApi::Context::default();
    let result = client.v1ProductsGet(brandId, categoryId, code, familyId, firstResult, id, isActive, isWeb, lastModificationFrom, lastModificationTo, maxResults, reference, &context).wait();

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

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

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

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        array[ProductDto] productDto = ; // array[ProductDto] | 

        try {
            PayloadDtoVoid result = apiInstance.v1ProductsPost(productDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1ProductsPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[ProductDto] productDto = new array[ProductDto](); // array[ProductDto] | 

try {
    final result = await api_instance.v1ProductsPost(productDto);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1ProductsPost: $e\n');
}

import org.openapitools.client.api.RestProductServiceApi;

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        array[ProductDto] productDto = ; // array[ProductDto] | 

        try {
            PayloadDtoVoid result = apiInstance.v1ProductsPost(productDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1ProductsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestProductServiceApi *apiInstance = [[RestProductServiceApi alloc] init];
array[ProductDto] *productDto = ; //  (optional)

[apiInstance v1ProductsPostWith:productDto
              completionHandler: ^(PayloadDtoVoid output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestProductServiceApi()
var opts = {
  'productDto':  // {array[ProductDto]} 
};

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

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

namespace Example
{
    public class v1ProductsPostExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestProductServiceApi();
            var productDto = new array[ProductDto](); // array[ProductDto] |  (optional) 

            try {
                PayloadDtoVoid result = apiInstance.v1ProductsPost(productDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProductServiceApi.v1ProductsPost: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProductServiceApi();
$productDto = ; // array[ProductDto] | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestProductServiceApi->new();
my $productDto = [WWW::OPenAPIClient::Object::array[ProductDto]->new()]; # array[ProductDto] | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestProductServiceApi()
productDto =  # array[ProductDto] |  (optional)

try:
    api_response = api_instance.v1_products_post(productDto=productDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProductServiceApi->v1ProductsPost: %s\n" % e)

extern crate RestProductServiceApi;

pub fn main() {
    let productDto = ; // array[ProductDto]

    let mut context = RestProductServiceApi::Context::default();
    let result = client.v1ProductsPost(productDto, &context).wait();

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

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

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

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        Integer firstResult = 56; // Integer | 
        String id = id_example; // String | 
        Integer maxResults = 56; // Integer | 
        String type = type_example; // String | 

        try {
            PayloadDtoListTaxDto result = apiInstance.v1TaxesGet(firstResult, id, maxResults, type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1TaxesGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer firstResult = new Integer(); // Integer | 
final String id = new String(); // String | 
final Integer maxResults = new Integer(); // Integer | 
final String type = new String(); // String | 

try {
    final result = await api_instance.v1TaxesGet(firstResult, id, maxResults, type);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1TaxesGet: $e\n');
}

import org.openapitools.client.api.RestProductServiceApi;

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        Integer firstResult = 56; // Integer | 
        String id = id_example; // String | 
        Integer maxResults = 56; // Integer | 
        String type = type_example; // String | 

        try {
            PayloadDtoListTaxDto result = apiInstance.v1TaxesGet(firstResult, id, maxResults, type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1TaxesGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestProductServiceApi *apiInstance = [[RestProductServiceApi alloc] init];
Integer *firstResult = 56; //  (optional) (default to null)
String *id = id_example; //  (optional) (default to null)
Integer *maxResults = 56; //  (optional) (default to null)
String *type = type_example; //  (optional) (default to null)

[apiInstance v1TaxesGetWith:firstResult
    id:id
    maxResults:maxResults
    type:type
              completionHandler: ^(PayloadDtoListTaxDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestProductServiceApi()
var opts = {
  'firstResult': 56, // {Integer} 
  'id': id_example, // {String} 
  'maxResults': 56, // {Integer} 
  'type': type_example // {String} 
};

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

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

namespace Example
{
    public class v1TaxesGetExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestProductServiceApi();
            var firstResult = 56;  // Integer |  (optional)  (default to null)
            var id = id_example;  // String |  (optional)  (default to null)
            var maxResults = 56;  // Integer |  (optional)  (default to null)
            var type = type_example;  // String |  (optional)  (default to null)

            try {
                PayloadDtoListTaxDto result = apiInstance.v1TaxesGet(firstResult, id, maxResults, type);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProductServiceApi.v1TaxesGet: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProductServiceApi();
$firstResult = 56; // Integer | 
$id = id_example; // String | 
$maxResults = 56; // Integer | 
$type = type_example; // String | 

try {
    $result = $api_instance->v1TaxesGet($firstResult, $id, $maxResults, $type);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RestProductServiceApi->v1TaxesGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestProductServiceApi->new();
my $firstResult = 56; # Integer | 
my $id = id_example; # String | 
my $maxResults = 56; # Integer | 
my $type = type_example; # String | 

eval {
    my $result = $api_instance->v1TaxesGet(firstResult => $firstResult, id => $id, maxResults => $maxResults, type => $type);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestProductServiceApi->v1TaxesGet: $@\n";
}

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestProductServiceApi()
firstResult = 56 # Integer |  (optional) (default to null)
id = id_example # String |  (optional) (default to null)
maxResults = 56 # Integer |  (optional) (default to null)
type = type_example # String |  (optional) (default to null)

try:
    api_response = api_instance.v1_taxes_get(firstResult=firstResult, id=id, maxResults=maxResults, type=type)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProductServiceApi->v1TaxesGet: %s\n" % e)

extern crate RestProductServiceApi;

pub fn main() {
    let firstResult = 56; // Integer
    let id = id_example; // String
    let maxResults = 56; // Integer
    let type = type_example; // String

    let mut context = RestProductServiceApi::Context::default();
    let result = client.v1TaxesGet(firstResult, id, maxResults, type, &context).wait();

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

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

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

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        array[TaxDto] taxDto = ; // array[TaxDto] | 

        try {
            PayloadDtoVoid result = apiInstance.v1TaxesPost(taxDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1TaxesPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[TaxDto] taxDto = new array[TaxDto](); // array[TaxDto] | 

try {
    final result = await api_instance.v1TaxesPost(taxDto);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1TaxesPost: $e\n');
}

import org.openapitools.client.api.RestProductServiceApi;

public class RestProductServiceApiExample {
    public static void main(String[] args) {
        RestProductServiceApi apiInstance = new RestProductServiceApi();
        array[TaxDto] taxDto = ; // array[TaxDto] | 

        try {
            PayloadDtoVoid result = apiInstance.v1TaxesPost(taxDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductServiceApi#v1TaxesPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestProductServiceApi *apiInstance = [[RestProductServiceApi alloc] init];
array[TaxDto] *taxDto = ; //  (optional)

[apiInstance v1TaxesPostWith:taxDto
              completionHandler: ^(PayloadDtoVoid output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestProductServiceApi()
var opts = {
  'taxDto':  // {array[TaxDto]} 
};

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

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

namespace Example
{
    public class v1TaxesPostExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestProductServiceApi();
            var taxDto = new array[TaxDto](); // array[TaxDto] |  (optional) 

            try {
                PayloadDtoVoid result = apiInstance.v1TaxesPost(taxDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProductServiceApi.v1TaxesPost: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProductServiceApi();
$taxDto = ; // array[TaxDto] | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestProductServiceApi->new();
my $taxDto = [WWW::OPenAPIClient::Object::array[TaxDto]->new()]; # array[TaxDto] | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestProductServiceApi()
taxDto =  # array[TaxDto] |  (optional)

try:
    api_response = api_instance.v1_taxes_post(taxDto=taxDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProductServiceApi->v1TaxesPost: %s\n" % e)

extern crate RestProductServiceApi;

pub fn main() {
    let taxDto = ; // array[TaxDto]

    let mut context = RestProductServiceApi::Context::default();
    let result = client.v1TaxesPost(taxDto, &context).wait();

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

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

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

public class RestSalesServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestSalesServiceApi apiInstance = new RestSalesServiceApi();
        SetTransmittedDto setTransmittedDto = ; // SetTransmittedDto | 

        try {
            PayloadDtoVoid result = apiInstance.v1SetTransmittedPost(setTransmittedDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestSalesServiceApi#v1SetTransmittedPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SetTransmittedDto setTransmittedDto = new SetTransmittedDto(); // SetTransmittedDto | 

try {
    final result = await api_instance.v1SetTransmittedPost(setTransmittedDto);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1SetTransmittedPost: $e\n');
}

import org.openapitools.client.api.RestSalesServiceApi;

public class RestSalesServiceApiExample {
    public static void main(String[] args) {
        RestSalesServiceApi apiInstance = new RestSalesServiceApi();
        SetTransmittedDto setTransmittedDto = ; // SetTransmittedDto | 

        try {
            PayloadDtoVoid result = apiInstance.v1SetTransmittedPost(setTransmittedDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestSalesServiceApi#v1SetTransmittedPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestSalesServiceApi *apiInstance = [[RestSalesServiceApi alloc] init];
SetTransmittedDto *setTransmittedDto = ; //  (optional)

[apiInstance v1SetTransmittedPostWith:setTransmittedDto
              completionHandler: ^(PayloadDtoVoid output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestSalesServiceApi()
var opts = {
  'setTransmittedDto':  // {SetTransmittedDto} 
};

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

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

namespace Example
{
    public class v1SetTransmittedPostExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestSalesServiceApi();
            var setTransmittedDto = new SetTransmittedDto(); // SetTransmittedDto |  (optional) 

            try {
                PayloadDtoVoid result = apiInstance.v1SetTransmittedPost(setTransmittedDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestSalesServiceApi.v1SetTransmittedPost: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestSalesServiceApi();
$setTransmittedDto = ; // SetTransmittedDto | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestSalesServiceApi->new();
my $setTransmittedDto = WWW::OPenAPIClient::Object::SetTransmittedDto->new(); # SetTransmittedDto | 

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

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestSalesServiceApi()
setTransmittedDto =  # SetTransmittedDto |  (optional)

try:
    api_response = api_instance.v1_set_transmitted_post(setTransmittedDto=setTransmittedDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestSalesServiceApi->v1SetTransmittedPost: %s\n" % e)

extern crate RestSalesServiceApi;

pub fn main() {
    let setTransmittedDto = ; // SetTransmittedDto

    let mut context = RestSalesServiceApi::Context::default();
    let result = client.v1SetTransmittedPost(setTransmittedDto, &context).wait();

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

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

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

public class RestSalesServiceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: SecurityScheme
        HttpBearerAuth SecurityScheme = (HttpBearerAuth) defaultClient.getAuthentication("SecurityScheme");
        SecurityScheme.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RestSalesServiceApi apiInstance = new RestSalesServiceApi();
        date creationDateFrom = 2013-10-20; // date | 
        date creationDateTo = 2013-10-20; // date | 
        Integer emitter = 56; // Integer | 
        Integer firstResult = 56; // Integer | 
        String govtId = govtId_example; // String | 
        Integer maxResults = 56; // Integer | 
        Integer ticketId = 56; // Integer | 
        String ticketNumber = ticketNumber_example; // String | 
        Boolean transmitted = true; // Boolean | 

        try {
            PayloadDtoListTicketDto result = apiInstance.v1TicketsGet(creationDateFrom, creationDateTo, emitter, firstResult, govtId, maxResults, ticketId, ticketNumber, transmitted);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestSalesServiceApi#v1TicketsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final date creationDateFrom = new date(); // date | 
final date creationDateTo = new date(); // date | 
final Integer emitter = new Integer(); // Integer | 
final Integer firstResult = new Integer(); // Integer | 
final String govtId = new String(); // String | 
final Integer maxResults = new Integer(); // Integer | 
final Integer ticketId = new Integer(); // Integer | 
final String ticketNumber = new String(); // String | 
final Boolean transmitted = new Boolean(); // Boolean | 

try {
    final result = await api_instance.v1TicketsGet(creationDateFrom, creationDateTo, emitter, firstResult, govtId, maxResults, ticketId, ticketNumber, transmitted);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1TicketsGet: $e\n');
}

import org.openapitools.client.api.RestSalesServiceApi;

public class RestSalesServiceApiExample {
    public static void main(String[] args) {
        RestSalesServiceApi apiInstance = new RestSalesServiceApi();
        date creationDateFrom = 2013-10-20; // date | 
        date creationDateTo = 2013-10-20; // date | 
        Integer emitter = 56; // Integer | 
        Integer firstResult = 56; // Integer | 
        String govtId = govtId_example; // String | 
        Integer maxResults = 56; // Integer | 
        Integer ticketId = 56; // Integer | 
        String ticketNumber = ticketNumber_example; // String | 
        Boolean transmitted = true; // Boolean | 

        try {
            PayloadDtoListTicketDto result = apiInstance.v1TicketsGet(creationDateFrom, creationDateTo, emitter, firstResult, govtId, maxResults, ticketId, ticketNumber, transmitted);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestSalesServiceApi#v1TicketsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: SecurityScheme
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RestSalesServiceApi *apiInstance = [[RestSalesServiceApi alloc] init];
date *creationDateFrom = 2013-10-20; //  (optional) (default to null)
date *creationDateTo = 2013-10-20; //  (optional) (default to null)
Integer *emitter = 56; //  (optional) (default to null)
Integer *firstResult = 56; //  (optional) (default to null)
String *govtId = govtId_example; //  (optional) (default to null)
Integer *maxResults = 56; //  (optional) (default to null)
Integer *ticketId = 56; //  (optional) (default to null)
String *ticketNumber = ticketNumber_example; //  (optional) (default to null)
Boolean *transmitted = true; //  (optional) (default to null)

[apiInstance v1TicketsGetWith:creationDateFrom
    creationDateTo:creationDateTo
    emitter:emitter
    firstResult:firstResult
    govtId:govtId
    maxResults:maxResults
    ticketId:ticketId
    ticketNumber:ticketNumber
    transmitted:transmitted
              completionHandler: ^(PayloadDtoListTicketDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArComSystemStarposapiQuarkusApi = require('ar_com_system_starposapi_quarkus_api');
var defaultClient = ArComSystemStarposapiQuarkusApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: SecurityScheme
var SecurityScheme = defaultClient.authentications['SecurityScheme'];
SecurityScheme.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArComSystemStarposapiQuarkusApi.RestSalesServiceApi()
var opts = {
  'creationDateFrom': 2013-10-20, // {date} 
  'creationDateTo': 2013-10-20, // {date} 
  'emitter': 56, // {Integer} 
  'firstResult': 56, // {Integer} 
  'govtId': govtId_example, // {String} 
  'maxResults': 56, // {Integer} 
  'ticketId': 56, // {Integer} 
  'ticketNumber': ticketNumber_example, // {String} 
  'transmitted': true // {Boolean} 
};

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

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

namespace Example
{
    public class v1TicketsGetExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: SecurityScheme
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RestSalesServiceApi();
            var creationDateFrom = 2013-10-20;  // date |  (optional)  (default to null)
            var creationDateTo = 2013-10-20;  // date |  (optional)  (default to null)
            var emitter = 56;  // Integer |  (optional)  (default to null)
            var firstResult = 56;  // Integer |  (optional)  (default to null)
            var govtId = govtId_example;  // String |  (optional)  (default to null)
            var maxResults = 56;  // Integer |  (optional)  (default to null)
            var ticketId = 56;  // Integer |  (optional)  (default to null)
            var ticketNumber = ticketNumber_example;  // String |  (optional)  (default to null)
            var transmitted = true;  // Boolean |  (optional)  (default to null)

            try {
                PayloadDtoListTicketDto result = apiInstance.v1TicketsGet(creationDateFrom, creationDateTo, emitter, firstResult, govtId, maxResults, ticketId, ticketNumber, transmitted);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestSalesServiceApi.v1TicketsGet: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: SecurityScheme
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestSalesServiceApi();
$creationDateFrom = 2013-10-20; // date | 
$creationDateTo = 2013-10-20; // date | 
$emitter = 56; // Integer | 
$firstResult = 56; // Integer | 
$govtId = govtId_example; // String | 
$maxResults = 56; // Integer | 
$ticketId = 56; // Integer | 
$ticketNumber = ticketNumber_example; // String | 
$transmitted = true; // Boolean | 

try {
    $result = $api_instance->v1TicketsGet($creationDateFrom, $creationDateTo, $emitter, $firstResult, $govtId, $maxResults, $ticketId, $ticketNumber, $transmitted);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RestSalesServiceApi->v1TicketsGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestSalesServiceApi->new();
my $creationDateFrom = 2013-10-20; # date | 
my $creationDateTo = 2013-10-20; # date | 
my $emitter = 56; # Integer | 
my $firstResult = 56; # Integer | 
my $govtId = govtId_example; # String | 
my $maxResults = 56; # Integer | 
my $ticketId = 56; # Integer | 
my $ticketNumber = ticketNumber_example; # String | 
my $transmitted = true; # Boolean | 

eval {
    my $result = $api_instance->v1TicketsGet(creationDateFrom => $creationDateFrom, creationDateTo => $creationDateTo, emitter => $emitter, firstResult => $firstResult, govtId => $govtId, maxResults => $maxResults, ticketId => $ticketId, ticketNumber => $ticketNumber, transmitted => $transmitted);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestSalesServiceApi->v1TicketsGet: $@\n";
}

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

# Configure Bearer (JWT) access token for authorization: SecurityScheme
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RestSalesServiceApi()
creationDateFrom = 2013-10-20 # date |  (optional) (default to null)
creationDateTo = 2013-10-20 # date |  (optional) (default to null)
emitter = 56 # Integer |  (optional) (default to null)
firstResult = 56 # Integer |  (optional) (default to null)
govtId = govtId_example # String |  (optional) (default to null)
maxResults = 56 # Integer |  (optional) (default to null)
ticketId = 56 # Integer |  (optional) (default to null)
ticketNumber = ticketNumber_example # String |  (optional) (default to null)
transmitted = true # Boolean |  (optional) (default to null)

try:
    api_response = api_instance.v1_tickets_get(creationDateFrom=creationDateFrom, creationDateTo=creationDateTo, emitter=emitter, firstResult=firstResult, govtId=govtId, maxResults=maxResults, ticketId=ticketId, ticketNumber=ticketNumber, transmitted=transmitted)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestSalesServiceApi->v1TicketsGet: %s\n" % e)

extern crate RestSalesServiceApi;

pub fn main() {
    let creationDateFrom = 2013-10-20; // date
    let creationDateTo = 2013-10-20; // date
    let emitter = 56; // Integer
    let firstResult = 56; // Integer
    let govtId = govtId_example; // String
    let maxResults = 56; // Integer
    let ticketId = 56; // Integer
    let ticketNumber = ticketNumber_example; // String
    let transmitted = true; // Boolean

    let mut context = RestSalesServiceApi::Context::default();
    let result = client.v1TicketsGet(creationDateFrom, creationDateTo, emitter, firstResult, govtId, maxResults, ticketId, ticketNumber, transmitted, &context).wait();

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