wesley-key-sdk 4.0.0 → 4.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32b2ba67ccdc0313bfb0c355ad9fa99a6413618ab32324bd9d6f91d062b02831
-  data.tar.gz: '09fb581ec96561ada24b807c5775d75436f750d5c4f56f9a053c8d4fa938aaa6'
+  metadata.gz: f22b22395a8452f239db0c529bcd4bd9c4d209bc42dece0aa51ccda0794bf274
+  data.tar.gz: 646a929e08b140f97c9ff50c7aa9e052d087e5880f5b13b0f045d84dfa6a4bb4
 SHA512:
-  metadata.gz: 8960c201fa1e7c00d4fd8f2f0928fcac566a4fd88ba94f41c22acf70eb8539c2b0e5608852b37ff3353dda04e740d549c59c0bb984b192d80a5eccc7a3e914b3
-  data.tar.gz: c048447b48bbecf1651992854ff495daa05526f2ac4a5039c18f607cb2d4e1f19d834f56b782c4a767c96fb647c277df2b42df41b6d645b7b91657a5990f8b3b
+  metadata.gz: 8b841fcc3575323415331051808a172ab7b2f10380c9292190d122a6912b6e68ab655654905faa41949e252c2b1aa9ba9923146dab8c32bb85eb24b8cee1d241
+  data.tar.gz: e7865b424ea16c05604c1ed249dcc4665279c35b890ea60736597b6c0476889121b9a662e67f40956192fc8e372c496fe1920e43ddf75cf1e0101462a53783bd

data/README.md

@@ -1,33 +1,35 @@
 
-# Getting Started with Webhooks and Callbacks API
+# Getting Started with Swagger Petstore - OpenAPI 3.0
 
 ## Introduction
 
