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

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

public class PetApiExample {

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

        PetApi apiInstance = new PetApi();
        Pet pet = ; // Pet | 
        try {
            apiInstance.addPet(pet);
        } catch (ApiException e) {
            System.err.println("Exception when calling PetApi#addPet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.PetApi;

public class PetApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

Pet *pet = ; // 

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

// Add a new pet to the store
[apiInstance addPetWith:pet
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenApiPetstore = require('open_api_petstore');
var defaultClient = OpenApiPetstore.ApiClient.instance;

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

var api = new OpenApiPetstore.PetApi()
var pet = ; // {Pet} 

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

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

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

            var apiInstance = new PetApi();
            var pet = new Pet(); // Pet | 

            try
            {
                // Add a new pet to the store
                apiInstance.addPet(pet);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PetApi.addPet: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new OpenAPITools\Client\Api\PetApi();
$pet = ; // Pet | 

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

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

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

my $api_instance = WWW::OPenAPIClient::PetApi->new();
my $pet = WWW::OPenAPIClient::Object::Pet->new(); # Pet | 

eval { 
    $api_instance->addPet(pet => $pet);
};
if ($@) {
    warn "Exception when calling PetApi->addPet: $@\n";
}

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

# Configure OAuth2 access token for authorization: petstore_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = openapi_client.PetApi()
pet =  # Pet | 

try: 
    # Add a new pet to the store
    api_instance.add_pet(pet)
except ApiException as e:
    print("Exception when calling PetApi->addPet: %s\n" % e)

extern crate PetApi;

pub fn main() {
    let pet = ; // Pet

    let mut context = PetApi::Context::default();
    let result = client.addPet(pet, &context).wait();
    println!("{:?}", result);

}

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

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

public class PetApiExample {

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

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

import org.openapitools.client.api.PetApi;

public class PetApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

Long *petId = 789; // Pet id to delete
String *apiKey = apiKey_example; //  (optional)

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

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

var OpenApiPetstore = require('open_api_petstore');
var defaultClient = OpenApiPetstore.ApiClient.instance;

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

var api = new OpenApiPetstore.PetApi()
var petId = 789; // {Long} Pet id to delete
var opts = {
  'apiKey': apiKey_example // {String} 
};

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

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

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

            var apiInstance = new PetApi();
            var petId = 789;  // Long | Pet id to delete
            var apiKey = apiKey_example;  // String |  (optional) 

            try
            {
                // Deletes a pet
                apiInstance.deletePet(petId, apiKey);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PetApi.deletePet: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new OpenAPITools\Client\Api\PetApi();
$petId = 789; // Long | Pet id to delete
$apiKey = apiKey_example; // String | 

try {
    $api_instance->deletePet($petId, $apiKey);
} catch (Exception $e) {
    echo 'Exception when calling PetApi->deletePet: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

my $api_instance = WWW::OPenAPIClient::PetApi->new();
my $petId = 789; # Long | Pet id to delete
my $apiKey = apiKey_example; # String | 

eval { 
    $api_instance->deletePet(petId => $petId, apiKey => $apiKey);
};
if ($@) {
    warn "Exception when calling PetApi->deletePet: $@\n";
}

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

# Configure OAuth2 access token for authorization: petstore_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = openapi_client.PetApi()
petId = 789 # Long | Pet id to delete
apiKey = apiKey_example # String |  (optional)

try: 
    # Deletes a pet
    api_instance.delete_pet(petId, apiKey=apiKey)
except ApiException as e:
    print("Exception when calling PetApi->deletePet: %s\n" % e)

extern crate PetApi;

pub fn main() {
    let petId = 789; // Long
    let apiKey = apiKey_example; // String

    let mut context = PetApi::Context::default();
    let result = client.deletePet(petId, apiKey, &context).wait();
    println!("{:?}", result);

}

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

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

public class PetApiExample {

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

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

import org.openapitools.client.api.PetApi;

public class PetApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

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

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

// Finds Pets by status
[apiInstance findPetsByStatusWith:status
              completionHandler: ^(array[Pet] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenApiPetstore = require('open_api_petstore');
var defaultClient = OpenApiPetstore.ApiClient.instance;

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

var api = new OpenApiPetstore.PetApi()
var status = ; // {array[String]} Status values that need to be considered for filter

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

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

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

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

            try
            {
                // Finds Pets by status
                array[Pet] result = apiInstance.findPetsByStatus(status);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PetApi.findPetsByStatus: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

# Configure OAuth2 access token for authorization: petstore_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try: 
    # Finds Pets by status
    api_response = api_instance.find_pets_by_status(status)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PetApi->findPetsByStatus: %s\n" % e)

extern crate PetApi;

pub fn main() {
    let status = ; // array[String]

    let mut context = PetApi::Context::default();
    let result = client.findPetsByStatus(status, &context).wait();
    println!("{:?}", result);

}

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

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

public class PetApiExample {

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

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

import org.openapitools.client.api.PetApi;

public class PetApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

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

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

// Finds Pets by tags
[apiInstance findPetsByTagsWith:tags
              completionHandler: ^(array[Pet] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenApiPetstore = require('open_api_petstore');
var defaultClient = OpenApiPetstore.ApiClient.instance;

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

var api = new OpenApiPetstore.PetApi()
var tags = ; // {array[String]} Tags to filter by

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

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

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

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

            try
            {
                // Finds Pets by tags
                array[Pet] result = apiInstance.findPetsByTags(tags);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PetApi.findPetsByTags: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

# Configure OAuth2 access token for authorization: petstore_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try: 
    # Finds Pets by tags
    api_response = api_instance.find_pets_by_tags(tags)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PetApi->findPetsByTags: %s\n" % e)

extern crate PetApi;

pub fn main() {
    let tags = ; // array[String]

    let mut context = PetApi::Context::default();
    let result = client.findPetsByTags(tags, &context).wait();
    println!("{:?}", result);

}

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

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

public class PetApiExample {

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

        PetApi apiInstance = new PetApi();
        Long petId = 789; // Long | ID of pet to return
        try {
            Pet result = apiInstance.getPetById(petId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PetApi#getPetById");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.PetApi;

public class PetApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

Long *petId = 789; // ID of pet to return

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

// Find pet by ID
[apiInstance getPetByIdWith:petId
              completionHandler: ^(Pet output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenApiPetstore = require('open_api_petstore');
var defaultClient = OpenApiPetstore.ApiClient.instance;

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

var api = new OpenApiPetstore.PetApi()
var petId = 789; // {Long} ID of pet to return

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

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

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

            var apiInstance = new PetApi();
            var petId = 789;  // Long | ID of pet to return

            try
            {
                // Find pet by ID
                Pet result = apiInstance.getPetById(petId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PetApi.getPetById: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new OpenAPITools\Client\Api\PetApi();
$petId = 789; // Long | ID of pet to return

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

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

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

my $api_instance = WWW::OPenAPIClient::PetApi->new();
my $petId = 789; # Long | ID of pet to return

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

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

# Configure API key authorization: api_key
openapi_client.configuration.api_key['api_key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['api_key'] = 'Bearer'

# create an instance of the API class
api_instance = openapi_client.PetApi()
petId = 789 # Long | ID of pet to return

try: 
    # Find pet by ID
    api_response = api_instance.get_pet_by_id(petId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PetApi->getPetById: %s\n" % e)

extern crate PetApi;

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

    let mut context = PetApi::Context::default();
    let result = client.getPetById(petId, &context).wait();
    println!("{:?}", result);

}

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

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

public class PetApiExample {

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

        PetApi apiInstance = new PetApi();
        Pet pet = ; // Pet | 
        try {
            apiInstance.updatePet(pet);
        } catch (ApiException e) {
            System.err.println("Exception when calling PetApi#updatePet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.PetApi;

public class PetApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

Pet *pet = ; // 

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

// Update an existing pet
[apiInstance updatePetWith:pet
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenApiPetstore = require('open_api_petstore');
var defaultClient = OpenApiPetstore.ApiClient.instance;

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

var api = new OpenApiPetstore.PetApi()
var pet = ; // {Pet} 

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

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

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

            var apiInstance = new PetApi();
            var pet = new Pet(); // Pet | 

            try
            {
                // Update an existing pet
                apiInstance.updatePet(pet);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PetApi.updatePet: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new OpenAPITools\Client\Api\PetApi();
$pet = ; // Pet | 

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

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

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

my $api_instance = WWW::OPenAPIClient::PetApi->new();
my $pet = WWW::OPenAPIClient::Object::Pet->new(); # Pet | 

eval { 
    $api_instance->updatePet(pet => $pet);
};
if ($@) {
    warn "Exception when calling PetApi->updatePet: $@\n";
}

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

# Configure OAuth2 access token for authorization: petstore_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = openapi_client.PetApi()
pet =  # Pet | 

try: 
    # Update an existing pet
    api_instance.update_pet(pet)
except ApiException as e:
    print("Exception when calling PetApi->updatePet: %s\n" % e)

extern crate PetApi;

pub fn main() {
    let pet = ; // Pet

    let mut context = PetApi::Context::default();
    let result = client.updatePet(pet, &context).wait();
    println!("{:?}", result);

}

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

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

public class PetApiExample {

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

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

import org.openapitools.client.api.PetApi;

public class PetApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

Long *petId = 789; // ID of pet that needs to be updated
String *name = name_example; // Updated name of the pet (optional) (default to null)
String *status = status_example; // Updated status of the pet (optional) (default to null)

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

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

var OpenApiPetstore = require('open_api_petstore');
var defaultClient = OpenApiPetstore.ApiClient.instance;

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

var api = new OpenApiPetstore.PetApi()
var petId = 789; // {Long} ID of pet that needs to be updated
var opts = {
  'name': name_example, // {String} Updated name of the pet
  'status': status_example // {String} Updated status of the pet
};

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

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

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

            var apiInstance = new PetApi();
            var petId = 789;  // Long | ID of pet that needs to be updated
            var name = name_example;  // String | Updated name of the pet (optional)  (default to null)
            var status = status_example;  // String | Updated status of the pet (optional)  (default to null)

            try
            {
                // Updates a pet in the store with form data
                apiInstance.updatePetWithForm(petId, name, status);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PetApi.updatePetWithForm: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new OpenAPITools\Client\Api\PetApi();
$petId = 789; // Long | ID of pet that needs to be updated
$name = name_example; // String | Updated name of the pet
$status = status_example; // String | Updated status of the pet

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

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

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

my $api_instance = WWW::OPenAPIClient::PetApi->new();
my $petId = 789; # Long | ID of pet that needs to be updated
my $name = name_example; # String | Updated name of the pet
my $status = status_example; # String | Updated status of the pet

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

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

# Configure OAuth2 access token for authorization: petstore_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = openapi_client.PetApi()
petId = 789 # Long | ID of pet that needs to be updated
name = name_example # String | Updated name of the pet (optional) (default to null)
status = status_example # String | Updated status of the pet (optional) (default to null)

try: 
    # Updates a pet in the store with form data
    api_instance.update_pet_with_form(petId, name=name, status=status)
except ApiException as e:
    print("Exception when calling PetApi->updatePetWithForm: %s\n" % e)

extern crate PetApi;

pub fn main() {
    let petId = 789; // Long
    let name = name_example; // String
    let status = status_example; // String

    let mut context = PetApi::Context::default();
    let result = client.updatePetWithForm(petId, name, status, &context).wait();
    println!("{:?}", result);

}

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

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

public class PetApiExample {

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

        PetApi apiInstance = new PetApi();
        Long petId = 789; // Long | ID of pet to update
        String additionalMetadata = additionalMetadata_example; // String | Additional data to pass to server
        File file = BINARY_DATA_HERE; // File | file to upload
        try {
            ApiResponse result = apiInstance.uploadFile(petId, additionalMetadata, file);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PetApi#uploadFile");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.PetApi;

public class PetApiExample {

    public static void main(String[] args) {
        PetApi apiInstance = new PetApi();
        Long petId = 789; // Long | ID of pet to update
        String additionalMetadata = additionalMetadata_example; // String | Additional data to pass to server
        File file = BINARY_DATA_HERE; // File | file to upload
        try {
            ApiResponse result = apiInstance.uploadFile(petId, additionalMetadata, file);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PetApi#uploadFile");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

Long *petId = 789; // ID of pet to update
String *additionalMetadata = additionalMetadata_example; // Additional data to pass to server (optional) (default to null)
File *file = BINARY_DATA_HERE; // file to upload (optional) (default to null)

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

// uploads an image
[apiInstance uploadFileWith:petId
    additionalMetadata:additionalMetadata
    file:file
              completionHandler: ^(ApiResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenApiPetstore = require('open_api_petstore');
var defaultClient = OpenApiPetstore.ApiClient.instance;

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

var api = new OpenApiPetstore.PetApi()
var petId = 789; // {Long} ID of pet to update
var opts = {
  'additionalMetadata': additionalMetadata_example, // {String} Additional data to pass to server
  'file': BINARY_DATA_HERE // {File} file to upload
};

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

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

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

            var apiInstance = new PetApi();
            var petId = 789;  // Long | ID of pet to update
            var additionalMetadata = additionalMetadata_example;  // String | Additional data to pass to server (optional)  (default to null)
            var file = BINARY_DATA_HERE;  // File | file to upload (optional)  (default to null)

            try
            {
                // uploads an image
                ApiResponse result = apiInstance.uploadFile(petId, additionalMetadata, file);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PetApi.uploadFile: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new OpenAPITools\Client\Api\PetApi();
$petId = 789; // Long | ID of pet to update
$additionalMetadata = additionalMetadata_example; // String | Additional data to pass to server
$file = BINARY_DATA_HERE; // File | file to upload

try {
    $result = $api_instance->uploadFile($petId, $additionalMetadata, $file);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PetApi->uploadFile: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

my $api_instance = WWW::OPenAPIClient::PetApi->new();
my $petId = 789; # Long | ID of pet to update
my $additionalMetadata = additionalMetadata_example; # String | Additional data to pass to server
my $file = BINARY_DATA_HERE; # File | file to upload

eval { 
    my $result = $api_instance->uploadFile(petId => $petId, additionalMetadata => $additionalMetadata, file => $file);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PetApi->uploadFile: $@\n";
}

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

# Configure OAuth2 access token for authorization: petstore_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = openapi_client.PetApi()
petId = 789 # Long | ID of pet to update
additionalMetadata = additionalMetadata_example # String | Additional data to pass to server (optional) (default to null)
file = BINARY_DATA_HERE # File | file to upload (optional) (default to null)

try: 
    # uploads an image
    api_response = api_instance.upload_file(petId, additionalMetadata=additionalMetadata, file=file)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PetApi->uploadFile: %s\n" % e)

extern crate PetApi;

pub fn main() {
    let petId = 789; // Long
    let additionalMetadata = additionalMetadata_example; // String
    let file = BINARY_DATA_HERE; // File

    let mut context = PetApi::Context::default();
    let result = client.uploadFile(petId, additionalMetadata, file, &context).wait();
    println!("{:?}", result);

}

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

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

public class StoreApiExample {

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

import org.openapitools.client.api.StoreApi;

public class StoreApiExample {

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

String *orderId = orderId_example; // ID of the order that needs to be deleted

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

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

var OpenApiPetstore = require('open_api_petstore');

var api = new OpenApiPetstore.StoreApi()
var orderId = orderId_example; // {String} ID of the order that needs to be deleted

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

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

namespace Example
{
    public class deleteOrderExample
    {
        public void main()
        {
            
            var apiInstance = new StoreApi();
            var orderId = orderId_example;  // String | ID of the order that needs to be deleted

            try
            {
                // Delete purchase order by ID
                apiInstance.deleteOrder(orderId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling StoreApi.deleteOrder: " + e.Message );
            }
        }
    }
}

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

$api_instance = new OpenAPITools\Client\Api\StoreApi();
$orderId = orderId_example; // String | ID of the order that needs to be deleted

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

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

my $api_instance = WWW::OPenAPIClient::StoreApi->new();
my $orderId = orderId_example; # String | ID of the order that needs to be deleted

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

try: 
    # Delete purchase order by ID
    api_instance.delete_order(orderId)
except ApiException as e:
    print("Exception when calling StoreApi->deleteOrder: %s\n" % e)

extern crate StoreApi;

pub fn main() {
    let orderId = orderId_example; // String

    let mut context = StoreApi::Context::default();
    let result = client.deleteOrder(orderId, &context).wait();
    println!("{:?}", result);

}

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

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

public class StoreApiExample {

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

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

import org.openapitools.client.api.StoreApi;

public class StoreApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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


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

// Returns pet inventories by status
[apiInstance getInventoryWithCompletionHandler: 
              ^(map['String', 'Integer'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenApiPetstore = require('open_api_petstore');
var defaultClient = OpenApiPetstore.ApiClient.instance;

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

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

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

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

            var apiInstance = new StoreApi();

            try
            {
                // Returns pet inventories by status
                map['String', 'Integer'] result = apiInstance.getInventory();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling StoreApi.getInventory: " + e.Message );
            }
        }
    }
}

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

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

$api_instance = new OpenAPITools\Client\Api\StoreApi();

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

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

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

my $api_instance = WWW::OPenAPIClient::StoreApi->new();

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

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

# Configure API key authorization: api_key
openapi_client.configuration.api_key['api_key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['api_key'] = 'Bearer'

# create an instance of the API class
api_instance = openapi_client.StoreApi()

try: 
    # Returns pet inventories by status
    api_response = api_instance.get_inventory()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling StoreApi->getInventory: %s\n" % e)

extern crate StoreApi;

pub fn main() {

    let mut context = StoreApi::Context::default();
    let result = client.getInventory(&context).wait();
    println!("{:?}", result);

}

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

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

public class StoreApiExample {

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

import org.openapitools.client.api.StoreApi;

public class StoreApiExample {

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

Long *orderId = 789; // ID of pet that needs to be fetched

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

// Find purchase order by ID
[apiInstance getOrderByIdWith:orderId
              completionHandler: ^(Order output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenApiPetstore = require('open_api_petstore');

var api = new OpenApiPetstore.StoreApi()
var orderId = 789; // {Long} ID of pet that needs to be fetched

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

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

namespace Example
{
    public class getOrderByIdExample
    {
        public void main()
        {
            
            var apiInstance = new StoreApi();
            var orderId = 789;  // Long | ID of pet that needs to be fetched

            try
            {
                // Find purchase order by ID
                Order result = apiInstance.getOrderById(orderId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling StoreApi.getOrderById: " + e.Message );
            }
        }
    }
}

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

$api_instance = new OpenAPITools\Client\Api\StoreApi();
$orderId = 789; // Long | ID of pet that needs to be fetched

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

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

my $api_instance = WWW::OPenAPIClient::StoreApi->new();
my $orderId = 789; # Long | ID of pet that needs to be fetched

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

try: 
    # Find purchase order by ID
    api_response = api_instance.get_order_by_id(orderId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling StoreApi->getOrderById: %s\n" % e)

extern crate StoreApi;

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

    let mut context = StoreApi::Context::default();
    let result = client.getOrderById(orderId, &context).wait();
    println!("{:?}", result);

}

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

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

public class StoreApiExample {

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

import org.openapitools.client.api.StoreApi;

public class StoreApiExample {

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

Order *order = ; // 

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

// Place an order for a pet
[apiInstance placeOrderWith:order
              completionHandler: ^(Order output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenApiPetstore = require('open_api_petstore');

var api = new OpenApiPetstore.StoreApi()
var order = ; // {Order} 

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

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

namespace Example
{
    public class placeOrderExample
    {
        public void main()
        {
            
            var apiInstance = new StoreApi();
            var order = new Order(); // Order | 

            try
            {
                // Place an order for a pet
                Order result = apiInstance.placeOrder(order);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling StoreApi.placeOrder: " + e.Message );
            }
        }
    }
}

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

$api_instance = new OpenAPITools\Client\Api\StoreApi();
$order = ; // Order | 

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

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

my $api_instance = WWW::OPenAPIClient::StoreApi->new();
my $order = WWW::OPenAPIClient::Object::Order->new(); # Order | 

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

try: 
    # Place an order for a pet
    api_response = api_instance.place_order(order)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling StoreApi->placeOrder: %s\n" % e)

extern crate StoreApi;

pub fn main() {
    let order = ; // Order

    let mut context = StoreApi::Context::default();
    let result = client.placeOrder(order, &context).wait();
    println!("{:?}", result);

}

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

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

public class UserApiExample {

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

import org.openapitools.client.api.UserApi;

public class UserApiExample {

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

User *user = ; // 

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

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

var OpenApiPetstore = require('open_api_petstore');

var api = new OpenApiPetstore.UserApi()
var user = ; // {User} 

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

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

namespace Example
{
    public class createUserExample
    {
        public void main()
        {
            
            var apiInstance = new UserApi();
            var user = new User(); // User | 

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

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

$api_instance = new OpenAPITools\Client\Api\UserApi();
$user = ; // User | 

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

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

my $api_instance = WWW::OPenAPIClient::UserApi->new();
my $user = WWW::OPenAPIClient::Object::User->new(); # User | 

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

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

extern crate UserApi;

pub fn main() {
    let user = ; // User

    let mut context = UserApi::Context::default();
    let result = client.createUser(user, &context).wait();
    println!("{:?}", result);

}

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

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

public class UserApiExample {

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

import org.openapitools.client.api.UserApi;

public class UserApiExample {

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

array[User] *user = ; // 

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

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

var OpenApiPetstore = require('open_api_petstore');

var api = new OpenApiPetstore.UserApi()
var user = ; // {array[User]} 

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

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

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

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

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

$api_instance = new OpenAPITools\Client\Api\UserApi();
$user = ; // array[User] | 

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

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

my $api_instance = WWW::OPenAPIClient::UserApi->new();
my $user = [WWW::OPenAPIClient::Object::array[User]->new()]; # array[User] | 

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

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

extern crate UserApi;

pub fn main() {
    let user = ; // array[User]

    let mut context = UserApi::Context::default();
    let result = client.createUsersWithArrayInput(user, &context).wait();
    println!("{:?}", result);

}

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

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

public class UserApiExample {

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

import org.openapitools.client.api.UserApi;

public class UserApiExample {

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

array[User] *user = ; // 

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

// Creates list of users with given input array
[apiInstance createUsersWithListInputWith:user
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OpenApiPetstore = require('open_api_petstore');

var api = new OpenApiPetstore.UserApi()
var user = ; // {array[User]} 

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

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

namespace Example
{
    public class createUsersWithListInputExample
    {
        public void main()
        {
            
            var apiInstance = new UserApi();
            var user = new array[User](); // array[User] | 

            try
            {
                // Creates list of users with given input array
                apiInstance.createUsersWithListInput(user);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.createUsersWithListInput: " + e.Message );
            }
        }
    }
}

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

$api_instance = new OpenAPITools\Client\Api\UserApi();
$user = ; // array[User] | 

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

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

my $api_instance = WWW::OPenAPIClient::UserApi->new();
my $user = [WWW::OPenAPIClient::Object::array[User]->new()]; # array[User] | 

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

try: 
    # Creates list of users with given input array
    api_instance.create_users_with_list_input(user)
except ApiException as e:
    print("Exception when calling UserApi->createUsersWithListInput: %s\n" % e)

extern crate UserApi;

pub fn main() {
    let user = ; // array[User]

    let mut context = UserApi::Context::default();
    let result = client.createUsersWithListInput(user, &context).wait();
    println!("{:?}", result);

}

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

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

public class UserApiExample {

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

import org.openapitools.client.api.UserApi;

public class UserApiExample {

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

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

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

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

var OpenApiPetstore = require('open_api_petstore');

var api = new OpenApiPetstore.UserApi()
var username = username_example; // {String} The name that needs to be deleted

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

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

namespace Example
{
    public class deleteUserExample
    {
        public void main()
        {
            
            var apiInstance = new UserApi();
            var username = username_example;  // String | The name that needs to be deleted

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

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

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

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

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

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

eval { 
    $api_instance->deleteUser(username => $username);
};
if ($@) {
    warn "Exception when calling UserApi->deleteUser: $@\n";
}

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

# create an instance of the API class
api_instance = openapi_client.UserApi()
username = username_example # String | The name that needs to be deleted

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

extern crate UserApi;

pub fn main() {
    let username = username_example; // String

    let mut context = UserApi::Context::default();
    let result = client.deleteUser(username, &context).wait();
    println!("{:?}", result);

}

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

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

public class UserApiExample {

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

import org.openapitools.client.api.UserApi;

public class UserApiExample {

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

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

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

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

var OpenApiPetstore = require('open_api_petstore');

var api = new OpenApiPetstore.UserApi()
var username = username_example; // {String} The name that needs to be fetched. Use user1 for testing.

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

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

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

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

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

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

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

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

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

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

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

# create an instance of the API class
api_instance = openapi_client.UserApi()
username = username_example # String | The name that needs to be fetched. Use user1 for testing.

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

extern crate UserApi;

pub fn main() {
    let username = username_example; // String

    let mut context = UserApi::Context::default();
    let result = client.getUserByName(username, &context).wait();
    println!("{:?}", result);

}

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

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

public class UserApiExample {

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

import org.openapitools.client.api.UserApi;

public class UserApiExample {

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

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

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

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

var OpenApiPetstore = require('open_api_petstore');

var api = new OpenApiPetstore.UserApi()
var username = username_example; // {String} The user name for login
var password = password_example; // {String} The password for login in clear text

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

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

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

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

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

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

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

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

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

eval { 
    my $result = $api_instance->loginUser(username => $username, password => $password);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->loginUser: $@\n";
}

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

# create an instance of the API class
api_instance = openapi_client.UserApi()
username = username_example # String | The user name for login
password = password_example # String | The password for login in clear text

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

extern crate UserApi;

pub fn main() {
    let username = username_example; // String
    let password = password_example; // String

    let mut context = UserApi::Context::default();
    let result = client.loginUser(username, password, &context).wait();
    println!("{:?}", result);

}

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

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

public class UserApiExample {

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

import org.openapitools.client.api.UserApi;

public class UserApiExample {

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

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

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

var OpenApiPetstore = require('open_api_petstore');

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

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

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

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

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

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

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

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

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

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

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

extern crate UserApi;

pub fn main() {

    let mut context = UserApi::Context::default();
    let result = client.logoutUser(&context).wait();
    println!("{:?}", result);

}

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

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

public class UserApiExample {

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

import org.openapitools.client.api.UserApi;

public class UserApiExample {

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

String *username = username_example; // name that need to be deleted
User *user = ; // 

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

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

var OpenApiPetstore = require('open_api_petstore');

var api = new OpenApiPetstore.UserApi()
var username = username_example; // {String} name that need to be deleted
var user = ; // {User} 

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

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

namespace Example
{
    public class updateUserExample
    {
        public void main()
        {
            
            var apiInstance = new UserApi();
            var username = username_example;  // String | name that need to be deleted
            var user = new User(); // User | 

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

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

$api_instance = new OpenAPITools\Client\Api\UserApi();
$username = username_example; // String | name that need to be deleted
$user = ; // User | 

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

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

my $api_instance = WWW::OPenAPIClient::UserApi->new();
my $username = username_example; # String | name that need to be deleted
my $user = WWW::OPenAPIClient::Object::User->new(); # User | 

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

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

extern crate UserApi;

pub fn main() {
    let username = username_example; // String
    let user = ; // User

    let mut context = UserApi::Context::default();
    let result = client.updateUser(username, user, &context).wait();
    println!("{:?}", result);

}