apimaticPetstore 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1dd7db51473ed28c14f69f9024318943facf6123a6f3a411a1412fb00e43e3de
+  data.tar.gz: fb3d1deca75e97d7d674fe09860f3e6f1c8c01514bf91aa0660772a069e8a6a0
+SHA512:
+  metadata.gz: 4a06384c1efa4835923c2f9a1b360655e5d0be1118e9bdcc11bc07f289ebf40742a2e2dc834278f8bde9f4ac6d9915967ae1e52f5b631980b225491a223ef237
+  data.tar.gz: 3302f2e241792519f29e524848752eb06364d95d8545dd009256c1885c57bd7973f47094fd41415549b0db302d2b8eade345680e9f88fd54b5c89a313ac21acd

data/LICENSE

@@ -0,0 +1,28 @@
+License: 
+========
+The MIT License (MIT)
+http://opensource.org/licenses/MIT
+
+Copyright (c) 2014 - 2023 APIMATIC Limited
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+Trade Mark:
+==========
+APIMATIC is a trade mark for APIMATIC Limited

data/README.md

@@ -0,0 +1,119 @@
+
+# Getting Started with Swagger Petstore
+
+## Introduction
+
+This is a sample server Petstore server.  You can find out more about Swagger at [http://swagger.io](http://swagger.io) or on [irc.freenode.net, #swagger](http://swagger.io/irc/).  For this sample, you can use the api key `special-key` to test the authorization filters.
+
+## Install the Package
+
+Install the gem from the command line:
+
+```ruby
+gem install apimaticPetstore -v 1.0.1
+```
+
+Or add the gem to your Gemfile and run `bundle`:
+
+```ruby
+gem 'apimaticPetstore', '1.0.1'
+```
+
+For additional gem details, see the [RubyGems page for the apimaticPetstore gem](https://rubygems.org/gems/apimaticPetstore/versions/1.0.1).
+
+## Test the SDK
+
+To run the tests, navigate to the root directory of the SDK in your terminal and execute the following command:
+
+```
+rake
+```
+
+## Initialize the API Client
+
+**_Note:_** Documentation for the client can be found [here.](doc/client.md)
+
+The following parameters are configurable for the API Client:
+
+| Parameter | Type | Description |
+|  --- | --- | --- |
+| `environment` | Environment | 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: 60** |
+| `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** |
+| `retry_statuses` | `Array` | A list of HTTP statuses to retry. <br> **Default: [408, 413, 429, 500, 502, 503, 504, 521, 522, 524]** |
+| `retry_methods` | `Array` | A list of HTTP methods to retry. <br> **Default: %i[get put]** |
+| `http_callback` | `HttpCallBack` | The Http CallBack allows defining callables for pre and post API calls. |
+| `o_auth_client_id` | `String` | OAuth 2 Client ID |
+| `o_auth_redirect_uri` | `String` | OAuth 2 Redirection endpoint or Callback Uri |
+| `o_auth_token` | `OAuthToken` | Object for storing information about the OAuth token |
+| `o_auth_scopes` | `OAuthScopeEnum` |  |
+
+The API client can be initialized as follows:
+
+```ruby
+client = SwaggerPetstore::Client.new(
+  o_auth_client_id: 'OAuthClientId',
+  o_auth_redirect_uri: 'OAuthRedirectUri',
+  o_auth_scopes: [
+    OAuthScopeEnum::READPETS,
+    OAuthScopeEnum::WRITEPETS
+  ],
+  environment: Environment::PRODUCTION
+)
+```
+
+## Authorization
+
+This API uses `OAuth 2 Implicit Grant`.
+
+## Implicit Grant
+
+Your application must obtain user authorization before it can execute an endpoint call incase this SDK chooses to use *OAuth 2.0 Implicit Grant* to obtain a user's consent to perform an API request on user's behalf. This authorization includes the following steps
+
+This process requires the presence of a client-side JavaScript code on the redirect URI page to receive the *access token* after the consent step is completed.
+
+### 1\. Obtain user consent
+
+To obtain user's consent, you must redirect the user to the authorization page. The `get_authorization_url()` method creates the URL to the authorization page. You must have initialized the client with scopes for which you need permission to access.
+
+```ruby
+auth_url = client.auth.get_authorization_url
+```
+
+### 2\. Handle the OAuth server response
+
+Once the user responds to the consent request, the OAuth 2.0 server responds to your application's access request by redirecting the user to the redirect URI specified set in `Configuration`.
+
+The redirect URI will receive the *access token* as the `token` argument in the URL fragment.
+
+```
+https://example.com/oauth/callback#token=XXXXXXXXXXXXXXXXXXXXXXXXX
+```
+
+The access token must be extracted by the client-side JavaScript code. The access token can be used to authorize any further endpoint calls by the JavaScript code.
+
+### Scopes
+
+Scopes enable your application to only request access to the resources it needs while enabling users to control the amount of access they grant to your application. Available scopes are defined in the `OAuthScopeEnum` enumeration.
+
+| Scope Name |
+|  --- |
+| `READPETS` |
+| `WRITEPETS` |
+
+## List of APIs
+
+* [Pet](doc/controllers/pet.md)
+* [Store](doc/controllers/store.md)
+* [User](doc/controllers/user.md)
+
+## Classes Documentation
+
+* [Utility Classes](doc/utility-classes.md)
+* [HttpResponse](doc/http-response.md)
+* [HttpRequest](doc/http-request.md)
+

data/lib/swagger_petstore/api_helper.rb

@@ -0,0 +1,10 @@
+# swagger_petstore
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module SwaggerPetstore
+  # API utility class
+  class APIHelper < CoreLibrary::ApiHelper
+  end
+end

data/lib/swagger_petstore/client.rb

@@ -0,0 +1,76 @@
+# swagger_petstore
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module SwaggerPetstore
+  #  swagger_petstore client class.
+  class Client
+    attr_reader :config, :auth_managers
+
+    # Access to pet controller.
+    # @return [PetController] Returns the controller instance.
+    def pet
+      @pet ||= PetController.new @global_configuration
+    end
+
+    # Access to store controller.
+    # @return [StoreController] Returns the controller instance.
+    def store
+      @store ||= StoreController.new @global_configuration
+    end
+
+    # Access to user controller.
+    # @return [UserController] Returns the controller instance.
+    def user
+      @user ||= UserController.new @global_configuration
+    end
+
+    def initialize(connection: nil, adapter: :net_http_persistent, timeout: 60,
+                   max_retries: 0, retry_interval: 1, backoff_factor: 2,
+                   retry_statuses: [408, 413, 429, 500, 502, 503, 504, 521, 522, 524],
+                   retry_methods: %i[get put], http_callback: nil,
+                   environment: Environment::PRODUCTION,
+                   o_auth_client_id: 'TODO: Replace',
+                   o_auth_redirect_uri: 'TODO: Replace', o_auth_token: nil,
+                   o_auth_scopes: nil, config: nil)
+      @config = if config.nil?
+                  Configuration.new(connection: connection, adapter: adapter,
+                                    timeout: timeout, max_retries: max_retries,
+                                    retry_interval: retry_interval,
+                                    backoff_factor: backoff_factor,
+                                    retry_statuses: retry_statuses,
+                                    retry_methods: retry_methods,
+                                    http_callback: http_callback,
+                                    environment: environment,
+                                    o_auth_client_id: o_auth_client_id,
+                                    o_auth_redirect_uri: o_auth_redirect_uri,
+                                    o_auth_token: o_auth_token,
+                                    o_auth_scopes: o_auth_scopes)
+                else
+                  config
+                end
+
+      @global_configuration = GlobalConfiguration.new(client_configuration: @config)
+                                                 .base_uri_executor(@config.method(:get_base_uri))
+                                                 .global_errors(BaseController::GLOBAL_ERRORS)
+                                                 .user_agent(BaseController.user_agent)
+                                                 .sdk_module(SwaggerPetstore)
+
+      initialize_auth_managers(@global_configuration)
+      @global_configuration = @global_configuration.auth_managers(@auth_managers)
+    end
+
+    # Initializes the auth managers hash used for authenticating API calls.
+    # @param [GlobalConfiguration] global_config The global configuration of the SDK)
+    def initialize_auth_managers(global_config)
+      @auth_managers = {}
+      http_client_config = global_config.client_configuration
+      ['global'].each { |auth| @auth_managers[auth] = nil }
+      @auth_managers['global'] = OAuth2.new(http_client_config.o_auth_client_id,
+                                            http_client_config.o_auth_redirect_uri,
+                                            http_client_config.o_auth_token, global_config,
+                                            http_client_config.o_auth_scopes)
+    end
+  end
+end

data/lib/swagger_petstore/configuration.rb

@@ -0,0 +1,125 @@
+# swagger_petstore
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module SwaggerPetstore
+  # An enum for SDK environments.
+  class Environment
+    ENVIRONMENT = [
+      PRODUCTION = 'production'.freeze
+    ].freeze
+  end
+
+  # An enum for API servers.
+  class Server
+    SERVER = [
+      SERVER_1 = 'Server 1'.freeze
+    ].freeze
+  end
+
+  # All configuration including auth info and base URI for the API access
+  # are configured in this class.
+  class Configuration < CoreLibrary::HttpClientConfiguration
+    # The attribute readers for properties.
+    attr_reader :environment, :o_auth_client_id, :o_auth_redirect_uri, :o_auth_scopes
+
+    def o_auth_token
+      if @o_auth_token.is_a? OAuthToken
+        OAuthToken.from_hash @o_auth_token.to_hash
+      else
+        @o_auth_token
+      end
+    end
+
+    class << self
+      attr_reader :environments
+    end
+
+    def initialize(connection: nil, adapter: :net_http_persistent, timeout: 60,
+                   max_retries: 0, retry_interval: 1, backoff_factor: 2,
+                   retry_statuses: [408, 413, 429, 500, 502, 503, 504, 521, 522, 524],
+                   retry_methods: %i[get put], http_callback: nil,
+                   environment: Environment::PRODUCTION,
+                   o_auth_client_id: 'TODO: Replace',
+                   o_auth_redirect_uri: 'TODO: Replace', o_auth_token: nil,
+                   o_auth_scopes: nil)
+
+      super connection: connection, adapter: adapter, timeout: timeout,
+            max_retries: max_retries, retry_interval: retry_interval,
+            backoff_factor: backoff_factor, retry_statuses: retry_statuses,
+            retry_methods: retry_methods, http_callback: http_callback
+
+      # Current API environment
+      @environment = String(environment)
+
+      # OAuth 2 Client ID
+      @o_auth_client_id = o_auth_client_id
+
+      # OAuth 2 Redirection endpoint or Callback Uri
+      @o_auth_redirect_uri = o_auth_redirect_uri
+
+      # Object for storing information about the OAuth token
+      @o_auth_token = if o_auth_token.is_a? OAuthToken
+                        OAuthToken.from_hash o_auth_token.to_hash
+                      else
+                        o_auth_token
+                      end
+
+      # TODO: Replace
+      @o_auth_scopes = o_auth_scopes
+
+      # The Http Client to use for making requests.
+      set_http_client CoreLibrary::FaradayClient.new(self)
+    end
+
+    def clone_with(connection: nil, adapter: nil, timeout: nil,
+                   max_retries: nil, retry_interval: nil, backoff_factor: nil,
+                   retry_statuses: nil, retry_methods: nil, http_callback: nil,
+                   environment: nil, o_auth_client_id: nil,
+                   o_auth_redirect_uri: nil, o_auth_token: nil,
+                   o_auth_scopes: nil)
+      connection ||= self.connection
+      adapter ||= self.adapter
+      timeout ||= self.timeout
+      max_retries ||= self.max_retries
+      retry_interval ||= self.retry_interval
+      backoff_factor ||= self.backoff_factor
+      retry_statuses ||= self.retry_statuses
+      retry_methods ||= self.retry_methods
+      http_callback ||= self.http_callback
+      environment ||= self.environment
+      o_auth_client_id ||= self.o_auth_client_id
+      o_auth_redirect_uri ||= self.o_auth_redirect_uri
+      o_auth_token ||= self.o_auth_token
+      o_auth_scopes ||= self.o_auth_scopes
+
+      Configuration.new(connection: connection, adapter: adapter,
+                        timeout: timeout, max_retries: max_retries,
+                        retry_interval: retry_interval,
+                        backoff_factor: backoff_factor,
+                        retry_statuses: retry_statuses,
+                        retry_methods: retry_methods,
+                        http_callback: http_callback, environment: environment,
+                        o_auth_client_id: o_auth_client_id,
+                        o_auth_redirect_uri: o_auth_redirect_uri,
+                        o_auth_token: o_auth_token,
+                        o_auth_scopes: o_auth_scopes)
+    end
+
+    # All the environments the SDK can run in.
+    ENVIRONMENTS = {
+      Environment::PRODUCTION => {
+        Server::SERVER_1 => 'https://petstore.swagger.io/v2'
+      }
+    }.freeze
+
+    # Generates the appropriate base URI for the environment and the server.
+    # @param [Configuration::Server] server The server enum for which the base URI is
+    # required.
+    # @return [String] The base URI.
+    def get_base_uri(server = Server::SERVER_1)
+      ENVIRONMENTS[environment][server].clone
+    end
+  end
+end

data/lib/swagger_petstore/controllers/base_controller.rb

@@ -0,0 +1,65 @@
+# swagger_petstore
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module SwaggerPetstore
+  # BaseController.
+  class BaseController
+    attr_accessor :config, :http_call_back
+
+    def self.user_agent
+      'APIMATIC 3.0'
+    end
+
+
+    GLOBAL_ERRORS = {
+      'default' => ErrorCase.new
+                            .error_message('HTTP response not OK.')
+                            .exception_type(APIException)
+    }.freeze
+
+    # Initialization constructor.
+    # @param [GlobalConfiguration] global_configuration The instance of GlobalConfiguration.
+    def initialize(global_configuration)
+      @global_configuration = global_configuration
+      @config = @global_configuration.client_configuration
+      @http_call_back = @config.http_callback
+      @api_call = ApiCall.new(@global_configuration)
+    end
+
+    # Creates a new builder for the Api Call instance.
+    # @return [ApiCall] The instance of ApiCall.
+    def new_api_call_builder
+      @api_call.new_builder
+    end
+
+    # Creates a new instance of the request builder.
+    # @param [HttpMethodEnum] http_method The HTTP method to use in the request.
+    # @param [String] path The endpoint path to use in the request.
+    # @param [String] server The server to extract the base uri for the request.
+    # @return [RequestBuilder] The instance of RequestBuilder.
+    def new_request_builder(http_method, path, server)
+      RequestBuilder.new
+                    .http_method(http_method)
+                    .path(path)
+                    .server(server)
+    end
+
+    # Creates a new instance of the response handler.
+    # @return [ResponseHandler] The instance of ResponseHandler.
+    def new_response_handler
+      ResponseHandler.new
+    end
+
+    # Creates a new instance of the parameter.
+    # @param [String|optional] key The key of the parameter.
+    # @param [Object] value The value of the parameter.
+    # @return [Parameter] The instance of Parameter.
+    def new_parameter(value, key: nil)
+      Parameter.new
+               .key(key)
+               .value(value)
+    end
+  end
+end

data/lib/swagger_petstore/controllers/pet_controller.rb

@@ -0,0 +1,221 @@
+# swagger_petstore
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module SwaggerPetstore
+  # PetController
+  class PetController < BaseController
+    # uploads an image
+    # @param [Integer] pet_id Required parameter: ID of pet to update
+    # @param [String] accept Required parameter: Example:
+    # @param [String] additional_metadata Required parameter: Additional data to
+    # pass to server
+    # @param [File | UploadIO] file Required parameter: file to upload
+    # @return [Response200] response from the API call
+    def upload_file(pet_id,
+                    accept,
+                    additional_metadata,
+                    file)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/pet/{petId}/uploadImage',
+                                     Server::SERVER_1)
+                   .template_param(new_parameter(pet_id, key: 'petId')
+                                    .should_encode(true))
+                   .header_param(new_parameter(accept, key: 'Accept'))
+                   .form_param(new_parameter(additional_metadata, key: 'additionalMetadata'))
+                   .multipart_param(new_parameter(file, key: 'file')
+                                     .default_content_type('application/octet-stream'))
+                   .auth(Single.new('global')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(Response200.method(:from_hash)))
+        .execute
+    end
+
+    # Add a new pet to the store
+    # @param [String] accept Required parameter: Example:
+    # @param [AddPetRequest] body Required parameter: Example:
+    # @return [void] response from the API call
+    def add_pet(accept,
+                body)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/pet',
+                                     Server::SERVER_1)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(accept, key: 'Accept'))
+                   .body_param(new_parameter(body))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('global')))
+        .response(new_response_handler
+                   .is_response_void(true)
+                   .local_error('405',
+                                'Invalid input',
+                                APIException))
+        .execute
+    end
+
+    # Update an existing pet
+    # @param [String] accept Required parameter: Example:
+    # @param [UpdatePetRequest] body Required parameter: Example:
+    # @return [void] response from the API call
+    def update_pet(accept,
+                   body)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/pet',
+                                     Server::SERVER_1)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(accept, key: 'Accept'))
+                   .body_param(new_parameter(body))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('global')))
+        .response(new_response_handler
+                   .is_response_void(true)
+                   .local_error('400',
+                                'Invalid ID supplied',
+                                APIException)
+                   .local_error('404',
+                                'Pet not found',
+                                APIException)
+                   .local_error('405',
+                                'Validation exception',
+                                APIException))
+        .execute
+    end
+
+    # Multiple status values can be provided with comma separated strings
+    # @param [List of String] status Required parameter: Status values that need
+    # to be considered for filter
+    # @param [String] accept Required parameter: Example:
+    # @return [List of Response2001] response from the API call
+    def find_pets_by_status(status,
+                            accept)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/pet/findByStatus',
+                                     Server::SERVER_1)
+                   .query_param(new_parameter(status, key: 'status'))
+                   .header_param(new_parameter(accept, key: 'Accept'))
+                   .auth(Single.new('global')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(Response2001.method(:from_hash))
+                   .is_response_array(true)
+                   .local_error('400',
+                                'Invalid status value',
+                                APIException))
+        .execute
+    end
+
+    # Multiple tags can be provided with comma separated strings. Use tag1,
+    # tag2, tag3 for testing.
+    # @param [List of String] tags Required parameter: Tags to filter by
+    # @param [String] accept Required parameter: Example:
+    # @return [List of Response2001] response from the API call
+    def find_pets_by_tags(tags,
+                          accept)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/pet/findByTags',
+                                     Server::SERVER_1)
+                   .query_param(new_parameter(tags, key: 'tags'))
+                   .header_param(new_parameter(accept, key: 'Accept'))
+                   .auth(Single.new('global')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(Response2001.method(:from_hash))
+                   .is_response_array(true)
+                   .local_error('400',
+                                'Invalid tag value',
+                                APIException))
+        .execute
+    end
+
+    # Returns a single pet
+    # @param [Integer] pet_id Required parameter: ID of pet to return
+    # @param [String] accept Required parameter: Example:
+    # @return [Response2001] response from the API call
+    def get_pet_by_id(pet_id,
+                      accept)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/pet/{petId}',
+                                     Server::SERVER_1)
+                   .template_param(new_parameter(pet_id, key: 'petId')
+                                    .should_encode(true))
+                   .header_param(new_parameter(accept, key: 'Accept'))
+                   .auth(Single.new('global')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(Response2001.method(:from_hash))
+                   .local_error('400',
+                                'Invalid ID supplied',
+                                APIException)
+                   .local_error('404',
+                                'Pet not found',
+                                APIException))
+        .execute
+    end
+
+    # Updates a pet in the store with form data
+    # @param [Integer] pet_id Required parameter: ID of pet that needs to be
+    # updated
+    # @param [String] accept Required parameter: Example:
+    # @param [String] name Required parameter: Updated name of the pet
+    # @param [String] status Required parameter: Updated status of the pet
+    # @return [void] response from the API call
+    def update_pet_with_form(pet_id,
+                             accept,
+                             name,
+                             status)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/pet/{petId}',
+                                     Server::SERVER_1)
+                   .template_param(new_parameter(pet_id, key: 'petId')
+                                    .should_encode(true))
+                   .header_param(new_parameter(accept, key: 'Accept'))
+                   .form_param(new_parameter(name, key: 'name'))
+                   .form_param(new_parameter(status, key: 'status'))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'content-type'))
+                   .auth(Single.new('global')))
+        .response(new_response_handler
+                   .is_response_void(true)
+                   .local_error('405',
+                                'Invalid input',
+                                APIException))
+        .execute
+    end
+
+    # Deletes a pet
+    # @param [Integer] pet_id Required parameter: Pet id to delete
+    # @param [String] api_key Required parameter: Example:
+    # @param [String] accept Required parameter: Example:
+    # @return [void] response from the API call
+    def delete_pet(pet_id,
+                   api_key,
+                   accept)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::DELETE,
+                                     '/pet/{petId}',
+                                     Server::SERVER_1)
+                   .template_param(new_parameter(pet_id, key: 'petId')
+                                    .should_encode(true))
+                   .header_param(new_parameter(api_key, key: 'api_key'))
+                   .header_param(new_parameter(accept, key: 'Accept'))
+                   .auth(Single.new('global')))
+        .response(new_response_handler
+                   .is_response_void(true)
+                   .local_error('400',
+                                'Invalid ID supplied',
+                                APIException)
+                   .local_error('404',
+                                'Pet not found',
+                                APIException))
+        .execute
+    end
+  end
+end