-A comprehensive API demonstrating webhooks and callbacks patterns.
+This is a sample Pet Store Server based on the OpenAPI 3.0 specification.  You can find out more about
+Swagger at [https://swagger.io](https://swagger.io). In the third iteration of the pet store, we've switched to the design first approach!
+You can now help us improve the API whether it's by making changes to the definition itself or to the code.
+That way, with time, we can improve the API in general, and expose some of the new features in OAS3.
 
-### Webhooks
+Some useful links:
 
-Webhooks allow your application to receive real-time notifications when certain events occur.
+- [The Pet Store repository](https://github.com/swagger-api/swagger-petstore)
+- [The source API definition for the Pet Store](https://github.com/swagger-api/swagger-petstore/blob/master/src/main/resources/openapi.yaml)
 
-### Callbacks
-
-Callbacks are used for asynchronous operations where the API will call back to your provided URL when the operation completes.
+Find out more about Swagger: [https://swagger.io](https://swagger.io)
 
 ## Install the Package
 
 Install the gem from the command line:
 
 ```bash
-gem install wesley-key-sdk -v 4.0.0
+gem install wesley-key-sdk -v 4.2.0
 ```
 
 Or add the gem to your Gemfile and run `bundle`:
 
 ```ruby
-gem 'wesley-key-sdk', '4.0.0'
+gem 'wesley-key-sdk', '4.2.0'
 ```
 
-For additional gem details, see the [RubyGems page for the wesley-key-sdk gem](https://rubygems.org/gems/wesley-key-sdk/versions/4.0.0).
+For additional gem details, see the [RubyGems page for the wesley-key-sdk gem](https://rubygems.org/gems/wesley-key-sdk/versions/4.2.0).
 
 ## IRB Console Usage
 
@@ -44,8 +46,8 @@ irb
 Now you can load the SDK in the IRB
 
 ```ruby
-require 'webhooks_and_callbacks_api'
-include WebhooksAndCallbacksApi
+require 'swagger_petstore_open_api30'
+include SwaggerPetstoreOpenApi30
 ```
 
 ### 2. Use IRB within SDK
@@ -53,7 +55,7 @@ include WebhooksAndCallbacksApi
 Open your system terminal (Command Prompt, Git Bash or macOS Terminal) and navigate to the root folder of SDK.
 
 ```
-cd path/to/webhooks_and_callbacks_api
+cd path/to/swagger_petstore_open_api30
 ```
 
 Now you can start the preconfigured irb console by running the following command
@@ -72,9 +74,10 @@ The following parameters are configurable for the API Client:
 
 | Parameter | Type | Description |
 |  --- | --- | --- |
+| environment | [`Environment`](README.md#environments) | The API environment. <br> **Default: `Environment.PRODUCTION`** |
 | connection | `Faraday::Connection` | The Faraday connection object passed by the SDK user for making requests |
 | adapter | `Faraday::Adapter` | The Faraday adapter object passed by the SDK user for performing http requests |
-| timeout | `Float` | The value to use for connection timeout. <br> **Default: 50** |
+| timeout | `Float` | The value to use for connection timeout. <br> **Default: 30** |
 | max_retries | `Integer` | The number of times to retry an endpoint call if it fails. <br> **Default: 0** |
 | retry_interval | `Float` | Pause in seconds between retries. <br> **Default: 1** |
 | backoff_factor | `Float` | The amount to multiply each successive retry's interval amount by in order to provide backoff. <br> **Default: 2** |
@@ -83,24 +86,30 @@ The following parameters are configurable for the API Client:
 | http_callback | `HttpCallBack` | The Http CallBack allows defining callables for pre and post API calls. |
 | proxy_settings | [`ProxySettings`](doc/proxy-settings.md) | Optional proxy configuration to route HTTP requests through a proxy server. |
 | logging_configuration | [`LoggingConfiguration`](doc/logging-configuration.md) | The SDK logging configuration for API calls |
+| petstore_auth_credentials | [`PetstoreAuthCredentials`](doc/auth/oauth-2-implicit-grant.md) | The credential object for OAuth 2 Implicit Grant |
 | api_key_credentials | [`ApiKeyCredentials`](doc/auth/custom-header-signature.md) | The credential object for Custom Header Signature |
-| bearer_auth_credentials | [`BearerAuthCredentials`](doc/auth/oauth-2-bearer-token.md) | The credential object for OAuth 2 Bearer token |
 
 The API client can be initialized as follows:
 
 ### Code-Based Client Initialization
 
 ```ruby
-require 'webhooks_and_callbacks_api'
-include WebhooksAndCallbacksApi
+require 'swagger_petstore_open_api30'
+include SwaggerPetstoreOpenApi30
 
 client = Client.new(
-  api_key_credentials: ApiKeyCredentials.new(
-    x_api_key: 'X-API-Key'
+  petstore_auth_credentials: PetstoreAuthCredentials.new(
+    oauth_client_id: 'OAuthClientId',
+    oauth_redirect_uri: 'OAuthRedirectUri',
+    oauth_scopes: [
+      OauthScopePetstoreAuth::WRITEPETS,
+      OauthScopePetstoreAuth::READPETS
+    ]
   ),
-  bearer_auth_credentials: BearerAuthCredentials.new(
-    access_token: 'AccessToken'
+  api_key_credentials: ApiKeyCredentials.new(
+    api_key: 'api_key'
   ),
+  environment: Environment::PRODUCTION,
   logging_configuration: LoggingConfiguration.new(
     log_level: Logger::INFO,
     request_logging_config: RequestLoggingConfiguration.new(
@@ -116,8 +125,8 @@ client = Client.new(
 ### Environment-Based Client Initialization
 
 ```ruby
-require 'webhooks_and_callbacks_api'
-include WebhooksAndCallbacksApi
+require 'swagger_petstore_open_api30'
+include SwaggerPetstoreOpenApi30
 
 # Create client from environment
 client = Client.from_env
@@ -125,24 +134,28 @@ client = Client.from_env
 
 See the [`Environment-Based Client Initialization`](doc/environment-based-client-initialization.md) section for details.
 
+## Environments
+
+The SDK can be configured to use a different environment for making API calls. Available environments are:
+
+### Fields
+
+| Name | Description |
+|  --- | --- |
+| PRODUCTION | **Default** |
+
 ## Authorization
 
 This API uses the following authentication schemes.
 
-* [`ApiKey (Custom Header Signature)`](doc/auth/custom-header-signature.md)
-* [`BearerAuth (OAuth 2 Bearer token)`](doc/auth/oauth-2-bearer-token.md)
+* [`petstore_auth (OAuth 2 Implicit Grant)`](doc/auth/oauth-2-implicit-grant.md)
+* [`api_key (Custom Header Signature)`](doc/auth/custom-header-signature.md)
 
 ## List of APIs
 
-* [Orders](doc/controllers/orders.md)
-
-## Webhooks
-
-* [Webhooks](doc/events/webhooks/webhooks-handler.md)
-* [Webhooks A](doc/events/webhooks/webhooks-a-handler.md)
-* [Webhooks B](doc/events/webhooks/webhooks-b-handler.md)
-* [Webhooks C](doc/events/webhooks/webhooks-c-handler.md)
-* [Webhooks No Verification](doc/events/webhooks/webhooks-no-verification-handler.md)
+* [Pet](doc/controllers/pet.md)
+* [Store](doc/controllers/store.md)
+* [User](doc/controllers/user.md)
 
 ## SDK Infrastructure
 

data/bin/console

@@ -4,11 +4,11 @@
 $LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
 
 # Require the gem
-require 'webhooks_and_callbacks_api'
+require 'swagger_petstore_open_api30'
 
-puts 'WebhooksAndCallbacksApi SDK loaded!'
-puts 'You can now create a client with: client = WebhooksAndCallbacksApi::Client.new'
-puts 'Or use from_env: client = WebhooksAndCallbacksApi::Client.from_env'
+puts 'SwaggerPetstoreOpenApi30 SDK loaded!'
+puts 'You can now create a client with: client = SwaggerPetstoreOpenApi30::Client.new'
+puts 'Or use from_env: client = SwaggerPetstoreOpenApi30::Client.from_env'
 
 # Start an interactive IRB session
 require 'irb'

data/lib/{webhooks_and_callbacks_api → swagger_petstore_open_api30}/api_helper.rb

@@ -1,9 +1,9 @@
-# webhooks_and_callbacks_api
+# swagger_petstore_open_api30
 #
 # This file was automatically generated by
 # APIMATIC v3.0 ( https://www.apimatic.io ).
 
-module WebhooksAndCallbacksApi
+module SwaggerPetstoreOpenApi30
   # API utility class
   class APIHelper < CoreLibrary::ApiHelper
   end

data/lib/{webhooks_and_callbacks_api → swagger_petstore_open_api30}/apis/base_api.rb

@@ -1,16 +1,16 @@
-# webhooks_and_callbacks_api
+# swagger_petstore_open_api30
 #
 # This file was automatically generated by
 # APIMATIC v3.0 ( https://www.apimatic.io ).
 
-module WebhooksAndCallbacksApi
+module SwaggerPetstoreOpenApi30
   # BaseApi.
   class BaseApi
     include CoreLibrary
     attr_accessor :config, :http_call_back
 
     def self.user_agent
-      'Ruby-SDK/4.0.0 (OS: {os-info}, Engine: {engine}/{engine-version})'
+      'Ruby-SDK/4.2.0 (OS: {os-info}, Engine: {engine}/{engine-version})'
     end
 
     def self.user_agent_parameters

data/lib/swagger_petstore_open_api30/apis/pet_api.rb

@@ -0,0 +1,287 @@
+# swagger_petstore_open_api30
+#
+# This file was automatically generated by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module SwaggerPetstoreOpenApi30
+  # PetApi
+  class PetApi < BaseApi
+    # Update an existing pet by Id.
+    # @param [String] name Required parameter: TODO: type description here
+    # @param [Array[String]] photo_urls Required parameter: TODO: type
+    # description here
+    # @param [Integer] id Optional parameter: TODO: type description here
+    # @param [Category] category Optional parameter: TODO: type description
+    # here
+    # @param [Array[Tag]] tags Optional parameter: TODO: type description here
+    # @param [PetStatus] status Optional parameter: pet status in the store
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def update_pet(name,
+                   photo_urls,
+                   id: nil,
+                   category: nil,
+                   tags: nil,
+                   status: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/pet',
+                                     Server::DEFAULT)
+                   .form_param(new_parameter(name, key: 'name')
+                                .is_required(true))
+                   .form_param(new_parameter(photo_urls, key: 'photoUrls')
+                                .is_required(true))
+                   .form_param(new_parameter(id, key: 'id'))
+                   .form_param(new_parameter(category, key: 'category'))
+                   .form_param(new_parameter(tags, key: 'tags'))
+                   .form_param(new_parameter(status, key: 'status'))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'content-type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('petstore_auth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Pet.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Invalid ID supplied',
+                                 APIException)
+                    .local_error('404',
+                                 'Pet not found',
+                                 APIException)
+                    .local_error('422',
+                                 'Validation exception',
+                                 APIException)
+                    .local_error('default',
+                                 'Unexpected error',
+                                 APIException))
+        .execute
+    end
+
+    # Add a new pet to the store.
+    # @param [String] name Required parameter: TODO: type description here
+    # @param [Array[String]] photo_urls Required parameter: TODO: type
+    # description here
+    # @param [Integer] id Optional parameter: TODO: type description here
+    # @param [Category] category Optional parameter: TODO: type description
+    # here
+    # @param [Array[Tag]] tags Optional parameter: TODO: type description here
+    # @param [PetStatus] status Optional parameter: pet status in the store
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def add_pet(name,
+                photo_urls,
+                id: nil,
+                category: nil,
+                tags: nil,
+                status: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/pet',
+                                     Server::DEFAULT)
+                   .form_param(new_parameter(name, key: 'name')
+                                .is_required(true))
+                   .form_param(new_parameter(photo_urls, key: 'photoUrls')
+                                .is_required(true))
+                   .form_param(new_parameter(id, key: 'id'))
+                   .form_param(new_parameter(category, key: 'category'))
+                   .form_param(new_parameter(tags, key: 'tags'))
+                   .form_param(new_parameter(status, key: 'status'))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'content-type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('petstore_auth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Pet.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Invalid input',
+                                 APIException)
+                    .local_error('422',
+                                 'Validation exception',
+                                 APIException)
+                    .local_error('default',
+                                 'Unexpected error',
+                                 APIException))
+        .execute
+    end
+
+    # Multiple status values can be provided with comma separated strings.
+    # @param [PetStatus] status Optional parameter: Status values that need to
+    # be considered for filter
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def find_pets_by_status(status: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/pet/findByStatus',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(status, key: 'status'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('petstore_auth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Pet.method(:from_hash))
+                    .is_api_response(true)
+                    .is_response_array(true)
+                    .local_error('400',
+                                 'Invalid status value',
+                                 APIException)
+                    .local_error('default',
+                                 'Unexpected error',
+                                 APIException))
+        .execute
+    end
+
+    # Multiple tags can be provided with comma separated strings. Use tag1,
+    # tag2, tag3 for testing.
+    # @param [Array[String]] tags Optional parameter: Tags to filter by
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def find_pets_by_tags(tags: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/pet/findByTags',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(tags, key: 'tags'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('petstore_auth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Pet.method(:from_hash))
+                    .is_api_response(true)
+                    .is_response_array(true)
+                    .local_error('400',
+                                 'Invalid tag value',
+                                 APIException)
+                    .local_error('default',
+                                 'Unexpected error',
+                                 APIException))
+        .execute
+    end
+
+    # Returns a single pet.
+    # @param [Integer] pet_id Required parameter: ID of pet to return
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_pet_by_id(pet_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/pet/{petId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(pet_id, key: 'petId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Or.new('api_key', 'petstore_auth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Pet.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Invalid ID supplied',
+                                 APIException)
+                    .local_error('404',
+                                 'Pet not found',
+                                 APIException)
+                    .local_error('default',
+                                 'Unexpected error',
+                                 APIException))
+        .execute
+    end
+
+    # Updates a pet resource based on the form data.
+    # @param [Integer] pet_id Required parameter: ID of pet that needs to be
+    # updated
+    # @param [String] name Optional parameter: Name of pet that needs to be
+    # updated
+    # @param [String] status Optional parameter: Status of pet that needs to be
+    # updated
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def update_pet_with_form(pet_id,
+                             name: nil,
+                             status: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/pet/{petId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(pet_id, key: 'petId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(name, key: 'name'))
+                   .query_param(new_parameter(status, key: 'status'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('petstore_auth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Pet.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Invalid input',
+                                 APIException)
+                    .local_error('default',
+                                 'Unexpected error',
+                                 APIException))
+        .execute
+    end
+
+    # Delete a pet.
+    # @param [Integer] pet_id Required parameter: Pet id to delete
+    # @param [String] api_key Optional parameter: TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def delete_pet(pet_id,
+                   api_key: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::DELETE,
+                                     '/pet/{petId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(pet_id, key: 'petId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(api_key, key: 'api_key'))
+                   .auth(Single.new('petstore_auth')))
+        .response(new_response_handler
+                    .is_response_void(true)
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Invalid pet value',
+                                 APIException)
+                    .local_error('default',
+                                 'Unexpected error',
+                                 APIException))
+        .execute
+    end
+
+    # Upload image of the pet.
+    # @param [Integer] pet_id Required parameter: ID of pet to update
+    # @param [String] additional_metadata Optional parameter: Additional
+    # Metadata
+    # @param [File | UploadIO] body Optional parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def upload_file(pet_id,
+                    additional_metadata: nil,
+                    body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/pet/{petId}/uploadImage',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(pet_id, key: 'petId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(additional_metadata, key: 'additionalMetadata'))
+                   .multipart_param(new_parameter(body, key: 'body')
+                                     .default_content_type('application/octet-stream'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('petstore_auth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ApiResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'No file uploaded',
+                                 APIException)
+                    .local_error('404',
+                                 'Pet not found',
+                                 APIException)
+                    .local_error('default',
+                                 'Unexpected error',
+                                 APIException))
+        .execute
+    end
+  end
+end

data/lib/swagger_petstore_open_api30/apis/store_api.rb

@@ -0,0 +1,131 @@
+# swagger_petstore_open_api30
+#
+# This file was automatically generated by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module SwaggerPetstoreOpenApi30
+  # StoreApi
+  class StoreApi < BaseApi
+    # Returns a map of status codes to quantities.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_inventory
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/store/inventory',
+                                     Server::DEFAULT)
+                   .auth(Single.new('api_key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:deserialize_primitive_types))
+                    .deserialize_into(proc do |response| response&.to_i end)
+                    .is_api_response(true)
+                    .is_primitive_response(true)
+                    .local_error('default',
+                                 'Unexpected error',
+                                 APIException))
+        .execute
+    end
+
+    # Place a new order in the store.
+    # @param [Integer] id Optional parameter: TODO: type description here
+    # @param [Integer] pet_id Optional parameter: TODO: type description here
+    # @param [Integer] quantity Optional parameter: TODO: type description
+    # here
+    # @param [DateTime] ship_date Optional parameter: TODO: type description
+    # here
+    # @param [OrderStatus] status Optional parameter: Order Status
+    # @param [TrueClass | FalseClass] complete Optional parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def place_order(id: nil,
+                    pet_id: nil,
+                    quantity: nil,
+                    ship_date: nil,
+                    status: nil,
+                    complete: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/store/order',
+                                     Server::DEFAULT)
+                   .form_param(new_parameter(id, key: 'id'))
+                   .form_param(new_parameter(pet_id, key: 'petId'))
+                   .form_param(new_parameter(quantity, key: 'quantity'))
+                   .form_param(new_parameter(ship_date, key: 'shipDate'))
+                   .form_param(new_parameter(status, key: 'status'))
+                   .form_param(new_parameter(complete, key: 'complete'))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'content-type'))
+                   .header_param(new_parameter('application/json', key: 'accept')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Order.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Invalid input',
+                                 APIException)
+                    .local_error('422',
+                                 'Validation exception',
+                                 APIException)
+                    .local_error('default',
+                                 'Unexpected error',
+                                 APIException))
+        .execute
+    end
+
+    # For valid response try integer IDs with value <= 5 or > 10. Other values
+    # will generate exceptions.
+    # @param [Integer] order_id Required parameter: ID of order that needs to be
+    # fetched
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_order_by_id(order_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/store/order/{orderId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(order_id, key: 'orderId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Order.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Invalid ID supplied',
+                                 APIException)
+                    .local_error('404',
+                                 'Order not found',
+                                 APIException)
+                    .local_error('default',
+                                 'Unexpected error',
+                                 APIException))
+        .execute
+    end
+
+    # For valid response try integer IDs with value < 1000. Anything above 1000
+    # or non-integers will generate API errors.
+    # @param [Integer] order_id Required parameter: ID of the order that needs
+    # to be deleted
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def delete_order(order_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::DELETE,
+                                     '/store/order/{orderId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(order_id, key: 'orderId')
+                                    .is_required(true)
+                                    .should_encode(true)))
+        .response(new_response_handler
+                    .is_response_void(true)
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Invalid ID supplied',
+                                 APIException)
+                    .local_error('404',
+                                 'Order not found',
+                                 APIException)
+                    .local_error('default',
+                                 'Unexpected error',
+                                 APIException))
+        .execute
+    end
+  end
+end