# OpenAPI Petstore

## API and SDK Documentation

Version: 1.0.0

This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.

# Pet

# addPet

Add a new pet to the store

    /pet

### Usage and SDK Samples

    curl -X POST "http://petstore.swagger.io/v2/pet"

    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);

    }

## Scopes

write:pets | modify pets in your account
read:pets | read your pets

## Parameters

Body parameters

Name | Description
--- | ---
pet * | Pet object that needs to be added to the store

## Responses

###

# deletePet

Deletes a pet

    /pet/{petId}

### Usage and SDK Samples

    curl -X DELETE "http://petstore.swagger.io/v2/pet/{petId}"

    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);

    }

## Scopes

write:pets | modify pets in your account
read:pets | read your pets

## Parameters

Path parameters

Name | Description
--- | ---
petId* | Long (int64) Pet id to delete Required

Header parameters

Name | Description
--- | ---
api_key | String

## Responses

###

# findPetsByStatus

Finds Pets by status

Multiple status values can be provided with comma separated strings

    /pet/findByStatus

### Usage and SDK Samples

    curl -X GET "http://petstore.swagger.io/v2/pet/findByStatus?status="

    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);

    }

## Scopes

write:pets | modify pets in your account
read:pets | read your pets

## Parameters

Query parameters

Name | Description
--- | ---
status* | array[String] Status values that need to be considered for filter Required

## Responses

###

###

# findPetsByTags

Finds Pets by tags

Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.

    /pet/findByTags

### Usage and SDK Samples

    curl -X GET "http://petstore.swagger.io/v2/pet/findByTags?tags="

    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);

    }

## Scopes

write:pets | modify pets in your account
read:pets | read your pets

## Parameters

Query parameters

Name | Description
--- | ---
tags* | array[String] Tags to filter by Required

## Responses

###

###

# getPetById

Find pet by ID

Returns a single pet

    /pet/{petId}

### Usage and SDK Samples

    curl -X GET -H "api_key: [[apiKey]]" "http://petstore.swagger.io/v2/pet/{petId}"

    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);

    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
petId* | Long (int64) ID of pet to return Required

## Responses

###

###

###

# updatePet

Update an existing pet

    /pet

### Usage and SDK Samples

    curl -X PUT "http://petstore.swagger.io/v2/pet"

    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);

    }

## Scopes

write:pets | modify pets in your account
read:pets | read your pets

## Parameters

Body parameters

Name | Description
--- | ---
pet * | Pet object that needs to be added to the store

## Responses

###

###

###

# updatePetWithForm

Updates a pet in the store with form data

    /pet/{petId}

### Usage and SDK Samples

    curl -X POST "http://petstore.swagger.io/v2/pet/{petId}"

    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);

    }

## Scopes

write:pets | modify pets in your account
read:pets | read your pets

## Parameters

Path parameters

Name | Description
--- | ---
petId* | Long (int64) ID of pet that needs to be updated Required

Form parameters

Name | Description
--- | ---
name | String Updated name of the pet
status | String Updated status of the pet

## Responses

###

# uploadFile

uploads an image

    /pet/{petId}/uploadImage

### Usage and SDK Samples

    curl -X POST "http://petstore.swagger.io/v2/pet/{petId}/uploadImage"

    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);

    }

## Scopes

write:pets | modify pets in your account
read:pets | read your pets

## Parameters

Path parameters

Name | Description
--- | ---
petId* | Long (int64) ID of pet to update Required

Form parameters

Name | Description
--- | ---
additionalMetadata | String Additional data to pass to server
file | File (binary) file to upload

## Responses

###

# Store

# deleteOrder

Delete purchase order by ID

For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors

    /store/order/{orderId}

### Usage and SDK Samples

    curl -X DELETE "http://petstore.swagger.io/v2/store/order/{orderId}"

    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);

    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
orderId* | String ID of the order that needs to be deleted Required

## Responses

###

###

# getInventory

Returns pet inventories by status

Returns a map of status codes to quantities

    /store/inventory

### Usage and SDK Samples

    curl -X GET -H "api_key: [[apiKey]]" "http://petstore.swagger.io/v2/store/inventory"

    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);

    }

## Scopes

## Parameters

## Responses

###

# getOrderById

Find purchase order by ID

For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions

    /store/order/{orderId}

### Usage and SDK Samples

    curl -X GET "http://petstore.swagger.io/v2/store/order/{orderId}"

    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);

    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
orderId* | Long (int64) ID of pet that needs to be fetched Required

## Responses

###

###

###

# placeOrder

Place an order for a pet

    /store/order

### Usage and SDK Samples

    curl -X POST "http://petstore.swagger.io/v2/store/order"

    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);

    }

## Scopes

## Parameters

Body parameters

Name | Description
--- | ---
order * | order placed for purchasing the pet

## Responses

###

###

# User

# createUser

Create user

This can only be done by the logged in user.

    /user

### Usage and SDK Samples

    curl -X POST "http://petstore.swagger.io/v2/user"

    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);

    }

## Scopes

## Parameters

Body parameters

Name | Description
--- | ---
user * | Created user object

## Responses

###

# createUsersWithArrayInput

Creates list of users with given input array

    /user/createWithArray

### Usage and SDK Samples

    curl -X POST "http://petstore.swagger.io/v2/user/createWithArray"

    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);

    }

## Scopes

## Parameters

Body parameters

Name | Description
--- | ---
user * | List of user object

## Responses

###

# createUsersWithListInput

Creates list of users with given input array

    /user/createWithList

### Usage and SDK Samples

    curl -X POST "http://petstore.swagger.io/v2/user/createWithList"

    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);

    }

## Scopes

## Parameters

Body parameters

Name | Description
--- | ---
user * | List of user object

## Responses

###

# deleteUser

Delete user

This can only be done by the logged in user.

    /user/{username}

### Usage and SDK Samples

    curl -X DELETE "http://petstore.swagger.io/v2/user/{username}"

    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);

    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
username* | String The name that needs to be deleted Required

## Responses

###

###

# getUserByName

Get user by user name

    /user/{username}

### Usage and SDK Samples

    curl -X GET "http://petstore.swagger.io/v2/user/{username}"

    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);

    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
username* | String The name that needs to be fetched. Use user1 for testing. Required

## Responses

###

###

###

# loginUser

Logs user into the system

    /user/login

### Usage and SDK Samples

    curl -X GET "http://petstore.swagger.io/v2/user/login?username=&password="

    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);

    }

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
username* | String The user name for login Required
password* | String The password for login in clear text Required

## Responses

###

Name | Type | Format | Description
--- | --- | --- | ---
XMinusRateMinusLimit | Integer | int32 | calls per hour allowed by the user
XMinusExpiresMinusAfter | Date | date-time | date in UTC when toekn expires

###

# logoutUser

Logs out current logged in user session

    /user/logout

### Usage and SDK Samples

    curl -X GET "http://petstore.swagger.io/v2/user/logout"

    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);

    }

## Scopes

## Parameters

## Responses

###

# updateUser

Updated user

This can only be done by the logged in user.

    /user/{username}

### Usage and SDK Samples

    curl -X PUT "http://petstore.swagger.io/v2/user/{username}"

    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);

    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
username* | String name that need to be deleted Required

Body parameters

Name | Description
--- | ---
user * | Updated user object

## Responses

###

###