Ruby client faraday (#3405)

* WIP: add faraday support to Ruby client

* update samples

* bin/console

* https only

* ruby-faraday: Add a gemspec template for faraday

* Add a test for ruby-faraday client options

* Remove Gemfile.lock from ruby-client-faraday

* Implement faraday client

* Problem: can't use Faraday library for ruby clients

Solution: add support for Faraday library

This patch builds on the work started by @meganemura

* Problem: Faraday is set as default library

Solution: Make Typhoeus default

This patch also updates the api_client template for Faraday to include query params with requests.

bin/ruby-client-petstore-faraday.sh

@@ -0,0 +1,32 @@
+#!/bin/sh
+
+SCRIPT="$0"
+echo "# START SCRIPT: $SCRIPT"
+
+while [ -h "$SCRIPT" ] ; do
+  ls=`ls -ld "$SCRIPT"`
+  link=`expr "$ls" : '.*-> \(.*\)$'`
+  if expr "$link" : '/.*' > /dev/null; then
+    SCRIPT="$link"
+  else
+    SCRIPT=`dirname "$SCRIPT"`/"$link"
+  fi
+done
+
+if [ ! -d "${APP_DIR}" ]; then
+  APP_DIR=`dirname "$SCRIPT"`/..
+  APP_DIR=`cd "${APP_DIR}"; pwd`
+fi
+
+executable="./modules/openapi-generator-cli/target/openapi-generator-cli.jar"
+
+if [ ! -f "$executable" ]
+then
+  mvn -B clean package
+fi
+
+# if you've executed sbt assembly previously it will use that instead.
+export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties"
+ags="generate -t modules/openapi-generator/src/main/resources/ruby-client -i modules/openapi-generator/src/test/resources/2_0/petstore-with-fake-endpoints-models-for-testing.yaml -g ruby -c bin/ruby-petstore-faraday.json -o samples/client/petstore/ruby-faraday $@"
+
+java $JAVA_OPTS -jar $executable $ags

bin/ruby-petstore-faraday.json

@@ -0,0 +1,5 @@
+{
+  "gemName": "petstore",
+  "moduleName": "Petstore",
+  "gemVersion": "1.0.0"
+}

bin/ruby-petstore.json

@@ -1,5 +1,6 @@
 {
   "gemName": "petstore",
+  "library": "typhoeus",
   "moduleName": "Petstore",
   "gemVersion": "1.0.0"
 }

docs/generators/ruby.md

@@ -22,3 +22,6 @@ sidebar_label: ruby
 |gemAuthor|gem author (only one is supported).| |null|
 |gemAuthorEmail|gem author email (only one is supported).| |null|
 |hideGenerationTimestamp|Hides the generation timestamp when files are generated.| |true|
+|faraday|Faraday (https://github.com/lostisland/faraday)| |false|
+|typhoeus|Typhoeus (https://github.com/typhoeus/typhoeus)| |false|
+|library|HTTP library template (sub-template) to use|<dl><dt>**faraday**</dt><dd>Faraday (https://github.com/lostisland/faraday)</dd><dt>**typhoeus**</dt><dd>Typhoeus &gt;= 1.0.1 (https://github.com/typhoeus/typhoeus)</dd><dl>|faraday|

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/RubyClientCodegen.java

@@ -46,6 +46,8 @@ public class RubyClientCodegen extends AbstractRubyCodegen {
     public static final String GEM_DESCRIPTION = "gemDescription";
     public static final String GEM_AUTHOR = "gemAuthor";
     public static final String GEM_AUTHOR_EMAIL = "gemAuthorEmail";
+    public static final String FARADAY = "faraday";
+    public static final String TYPHOEUS = "typhoeus";
 
     protected String gemName;
     protected String moduleName;
@@ -54,8 +56,8 @@ public class RubyClientCodegen extends AbstractRubyCodegen {
     protected String libFolder = "lib";
     protected String gemLicense = "unlicense";
     protected String gemRequiredRubyVersion = ">= 1.9";
-    protected String gemHomepage = "http://org.openapitools";
-    protected String gemSummary = "A ruby wrapper for the REST APIs";
+    protected String gemHomepage = "https://openapitools.org";
+    protected String gemSummary = "A Ruby SDK for the REST API";
     protected String gemDescription = "This gem maps to a REST API";
     protected String gemAuthor = "";
     protected String gemAuthorEmail = "";
@@ -141,6 +143,15 @@ public class RubyClientCodegen extends AbstractRubyCodegen {
         cliOptions.add(new CliOption(CodegenConstants.HIDE_GENERATION_TIMESTAMP, CodegenConstants.HIDE_GENERATION_TIMESTAMP_DESC).
                 defaultValue(Boolean.TRUE.toString()));
 
+        supportedLibraries.put(FARADAY, "Faraday (https://github.com/lostisland/faraday) (Beta support)");
+        supportedLibraries.put(TYPHOEUS, "Typhoeus >= 1.0.1 (https://github.com/typhoeus/typhoeus)");
+
+        CliOption libraryOption = new CliOption(CodegenConstants.LIBRARY, "HTTP library template (sub-template) to use");
+        libraryOption.setEnum(supportedLibraries);
+        // set TYPHOEUS as the default
+        libraryOption.setDefault(TYPHOEUS);
+        cliOptions.add(libraryOption);
+        setLibrary(TYPHOEUS);
     }
 
     @Override
@@ -209,10 +220,8 @@ public class RubyClientCodegen extends AbstractRubyCodegen {
         setModelPackage("models");
         setApiPackage("api");
 
-        supportingFiles.add(new SupportingFile("gemspec.mustache", "", gemName + ".gemspec"));
         supportingFiles.add(new SupportingFile("gem.mustache", libFolder, gemName + ".rb"));
         String gemFolder = libFolder + File.separator + gemName;
-        supportingFiles.add(new SupportingFile("api_client.mustache", gemFolder, "api_client.rb"));
         supportingFiles.add(new SupportingFile("api_error.mustache", gemFolder, "api_error.rb"));
         supportingFiles.add(new SupportingFile("configuration.mustache", gemFolder, "configuration.rb"));
         supportingFiles.add(new SupportingFile("version.mustache", gemFolder, "version.rb"));
@@ -221,10 +230,20 @@ public class RubyClientCodegen extends AbstractRubyCodegen {
         supportingFiles.add(new SupportingFile("gitignore.mustache", "", ".gitignore"));
         supportingFiles.add(new SupportingFile("Rakefile.mustache", "", "Rakefile"));
         supportingFiles.add(new SupportingFile("Gemfile.mustache", "", "Gemfile"));
-        supportingFiles.add(new SupportingFile("Gemfile.lock.mustache", "", "Gemfile.lock"));
         supportingFiles.add(new SupportingFile("rubocop.mustache", "", ".rubocop.yml"));
         supportingFiles.add(new SupportingFile("travis.mustache", "", ".travis.yml"));
 
+        if (TYPHOEUS.equals(getLibrary())) {
+            supportingFiles.add(new SupportingFile("api_client.mustache", gemFolder, "api_client.rb"));
+            supportingFiles.add(new SupportingFile("gemspec.mustache", "", gemName + ".gemspec"));
+            supportingFiles.add(new SupportingFile("Gemfile.lock.mustache", "", "Gemfile.lock"));
+        } else if (FARADAY.equals(getLibrary())) {
+            supportingFiles.add(new SupportingFile("faraday_api_client.mustache", gemFolder, "api_client.rb"));
+            supportingFiles.add(new SupportingFile("faraday_gemspec.mustache", "", gemName + ".gemspec"));
+        } else {
+            throw new RuntimeException("Invalid HTTP library " +  getLibrary() + ". Only faraday, typhoeus are supported.");
+        }
+
         // test files should not be overwritten
         writeOptional(outputFolder, new SupportingFile("rspec.mustache", "", ".rspec"));
         writeOptional(outputFolder, new SupportingFile("spec_helper.mustache", specFolder, "spec_helper.rb"));

modules/openapi-generator/src/main/resources/ruby-client/faraday_api_client.mustache

@@ -0,0 +1,393 @@
+=begin
+{{> api_info}}
+=end
+
+require 'date'
+require 'faraday'
+require 'json'
+require 'logger'
+require 'tempfile'
+
+module {{moduleName}}
+  class ApiClient
+    # The Configuration object holding settings to be used in the API client.
+    attr_accessor :config
+
+    # Defines the headers to be used in HTTP requests of all API calls by default.
+    #
+    # @return [Hash]
+    attr_accessor :default_headers
+
+    # Initializes the ApiClient
+    # @option config [Configuration] Configuration for initializing the object, default to Configuration.default
+    def initialize(config = Configuration.default)
+      @config = config
+      @user_agent = "{{#httpUserAgent}}{{{.}}}{{/httpUserAgent}}{{^httpUserAgent}}OpenAPI-Generator/#{VERSION}/ruby{{/httpUserAgent}}"
+      @default_headers = {
+        'Content-Type' => 'application/json',
+        'User-Agent' => @user_agent
+      }
+    end
+
+    def self.default
+      @@default ||= ApiClient.new
+    end
+
+    # Call an API with given options.
+    #
+    # @return [Array<(Object, Integer, Hash)>] an array of 3 elements:
+    #   the data deserialized from response body (could be nil), response status code and response headers.
+    def call_api(http_method, path, opts = {})
+      connection = Faraday.new(:url => config.base_url) do |conn|
+        conn.basic_auth(config.username, config.password)
+        if opts[:header_params]["Content-Type"] == "multipart/form-data"
+            conn.request :multipart
+            conn.request :url_encoded
+        end
+        conn.adapter(Faraday.default_adapter)
+      end
+      begin
+          response = connection.public_send(http_method.to_sym.downcase) do |req|
+              build_request(http_method, path, req, opts)
+          end
+
+          if @config.debugging
+            @config.logger.debug "HTTP response body ~BEGIN~\n#{response.body}\n~END~\n"
+          end
+
+          unless response.success?
+            if response.status == 0
+              # Errors from libcurl will be made visible here
+              fail ApiError.new(:code => 0,
+                                :message => response.return_message)
+            else
+              fail ApiError.new(:code => response.status,
+                                :response_headers => response.headers,
+                                :response_body => response.body),
+                   response.reason_phrase
+            end
+          end
+      rescue Faraday::TimeoutError
+          fail ApiError.new('Connection timed out')
+      end
+
+      if opts[:return_type]
+        data = deserialize(response, opts[:return_type])
+      else
+        data = nil
+      end
+      return data, response.status, response.headers
+    end
+
+    # Builds the HTTP request
+    #
+    # @param [String] http_method HTTP method/verb (e.g. POST)
+    # @param [String] path URL path (e.g. /account/new)
+    # @option opts [Hash] :header_params Header parameters
+    # @option opts [Hash] :query_params Query parameters
+    # @option opts [Hash] :form_params Query parameters
+    # @option opts [Object] :body HTTP body (JSON/XML)
+    # @return [Typhoeus::Request] A Typhoeus Request
+    def build_request(http_method, path, request, opts = {})
+      url = build_request_url(path)
+      http_method = http_method.to_sym.downcase
+
+      header_params = @default_headers.merge(opts[:header_params] || {})
+      query_params = opts[:query_params] || {}
+      form_params = opts[:form_params] || {}
+
+      update_params_for_auth! header_params, query_params, opts[:auth_names]
+
+      # set ssl_verifyhosts option based on @config.verify_ssl_host (true/false)
+      _verify_ssl_host = @config.verify_ssl_host ? 2 : 0
+
+      req_opts = {
+        :method => http_method,
+        :headers => header_params,
+        :params => query_params,
+        :params_encoding => @config.params_encoding,
+        :timeout => @config.timeout,
+        :ssl_verifypeer => @config.verify_ssl,
+        :ssl_verifyhost => _verify_ssl_host,
+        :sslcert => @config.cert_file,
+        :sslkey => @config.key_file,
+        :verbose => @config.debugging
+      }
+
+      # set custom cert, if provided
+      req_opts[:cainfo] = @config.ssl_ca_cert if @config.ssl_ca_cert
+
+      if [:post, :patch, :put, :delete].include?(http_method)
+        req_body = build_request_body(header_params, form_params, opts[:body])
+        req_opts.update :body => req_body
+        if @config.debugging
+          @config.logger.debug "HTTP request body param ~BEGIN~\n#{req_body}\n~END~\n"
+        end
+      end
+      request.headers = header_params
+      request.body = req_body
+      request.url path
+      request.params = query_params
+      download_file(request) if opts[:return_type] == 'File'
+      request
+    end
+
+    # Check if the given MIME is a JSON MIME.
+    # JSON MIME examples:
+    #   application/json
+    #   application/json; charset=UTF8
+    #   APPLICATION/JSON
+    #   */*
+    # @param [String] mime MIME
+    # @return [Boolean] True if the MIME is application/json
+    def json_mime?(mime)
+      (mime == '*/*') || !(mime =~ /Application\/.*json(?!p)(;.*)?/i).nil?
+    end
+
+    # Deserialize the response to the given return type.
+    #
+    # @param [Response] response HTTP response
+    # @param [String] return_type some examples: "User", "Array<User>", "Hash<String, Integer>"
+    def deserialize(response, return_type)
+      body = response.body
+
+      # handle file downloading - return the File instance processed in request callbacks
+      # note that response body is empty when the file is written in chunks in request on_body callback
+      return @tempfile if return_type == 'File'
+
+      return nil if body.nil? || body.empty?
+
+      # return response body directly for String return type
+      return body if return_type == 'String'
+
+      # ensuring a default content type
+      content_type = response.headers['Content-Type'] || 'application/json'
+
+      fail "Content-Type is not supported: #{content_type}" unless json_mime?(content_type)
+
+      begin
+        data = JSON.parse("[#{body}]", :symbolize_names => true)[0]
+      rescue JSON::ParserError => e
+        if %w(String Date DateTime).include?(return_type)
+          data = body
+        else
+          raise e
+        end
+      end
+
+      convert_to_type data, return_type
+    end
+
+    # Convert data to the given return type.
+    # @param [Object] data Data to be converted
+    # @param [String] return_type Return type
+    # @return [Mixed] Data in a particular type
+    def convert_to_type(data, return_type)
+      return nil if data.nil?
+      case return_type
+      when 'String'
+        data.to_s
+      when 'Integer'
+        data.to_i
+      when 'Float'
+        data.to_f
+      when 'Boolean'
+        data == true
+      when 'DateTime'
+        # parse date time (expecting ISO 8601 format)
+        DateTime.parse data
+      when 'Date'
+        # parse date time (expecting ISO 8601 format)
+        Date.parse data
+      when 'Object'
+        # generic object (usually a Hash), return directly
+        data
+      when /\AArray<(.+)>\z/
+        # e.g. Array<Pet>
+        sub_type = $1
+        data.map { |item| convert_to_type(item, sub_type) }
+      when /\AHash\<String, (.+)\>\z/
+        # e.g. Hash<String, Integer>
+        sub_type = $1
+        {}.tap do |hash|
+          data.each { |k, v| hash[k] = convert_to_type(v, sub_type) }
+        end
+      else
+        # models, e.g. Pet
+        {{moduleName}}.const_get(return_type).build_from_hash(data)
+      end
+    end
+
+    # Save response body into a file in (the defined) temporary folder, using the filename
+    # from the "Content-Disposition" header if provided, otherwise a random filename.
+    # The response body is written to the file in chunks in order to handle files which
+    # size is larger than maximum Ruby String or even larger than the maximum memory a Ruby
+    # process can use.
+    #
+    # @see Configuration#temp_folder_path
+    def download_file(request)
+      tempfile = nil
+      encoding = nil
+      request.on_headers do |response|
+        content_disposition = response.headers['Content-Disposition']
+        if content_disposition && content_disposition =~ /filename=/i
+          filename = content_disposition[/filename=['"]?([^'"\s]+)['"]?/, 1]
+          prefix = sanitize_filename(filename)
+        else
+          prefix = 'download-'
+        end
+        prefix = prefix + '-' unless prefix.end_with?('-')
+        encoding = response.body.encoding
+        tempfile = Tempfile.open(prefix, @config.temp_folder_path, encoding: encoding)
+        @tempfile = tempfile
+      end
+      request.on_body do |chunk|
+        chunk.force_encoding(encoding)
+        tempfile.write(chunk)
+      end
+      request.on_complete do |response|
+        tempfile.close if tempfile
+        @config.logger.info "Temp file written to #{tempfile.path}, please copy the file to a proper folder "\
+                            "with e.g. `FileUtils.cp(tempfile.path, '/new/file/path')` otherwise the temp file "\
+                            "will be deleted automatically with GC. It's also recommended to delete the temp file "\
+                            "explicitly with `tempfile.delete`"
+      end
+    end
+
+    # Sanitize filename by removing path.
+    # e.g. ../../sun.gif becomes sun.gif
+    #
+    # @param [String] filename the filename to be sanitized
+    # @return [String] the sanitized filename
+    def sanitize_filename(filename)
+      filename.gsub(/.*[\/\\]/, '')
+    end
+
+    def build_request_url(path)
+      # Add leading and trailing slashes to path
+      path = "/#{path}".gsub(/\/+/, '/')
+      @config.base_url + path
+    end
+
+    # Builds the HTTP request body
+    #
+    # @param [Hash] header_params Header parameters
+    # @param [Hash] form_params Query parameters
+    # @param [Object] body HTTP body (JSON/XML)
+    # @return [String] HTTP body data in the form of string
+    def build_request_body(header_params, form_params, body)
+      # http form
+      if header_params['Content-Type'] == 'application/x-www-form-urlencoded' ||
+          header_params['Content-Type'] == 'multipart/form-data'
+        data = {}
+        form_params.each do |key, value|
+          case value
+          when ::File, ::Tempfile
+            data[key] = Faraday::UploadIO.new(value.path, '')
+          when ::Array, nil
+            # let Faraday handle Array and nil parameters
+            data[key] = value
+          else
+            data[key] = value.to_s
+          end
+        end
+      elsif body
+        data = body.is_a?(String) ? body : body.to_json
+      else
+        data = nil
+      end
+      data
+    end
+
+    # Update hearder and query params based on authentication settings.
+    #
+    # @param [Hash] header_params Header parameters
+    # @param [Hash] query_params Query parameters
+    # @param [String] auth_names Authentication scheme name
+    def update_params_for_auth!(header_params, query_params, auth_names)
+      Array(auth_names).each do |auth_name|
+        auth_setting = @config.auth_settings[auth_name]
+        next unless auth_setting
+        case auth_setting[:in]
+        when 'header' then header_params[auth_setting[:key]] = auth_setting[:value]
+        when 'query'  then query_params[auth_setting[:key]] = auth_setting[:value]
+        else fail ArgumentError, 'Authentication token must be in `query` of `header`'
+        end
+      end
+    end
+
+    # Sets user agent in HTTP header
+    #
+    # @param [String] user_agent User agent (e.g. openapi-generator/ruby/1.0.0)
+    def user_agent=(user_agent)
+      @user_agent = user_agent
+      @default_headers['User-Agent'] = @user_agent
+    end
+
+    # Return Accept header based on an array of accepts provided.
+    # @param [Array] accepts array for Accept
+    # @return [String] the Accept header (e.g. application/json)
+    def select_header_accept(accepts)
+      return nil if accepts.nil? || accepts.empty?
+      # use JSON when present, otherwise use all of the provided
+      json_accept = accepts.find { |s| json_mime?(s) }
+      json_accept || accepts.join(',')
+    end
+
+    # Return Content-Type header based on an array of content types provided.
+    # @param [Array] content_types array for Content-Type
+    # @return [String] the Content-Type header  (e.g. application/json)
+    def select_header_content_type(content_types)
+      # use application/json by default
+      return 'application/json' if content_types.nil? || content_types.empty?
+      # use JSON when present, otherwise use the first one
+      json_content_type = content_types.find { |s| json_mime?(s) }
+      json_content_type || content_types.first
+    end
+
+    # Convert object (array, hash, object, etc) to JSON string.
+    # @param [Object] model object to be converted into JSON string
+    # @return [String] JSON string representation of the object
+    def object_to_http_body(model)
+      return model if model.nil? || model.is_a?(String)
+      local_body = nil
+      if model.is_a?(Array)
+        local_body = model.map { |m| object_to_hash(m) }
+      else
+        local_body = object_to_hash(model)
+      end
+      local_body.to_json
+    end
+
+    # Convert object(non-array) to hash.
+    # @param [Object] obj object to be converted into JSON string
+    # @return [String] JSON string representation of the object
+    def object_to_hash(obj)
+      if obj.respond_to?(:to_hash)
+        obj.to_hash
+      else
+        obj
+      end
+    end
+
+    # Build parameter value according to the given collection format.
+    # @param [String] collection_format one of :csv, :ssv, :tsv, :pipes and :multi
+    def build_collection_param(param, collection_format)
+      case collection_format
+      when :csv
+        param.join(',')
+      when :ssv
+        param.join(' ')
+      when :tsv
+        param.join("\t")
+      when :pipes
+        param.join('|')
+      when :multi
+        # return the array directly as typhoeus will handle it as expected
+        param
+      else
+        fail "unknown collection format: #{collection_format.inspect}"
+      end
+    end
+  end
+end

modules/openapi-generator/src/main/resources/ruby-client/faraday_gemspec.mustache

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+
+=begin
+{{> api_info}}
+=end
+
+$:.push File.expand_path("../lib", __FILE__)
+require "{{gemName}}/version"
+
+Gem::Specification.new do |s|
+  s.name        = "{{gemName}}{{^gemName}}{{{appName}}}{{/gemName}}"
+  s.version     = {{moduleName}}::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["{{gemAuthor}}{{^gemAuthor}}OpenAPI-Generator{{/gemAuthor}}"]
+  s.email       = ["{{gemAuthorEmail}}{{^gemAuthorEmail}}{{infoEmail}}{{/gemAuthorEmail}}"]
+  s.homepage    = "{{gemHomepage}}{{^gemHomepage}}https://openapi-generator.tech{{/gemHomepage}}"
+  s.summary     = "{{gemSummary}}{{^gemSummary}}{{{appName}}} Ruby Gem{{/gemSummary}}"
+  s.description = "{{gemDescription}}{{^gemDescription}}{{{appDescription}}}{{^appDescription}}{{{appName}}} Ruby Gem{{/appDescription}}{{/gemDescription}}"
+  {{#gemLicense}}
+  s.license     = '{{{gemLicense}}}'
+  {{/gemLicense}}
+  {{^gemLicense}}
+  s.license     = "Unlicense"
+  {{/gemLicense}}
+  s.required_ruby_version = "{{{gemRequiredRubyVersion}}}{{^gemRequiredRubyVersion}}>= 1.9{{/gemRequiredRubyVersion}}"
+
+  s.add_runtime_dependency 'faraday', '>= 0.14.0'
+  s.add_runtime_dependency 'json', '~> 2.1', '>= 2.1.0'
+
+  s.add_development_dependency 'rspec', '~> 3.6', '>= 3.6.0'
+  s.add_development_dependency 'vcr', '~> 3.0', '>= 3.0.1'
+  s.add_development_dependency 'webmock', '~> 1.24', '>= 1.24.3'
+
+  s.files         = `find *`.split("\n").uniq.sort.select { |f| !f.empty? }
+  s.test_files    = `find spec/*`.split("\n")
+  s.executables   = []
+  s.require_paths = ["lib"]
+end

modules/openapi-generator/src/test/java/org/openapitools/codegen/options/RubyClientOptionsProvider.java

@@ -38,6 +38,7 @@ public class RubyClientOptionsProvider implements OptionsProvider {
     public static final String GEM_AUTHOR_EMAIL_VALUE = "foo";
     public static final String ALLOW_UNICODE_IDENTIFIERS_VALUE = "false";
     public static final String PREPEND_FORM_OR_BODY_PARAMETERS_VALUE = "true";
+    public static final String LIBRARY = "typhoeus";
 
     @Override
     public String getLanguage() {
@@ -62,6 +63,7 @@ public class RubyClientOptionsProvider implements OptionsProvider {
                 .put(CodegenConstants.HIDE_GENERATION_TIMESTAMP, "true")
                 .put(CodegenConstants.ALLOW_UNICODE_IDENTIFIERS, ALLOW_UNICODE_IDENTIFIERS_VALUE)
                 .put(CodegenConstants.PREPEND_FORM_OR_BODY_PARAMETERS, PREPEND_FORM_OR_BODY_PARAMETERS_VALUE)
+                .put(CodegenConstants.LIBRARY, LIBRARY)
                 .build();
     }
 

samples/client/petstore/ruby-faraday/.gitignore

@@ -0,0 +1,39 @@
+# Generated by: https://openapi-generator.tech
+#
+
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

samples/client/petstore/ruby-faraday/.openapi-generator-ignore

@@ -0,0 +1,23 @@
+# OpenAPI Generator Ignore
+# Generated by openapi-generator https://github.com/openapitools/openapi-generator
+
+# Use this file to prevent files from being overwritten by the generator.
+# The patterns follow closely to .gitignore or .dockerignore.
+
+# As an example, the C# client generator defines ApiClient.cs.
+# You can make changes and tell OpenAPI Generator to ignore just this file by uncommenting the following line:
+#ApiClient.cs
+
+# You can match any string of characters against a directory, file or extension with a single asterisk (*):
+#foo/*/qux
+# The above matches foo/bar/qux and foo/baz/qux, but not foo/bar/baz/qux
+
+# You can recursively match patterns against a directory, file or extension with a double asterisk (**):
+#foo/**/qux
+# This matches foo/bar/qux, foo/baz/qux, and foo/bar/baz/qux
+
+# You can also negate patterns with an exclamation (!).
+# For example, you can ignore all files in a docs folder with the file extension .md:
+#docs/*.md
+# Then explicitly reverse the ignore rule for a single file:
+#!docs/README.md

samples/client/petstore/ruby-faraday/.openapi-generator/VERSION

@@ -0,0 +1 @@
+3.3.3-SNAPSHOT

samples/client/petstore/ruby-faraday/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

samples/client/petstore/ruby-faraday/.rubocop.yml

@@ -0,0 +1,154 @@
+# This file is based on https://github.com/rails/rails/blob/master/.rubocop.yml (MIT license)
+# Automatically generated by OpenAPI Generator (https://openapi-generator.tech)
+AllCops:
+  TargetRubyVersion: 2.2
+  # RuboCop has a bunch of cops enabled by default. This setting tells RuboCop
+  # to ignore them, so only the ones explicitly set in this file are enabled.
+  DisabledByDefault: true
+  Exclude:
+    - '**/templates/**/*'
+    - '**/vendor/**/*'
+    - 'actionpack/lib/action_dispatch/journey/parser.rb'
+
+# Prefer &&/|| over and/or.
+Style/AndOr:
+  Enabled: true
+
+# Do not use braces for hash literals when they are the last argument of a
+# method call.
+Style/BracesAroundHashParameters:
+  Enabled: true
+  EnforcedStyle: context_dependent
+
+# Align `when` with `case`.
+Layout/CaseIndentation:
+  Enabled: true
+
+# Align comments with method definitions.
+Layout/CommentIndentation:
+  Enabled: true
+
+Layout/ElseAlignment:
+  Enabled: true
+
+Layout/EmptyLineAfterMagicComment:
+  Enabled: true
+
+# In a regular class definition, no empty lines around the body.
+Layout/EmptyLinesAroundClassBody:
+  Enabled: true
+
+# In a regular method definition, no empty lines around the body.
+Layout/EmptyLinesAroundMethodBody:
+  Enabled: true
+
+# In a regular module definition, no empty lines around the body.
+Layout/EmptyLinesAroundModuleBody:
+  Enabled: true
+
+Layout/FirstParameterIndentation:
+  Enabled: true
+
+# Use Ruby >= 1.9 syntax for hashes. Prefer { a: :b } over { :a => :b }.
+Style/HashSyntax:
+  Enabled: false
+
+# Method definitions after `private` or `protected` isolated calls need one
+# extra level of indentation.
+Layout/IndentationConsistency:
+  Enabled: true
+  EnforcedStyle: rails
+
+# Two spaces, no tabs (for indentation).
+Layout/IndentationWidth:
+  Enabled: true
+
+Layout/LeadingCommentSpace:
+  Enabled: true
+
+Layout/SpaceAfterColon:
+  Enabled: true
+
+Layout/SpaceAfterComma:
+  Enabled: true
+
+Layout/SpaceAroundEqualsInParameterDefault:
+  Enabled: true
+
+Layout/SpaceAroundKeyword:
+  Enabled: true
+
+Layout/SpaceAroundOperators:
+  Enabled: true
+
+Layout/SpaceBeforeComma:
+    Enabled: true
+
+Layout/SpaceBeforeFirstArg:
+    Enabled: true
+
+Style/DefWithParentheses:
+  Enabled: true
+
+# Defining a method with parameters needs parentheses.
+Style/MethodDefParentheses:
+  Enabled: true
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+  EnforcedStyle: always
+
+# Use `foo {}` not `foo{}`.
+Layout/SpaceBeforeBlockBraces:
+  Enabled: true
+
+# Use `foo { bar }` not `foo {bar}`.
+Layout/SpaceInsideBlockBraces:
+  Enabled: true
+
+# Use `{ a: 1 }` not `{a:1}`.
+Layout/SpaceInsideHashLiteralBraces:
+  Enabled: true
+
+Layout/SpaceInsideParens:
+  Enabled: true
+
+# Check quotes usage according to lint rule below.
+#Style/StringLiterals:
+#  Enabled: true
+#  EnforcedStyle: single_quotes
+
+# Detect hard tabs, no hard tabs.
+Layout/Tab:
+  Enabled: true
+
+# Blank lines should not have any spaces.
+Layout/TrailingBlankLines:
+  Enabled: true
+
+# No trailing whitespace.
+Layout/TrailingWhitespace:
+  Enabled: false
+
+# Use quotes for string literals when they are enough.
+Style/UnneededPercentQ:
+  Enabled: true
+
+# Align `end` with the matching keyword or starting expression except for
+# assignments, where it should be aligned with the LHS.
+Layout/EndAlignment:
+  Enabled: true
+  EnforcedStyleAlignWith: variable
+  AutoCorrect: true
+
+# Use my_method(my_arg) not my_method( my_arg ) or my_method my_arg.
+Lint/RequireParentheses:
+  Enabled: true
+
+Style/RedundantReturn:
+  Enabled: true
+  AllowMultipleReturnValues: true
+
+Style/Semicolon:
+  Enabled: true
+  AllowAsExpressionSeparator: true

samples/client/petstore/ruby-faraday/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development, :test do
+  gem 'rake', '~> 12.0.0'
+  gem 'pry-byebug'
+end

samples/client/petstore/ruby-faraday/README.md

@@ -0,0 +1,180 @@
+# petstore
+
+Petstore - the Ruby gem for the OpenAPI Petstore
+
+This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+This SDK is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project:
+
+- API version: 1.0.0
+- Package version: 1.0.0
+- Build package: org.openapitools.codegen.languages.RubyClientCodegen
+
+## Installation
+
+### Build a gem
+
+To build the Ruby code into a gem:
+
+```shell
+gem build petstore.gemspec
+```
+
+Then either install the gem locally:
+
+```shell
+gem install ./petstore-1.0.0.gem
+```
+(for development, run `gem install --dev ./petstore-1.0.0.gem` to install the development dependencies)
+
+or publish the gem to a gem hosting service, e.g. [RubyGems](https://rubygems.org/).
+
+Finally add this to the Gemfile:
+
+    gem 'petstore', '~> 1.0.0'
+
+### Install from Git
+
+If the Ruby gem is hosted at a git repository: https://github.com/GIT_USER_ID/GIT_REPO_ID, then add the following in the Gemfile:
+
+    gem 'petstore', :git => 'https://github.com/GIT_USER_ID/GIT_REPO_ID.git'
+
+### Include the Ruby code directly
+
+Include the Ruby code directly using `-I` as follows:
+
+```shell
+ruby -Ilib script.rb
+```
+
+## Getting Started
+
+Please follow the [installation](#installation) procedure and then run the following code:
+```ruby
+# Load the gem
+require 'petstore'
+
+api_instance = Petstore::AnotherFakeApi.new
+client = Petstore::Client.new # Client | client model
+
+begin
+  #To test special tags
+  result = api_instance.call_123_test_special_tags(client)
+  p result
+rescue Petstore::ApiError => e
+  puts "Exception when calling AnotherFakeApi->call_123_test_special_tags: #{e}"
+end
+
+```
+
+## Documentation for API Endpoints
+
+All URIs are relative to *http://petstore.swagger.io:80/v2*
+
+Class | Method | HTTP request | Description
+------------ | ------------- | ------------- | -------------
+*Petstore::AnotherFakeApi* | [**call_123_test_special_tags**](docs/AnotherFakeApi.md#call_123_test_special_tags) | **PATCH** /another-fake/dummy | To test special tags
+*Petstore::FakeApi* | [**fake_outer_boolean_serialize**](docs/FakeApi.md#fake_outer_boolean_serialize) | **POST** /fake/outer/boolean | 
+*Petstore::FakeApi* | [**fake_outer_composite_serialize**](docs/FakeApi.md#fake_outer_composite_serialize) | **POST** /fake/outer/composite | 
+*Petstore::FakeApi* | [**fake_outer_number_serialize**](docs/FakeApi.md#fake_outer_number_serialize) | **POST** /fake/outer/number | 
+*Petstore::FakeApi* | [**fake_outer_string_serialize**](docs/FakeApi.md#fake_outer_string_serialize) | **POST** /fake/outer/string | 
+*Petstore::FakeApi* | [**test_body_with_file_schema**](docs/FakeApi.md#test_body_with_file_schema) | **PUT** /fake/body-with-file-schema | 
+*Petstore::FakeApi* | [**test_body_with_query_params**](docs/FakeApi.md#test_body_with_query_params) | **PUT** /fake/body-with-query-params | 
+*Petstore::FakeApi* | [**test_client_model**](docs/FakeApi.md#test_client_model) | **PATCH** /fake | To test \"client\" model
+*Petstore::FakeApi* | [**test_endpoint_parameters**](docs/FakeApi.md#test_endpoint_parameters) | **POST** /fake | Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
+*Petstore::FakeApi* | [**test_enum_parameters**](docs/FakeApi.md#test_enum_parameters) | **GET** /fake | To test enum parameters
+*Petstore::FakeApi* | [**test_group_parameters**](docs/FakeApi.md#test_group_parameters) | **DELETE** /fake | Fake endpoint to test group parameters (optional)
+*Petstore::FakeApi* | [**test_inline_additional_properties**](docs/FakeApi.md#test_inline_additional_properties) | **POST** /fake/inline-additionalProperties | test inline additionalProperties
+*Petstore::FakeApi* | [**test_json_form_data**](docs/FakeApi.md#test_json_form_data) | **GET** /fake/jsonFormData | test json serialization of form data
+*Petstore::FakeClassnameTags123Api* | [**test_classname**](docs/FakeClassnameTags123Api.md#test_classname) | **PATCH** /fake_classname_test | To test class name in snake case
+*Petstore::PetApi* | [**add_pet**](docs/PetApi.md#add_pet) | **POST** /pet | Add a new pet to the store
+*Petstore::PetApi* | [**delete_pet**](docs/PetApi.md#delete_pet) | **DELETE** /pet/{petId} | Deletes a pet
+*Petstore::PetApi* | [**find_pets_by_status**](docs/PetApi.md#find_pets_by_status) | **GET** /pet/findByStatus | Finds Pets by status
+*Petstore::PetApi* | [**find_pets_by_tags**](docs/PetApi.md#find_pets_by_tags) | **GET** /pet/findByTags | Finds Pets by tags
+*Petstore::PetApi* | [**get_pet_by_id**](docs/PetApi.md#get_pet_by_id) | **GET** /pet/{petId} | Find pet by ID
+*Petstore::PetApi* | [**update_pet**](docs/PetApi.md#update_pet) | **PUT** /pet | Update an existing pet
+*Petstore::PetApi* | [**update_pet_with_form**](docs/PetApi.md#update_pet_with_form) | **POST** /pet/{petId} | Updates a pet in the store with form data
+*Petstore::PetApi* | [**upload_file**](docs/PetApi.md#upload_file) | **POST** /pet/{petId}/uploadImage | uploads an image
+*Petstore::PetApi* | [**upload_file_with_required_file**](docs/PetApi.md#upload_file_with_required_file) | **POST** /fake/{petId}/uploadImageWithRequiredFile | uploads an image (required)
+*Petstore::StoreApi* | [**delete_order**](docs/StoreApi.md#delete_order) | **DELETE** /store/order/{order_id} | Delete purchase order by ID
+*Petstore::StoreApi* | [**get_inventory**](docs/StoreApi.md#get_inventory) | **GET** /store/inventory | Returns pet inventories by status
+*Petstore::StoreApi* | [**get_order_by_id**](docs/StoreApi.md#get_order_by_id) | **GET** /store/order/{order_id} | Find purchase order by ID
+*Petstore::StoreApi* | [**place_order**](docs/StoreApi.md#place_order) | **POST** /store/order | Place an order for a pet
+*Petstore::UserApi* | [**create_user**](docs/UserApi.md#create_user) | **POST** /user | Create user
+*Petstore::UserApi* | [**create_users_with_array_input**](docs/UserApi.md#create_users_with_array_input) | **POST** /user/createWithArray | Creates list of users with given input array
+*Petstore::UserApi* | [**create_users_with_list_input**](docs/UserApi.md#create_users_with_list_input) | **POST** /user/createWithList | Creates list of users with given input array
+*Petstore::UserApi* | [**delete_user**](docs/UserApi.md#delete_user) | **DELETE** /user/{username} | Delete user
+*Petstore::UserApi* | [**get_user_by_name**](docs/UserApi.md#get_user_by_name) | **GET** /user/{username} | Get user by user name
+*Petstore::UserApi* | [**login_user**](docs/UserApi.md#login_user) | **GET** /user/login | Logs user into the system
+*Petstore::UserApi* | [**logout_user**](docs/UserApi.md#logout_user) | **GET** /user/logout | Logs out current logged in user session
+*Petstore::UserApi* | [**update_user**](docs/UserApi.md#update_user) | **PUT** /user/{username} | Updated user
+
+
+## Documentation for Models
+
+ - [Petstore::AdditionalPropertiesClass](docs/AdditionalPropertiesClass.md)
+ - [Petstore::Animal](docs/Animal.md)
+ - [Petstore::AnimalFarm](docs/AnimalFarm.md)
+ - [Petstore::ApiResponse](docs/ApiResponse.md)
+ - [Petstore::ArrayOfArrayOfNumberOnly](docs/ArrayOfArrayOfNumberOnly.md)
+ - [Petstore::ArrayOfNumberOnly](docs/ArrayOfNumberOnly.md)
+ - [Petstore::ArrayTest](docs/ArrayTest.md)
+ - [Petstore::Capitalization](docs/Capitalization.md)
+ - [Petstore::Cat](docs/Cat.md)
+ - [Petstore::Category](docs/Category.md)
+ - [Petstore::ClassModel](docs/ClassModel.md)
+ - [Petstore::Client](docs/Client.md)
+ - [Petstore::Dog](docs/Dog.md)
+ - [Petstore::EnumArrays](docs/EnumArrays.md)
+ - [Petstore::EnumClass](docs/EnumClass.md)
+ - [Petstore::EnumTest](docs/EnumTest.md)
+ - [Petstore::File](docs/File.md)
+ - [Petstore::FileSchemaTestClass](docs/FileSchemaTestClass.md)
+ - [Petstore::FormatTest](docs/FormatTest.md)
+ - [Petstore::HasOnlyReadOnly](docs/HasOnlyReadOnly.md)
+ - [Petstore::List](docs/List.md)
+ - [Petstore::MapTest](docs/MapTest.md)
+ - [Petstore::MixedPropertiesAndAdditionalPropertiesClass](docs/MixedPropertiesAndAdditionalPropertiesClass.md)
+ - [Petstore::Model200Response](docs/Model200Response.md)
+ - [Petstore::ModelReturn](docs/ModelReturn.md)
+ - [Petstore::Name](docs/Name.md)
+ - [Petstore::NumberOnly](docs/NumberOnly.md)
+ - [Petstore::Order](docs/Order.md)
+ - [Petstore::OuterComposite](docs/OuterComposite.md)
+ - [Petstore::OuterEnum](docs/OuterEnum.md)
+ - [Petstore::Pet](docs/Pet.md)
+ - [Petstore::ReadOnlyFirst](docs/ReadOnlyFirst.md)
+ - [Petstore::SpecialModelName](docs/SpecialModelName.md)
+ - [Petstore::StringBooleanMap](docs/StringBooleanMap.md)
+ - [Petstore::Tag](docs/Tag.md)
+ - [Petstore::User](docs/User.md)
+
+
+## Documentation for Authorization
+
+
+### api_key
+
+- **Type**: API key
+- **API key parameter name**: api_key
+- **Location**: HTTP header
+
+### api_key_query
+
+- **Type**: API key
+- **API key parameter name**: api_key_query
+- **Location**: URL query string
+
+### http_basic_test
+
+- **Type**: HTTP basic authentication
+
+### petstore_auth
+
+- **Type**: OAuth
+- **Flow**: implicit
+- **Authorization URL**: http://petstore.swagger.io/api/oauth/dialog
+- **Scopes**: 
+  - write:pets: modify pets in your account
+  - read:pets: read your pets
+

samples/client/petstore/ruby-faraday/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec)
+  task default: :spec
+rescue LoadError
+  # no rspec available
+end

samples/client/petstore/ruby-faraday/bin/console

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "petstore"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+api = Petstore::PetApi.new
+api.api_client.config.debugging = true
+pet = api.get_pet_by_id(545646631)
+new_pet = pet.dup
+new_pet.id = nil
+
+res = api.add_pet(new_pet)
+
+require "pry"
+Pry.start

samples/client/petstore/ruby-faraday/docs/AdditionalPropertiesClass.md

@@ -0,0 +1,9 @@
+# Petstore::AdditionalPropertiesClass
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**map_property** | **Hash<String, String>** |  | [optional] 
+**map_of_map_property** | **Hash<String, Hash<String, String>>** |  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/Animal.md

@@ -0,0 +1,9 @@
+# Petstore::Animal
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**class_name** | **String** |  | 
+**color** | **String** |  | [optional] [default to 'red']
+
+

samples/client/petstore/ruby-faraday/docs/AnimalFarm.md

@@ -0,0 +1,7 @@
+# Petstore::AnimalFarm
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+
+

samples/client/petstore/ruby-faraday/docs/AnotherFakeApi.md

@@ -0,0 +1,54 @@
+# Petstore::AnotherFakeApi
+
+All URIs are relative to *http://petstore.swagger.io:80/v2*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**call_123_test_special_tags**](AnotherFakeApi.md#call_123_test_special_tags) | **PATCH** /another-fake/dummy | To test special tags
+
+
+# **call_123_test_special_tags**
+> Client call_123_test_special_tags(client)
+
+To test special tags
+
+To test special tags and operation ID starting with number
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+
+api_instance = Petstore::AnotherFakeApi.new
+client = Petstore::Client.new # Client | client model
+
+begin
+  #To test special tags
+  result = api_instance.call_123_test_special_tags(client)
+  p result
+rescue Petstore::ApiError => e
+  puts "Exception when calling AnotherFakeApi->call_123_test_special_tags: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **client** | [**Client**](Client.md)| client model | 
+
+### Return type
+
+[**Client**](Client.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+
+

samples/client/petstore/ruby-faraday/docs/ApiResponse.md

@@ -0,0 +1,10 @@
+# Petstore::ApiResponse
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**code** | **Integer** |  | [optional] 
+**type** | **String** |  | [optional] 
+**message** | **String** |  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/ArrayOfArrayOfNumberOnly.md

@@ -0,0 +1,8 @@
+# Petstore::ArrayOfArrayOfNumberOnly
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**array_array_number** | **Array<Array<Float>>** |  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/ArrayOfNumberOnly.md

@@ -0,0 +1,8 @@
+# Petstore::ArrayOfNumberOnly
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**array_number** | **Array<Float>** |  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/ArrayTest.md

@@ -0,0 +1,10 @@
+# Petstore::ArrayTest
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**array_of_string** | **Array<String>** |  | [optional] 
+**array_array_of_integer** | **Array<Array<Integer>>** |  | [optional] 
+**array_array_of_model** | **Array<Array<ReadOnlyFirst>>** |  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/Capitalization.md

@@ -0,0 +1,13 @@
+# Petstore::Capitalization
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**small_camel** | **String** |  | [optional] 
+**capital_camel** | **String** |  | [optional] 
+**small_snake** | **String** |  | [optional] 
+**capital_snake** | **String** |  | [optional] 
+**sca_eth_flow_points** | **String** |  | [optional] 
+**att_name** | **String** | Name of the pet  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/Cat.md

@@ -0,0 +1,10 @@
+# Petstore::Cat
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**class_name** | **String** |  | 
+**color** | **String** |  | [optional] [default to 'red']
+**declawed** | **BOOLEAN** |  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/Category.md

@@ -0,0 +1,9 @@
+# Petstore::Category
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**id** | **Integer** |  | [optional] 
+**name** | **String** |  | [default to 'default-name']
+
+

samples/client/petstore/ruby-faraday/docs/ClassModel.md

@@ -0,0 +1,8 @@
+# Petstore::ClassModel
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**_class** | **String** |  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/Client.md

@@ -0,0 +1,8 @@
+# Petstore::Client
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**client** | **String** |  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/Dog.md

@@ -0,0 +1,10 @@
+# Petstore::Dog
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**class_name** | **String** |  | 
+**color** | **String** |  | [optional] [default to 'red']
+**breed** | **String** |  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/EnumArrays.md

@@ -0,0 +1,9 @@
+# Petstore::EnumArrays
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**just_symbol** | **String** |  | [optional] 
+**array_enum** | **Array<String>** |  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/EnumClass.md

@@ -0,0 +1,7 @@
+# Petstore::EnumClass
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+
+

samples/client/petstore/ruby-faraday/docs/EnumTest.md

@@ -0,0 +1,12 @@
+# Petstore::EnumTest
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**enum_string** | **String** |  | [optional] 
+**enum_string_required** | **String** |  | 
+**enum_integer** | **Integer** |  | [optional] 
+**enum_number** | **Float** |  | [optional] 
+**outer_enum** | [**OuterEnum**](OuterEnum.md) |  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/FakeApi.md

@@ -0,0 +1,615 @@
+# Petstore::FakeApi
+
+All URIs are relative to *http://petstore.swagger.io:80/v2*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**fake_outer_boolean_serialize**](FakeApi.md#fake_outer_boolean_serialize) | **POST** /fake/outer/boolean | 
+[**fake_outer_composite_serialize**](FakeApi.md#fake_outer_composite_serialize) | **POST** /fake/outer/composite | 
+[**fake_outer_number_serialize**](FakeApi.md#fake_outer_number_serialize) | **POST** /fake/outer/number | 
+[**fake_outer_string_serialize**](FakeApi.md#fake_outer_string_serialize) | **POST** /fake/outer/string | 
+[**test_body_with_file_schema**](FakeApi.md#test_body_with_file_schema) | **PUT** /fake/body-with-file-schema | 
+[**test_body_with_query_params**](FakeApi.md#test_body_with_query_params) | **PUT** /fake/body-with-query-params | 
+[**test_client_model**](FakeApi.md#test_client_model) | **PATCH** /fake | To test \"client\" model
+[**test_endpoint_parameters**](FakeApi.md#test_endpoint_parameters) | **POST** /fake | Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
+[**test_enum_parameters**](FakeApi.md#test_enum_parameters) | **GET** /fake | To test enum parameters
+[**test_group_parameters**](FakeApi.md#test_group_parameters) | **DELETE** /fake | Fake endpoint to test group parameters (optional)
+[**test_inline_additional_properties**](FakeApi.md#test_inline_additional_properties) | **POST** /fake/inline-additionalProperties | test inline additionalProperties
+[**test_json_form_data**](FakeApi.md#test_json_form_data) | **GET** /fake/jsonFormData | test json serialization of form data
+
+
+# **fake_outer_boolean_serialize**
+> BOOLEAN fake_outer_boolean_serialize(opts)
+
+
+
+Test serialization of outer boolean types
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+
+api_instance = Petstore::FakeApi.new
+opts = {
+  body: true # BOOLEAN | Input boolean as post body
+}
+
+begin
+  result = api_instance.fake_outer_boolean_serialize(opts)
+  p result
+rescue Petstore::ApiError => e
+  puts "Exception when calling FakeApi->fake_outer_boolean_serialize: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **body** | **BOOLEAN**| Input boolean as post body | [optional] 
+
+### Return type
+
+**BOOLEAN**
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: */*
+
+
+
+# **fake_outer_composite_serialize**
+> OuterComposite fake_outer_composite_serialize(opts)
+
+
+
+Test serialization of object with outer number type
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+
+api_instance = Petstore::FakeApi.new
+opts = {
+  outer_composite: Petstore::OuterComposite.new # OuterComposite | Input composite as post body
+}
+
+begin
+  result = api_instance.fake_outer_composite_serialize(opts)
+  p result
+rescue Petstore::ApiError => e
+  puts "Exception when calling FakeApi->fake_outer_composite_serialize: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **outer_composite** | [**OuterComposite**](OuterComposite.md)| Input composite as post body | [optional] 
+
+### Return type
+
+[**OuterComposite**](OuterComposite.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: */*
+
+
+
+# **fake_outer_number_serialize**
+> Float fake_outer_number_serialize(opts)
+
+
+
+Test serialization of outer number types
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+
+api_instance = Petstore::FakeApi.new
+opts = {
+  body: 3.4 # Float | Input number as post body
+}
+
+begin
+  result = api_instance.fake_outer_number_serialize(opts)
+  p result
+rescue Petstore::ApiError => e
+  puts "Exception when calling FakeApi->fake_outer_number_serialize: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **body** | **Float**| Input number as post body | [optional] 
+
+### Return type
+
+**Float**
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: */*
+
+
+
+# **fake_outer_string_serialize**
+> String fake_outer_string_serialize(opts)
+
+
+
+Test serialization of outer string types
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+
+api_instance = Petstore::FakeApi.new
+opts = {
+  body: 'body_example' # String | Input string as post body
+}
+
+begin
+  result = api_instance.fake_outer_string_serialize(opts)
+  p result
+rescue Petstore::ApiError => e
+  puts "Exception when calling FakeApi->fake_outer_string_serialize: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **body** | **String**| Input string as post body | [optional] 
+
+### Return type
+
+**String**
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: */*
+
+
+
+# **test_body_with_file_schema**
+> test_body_with_file_schema(file_schema_test_class)
+
+
+
+For this test, the body for this request much reference a schema named `File`.
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+
+api_instance = Petstore::FakeApi.new
+file_schema_test_class = Petstore::FileSchemaTestClass.new # FileSchemaTestClass | 
+
+begin
+  api_instance.test_body_with_file_schema(file_schema_test_class)
+rescue Petstore::ApiError => e
+  puts "Exception when calling FakeApi->test_body_with_file_schema: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **file_schema_test_class** | [**FileSchemaTestClass**](FileSchemaTestClass.md)|  | 
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: Not defined
+
+
+
+# **test_body_with_query_params**
+> test_body_with_query_params(query, user)
+
+
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+
+api_instance = Petstore::FakeApi.new
+query = 'query_example' # String | 
+user = Petstore::User.new # User | 
+
+begin
+  api_instance.test_body_with_query_params(query, user)
+rescue Petstore::ApiError => e
+  puts "Exception when calling FakeApi->test_body_with_query_params: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **query** | **String**|  | 
+ **user** | [**User**](User.md)|  | 
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: Not defined
+
+
+
+# **test_client_model**
+> Client test_client_model(client)
+
+To test \"client\" model
+
+To test \"client\" model
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+
+api_instance = Petstore::FakeApi.new
+client = Petstore::Client.new # Client | client model
+
+begin
+  #To test \"client\" model
+  result = api_instance.test_client_model(client)
+  p result
+rescue Petstore::ApiError => e
+  puts "Exception when calling FakeApi->test_client_model: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **client** | [**Client**](Client.md)| client model | 
+
+### Return type
+
+[**Client**](Client.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+
+
+# **test_endpoint_parameters**
+> test_endpoint_parameters(number, double, pattern_without_delimiter, byte, opts)
+
+Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
+
+Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+# setup authorization
+Petstore.configure do |config|
+  # Configure HTTP basic authorization: http_basic_test
+  config.username = 'YOUR USERNAME'
+  config.password = 'YOUR PASSWORD'
+end
+
+api_instance = Petstore::FakeApi.new
+number = 3.4 # Float | None
+double = 3.4 # Float | None
+pattern_without_delimiter = 'pattern_without_delimiter_example' # String | None
+byte = 'byte_example' # String | None
+opts = {
+  integer: 56, # Integer | None
+  int32: 56, # Integer | None
+  int64: 56, # Integer | None
+  float: 3.4, # Float | None
+  string: 'string_example', # String | None
+  binary: File.new('/path/to/file'), # File | None
+  date: Date.parse('2013-10-20'), # Date | None
+  date_time: DateTime.parse('2013-10-20T19:20:30+01:00'), # DateTime | None
+  password: 'password_example', # String | None
+  callback: 'callback_example' # String | None
+}
+
+begin
+  #Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
+  api_instance.test_endpoint_parameters(number, double, pattern_without_delimiter, byte, opts)
+rescue Petstore::ApiError => e
+  puts "Exception when calling FakeApi->test_endpoint_parameters: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **number** | **Float**| None | 
+ **double** | **Float**| None | 
+ **pattern_without_delimiter** | **String**| None | 
+ **byte** | **String**| None | 
+ **integer** | **Integer**| None | [optional] 
+ **int32** | **Integer**| None | [optional] 
+ **int64** | **Integer**| None | [optional] 
+ **float** | **Float**| None | [optional] 
+ **string** | **String**| None | [optional] 
+ **binary** | **File**| None | [optional] 
+ **date** | **Date**| None | [optional] 
+ **date_time** | **DateTime**| None | [optional] 
+ **password** | **String**| None | [optional] 
+ **callback** | **String**| None | [optional] 
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+[http_basic_test](../README.md#http_basic_test)
+
+### HTTP request headers
+
+ - **Content-Type**: application/x-www-form-urlencoded
+ - **Accept**: Not defined
+
+
+
+# **test_enum_parameters**
+> test_enum_parameters(opts)
+
+To test enum parameters
+
+To test enum parameters
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+
+api_instance = Petstore::FakeApi.new
+opts = {
+  enum_header_string_array: ['enum_header_string_array_example'], # Array<String> | Header parameter enum test (string array)
+  enum_header_string: '-efg', # String | Header parameter enum test (string)
+  enum_query_string_array: ['enum_query_string_array_example'], # Array<String> | Query parameter enum test (string array)
+  enum_query_string: '-efg', # String | Query parameter enum test (string)
+  enum_query_integer: 56, # Integer | Query parameter enum test (double)
+  enum_query_double: 3.4, # Float | Query parameter enum test (double)
+  enum_form_string_array: '$', # Array<String> | Form parameter enum test (string array)
+  enum_form_string: '-efg' # String | Form parameter enum test (string)
+}
+
+begin
+  #To test enum parameters
+  api_instance.test_enum_parameters(opts)
+rescue Petstore::ApiError => e
+  puts "Exception when calling FakeApi->test_enum_parameters: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **enum_header_string_array** | [**Array&lt;String&gt;**](String.md)| Header parameter enum test (string array) | [optional] 
+ **enum_header_string** | **String**| Header parameter enum test (string) | [optional] [default to &#39;-efg&#39;]
+ **enum_query_string_array** | [**Array&lt;String&gt;**](String.md)| Query parameter enum test (string array) | [optional] 
+ **enum_query_string** | **String**| Query parameter enum test (string) | [optional] [default to &#39;-efg&#39;]
+ **enum_query_integer** | **Integer**| Query parameter enum test (double) | [optional] 
+ **enum_query_double** | **Float**| Query parameter enum test (double) | [optional] 
+ **enum_form_string_array** | [**Array&lt;String&gt;**](String.md)| Form parameter enum test (string array) | [optional] [default to &#39;$&#39;]
+ **enum_form_string** | **String**| Form parameter enum test (string) | [optional] [default to &#39;-efg&#39;]
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: application/x-www-form-urlencoded
+ - **Accept**: Not defined
+
+
+
+# **test_group_parameters**
+> test_group_parameters(required_string_group, required_boolean_group, required_int64_group, opts)
+
+Fake endpoint to test group parameters (optional)
+
+Fake endpoint to test group parameters (optional)
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+
+api_instance = Petstore::FakeApi.new
+required_string_group = 56 # Integer | Required String in group parameters
+required_boolean_group = true # BOOLEAN | Required Boolean in group parameters
+required_int64_group = 56 # Integer | Required Integer in group parameters
+opts = {
+  string_group: 56, # Integer | String in group parameters
+  boolean_group: true, # BOOLEAN | Boolean in group parameters
+  int64_group: 56 # Integer | Integer in group parameters
+}
+
+begin
+  #Fake endpoint to test group parameters (optional)
+  api_instance.test_group_parameters(required_string_group, required_boolean_group, required_int64_group, opts)
+rescue Petstore::ApiError => e
+  puts "Exception when calling FakeApi->test_group_parameters: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **required_string_group** | **Integer**| Required String in group parameters | 
+ **required_boolean_group** | **BOOLEAN**| Required Boolean in group parameters | 
+ **required_int64_group** | **Integer**| Required Integer in group parameters | 
+ **string_group** | **Integer**| String in group parameters | [optional] 
+ **boolean_group** | **BOOLEAN**| Boolean in group parameters | [optional] 
+ **int64_group** | **Integer**| Integer in group parameters | [optional] 
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: Not defined
+
+
+
+# **test_inline_additional_properties**
+> test_inline_additional_properties(request_body)
+
+test inline additionalProperties
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+
+api_instance = Petstore::FakeApi.new
+request_body = {'key' => 'request_body_example'} # Hash<String, String> | request body
+
+begin
+  #test inline additionalProperties
+  api_instance.test_inline_additional_properties(request_body)
+rescue Petstore::ApiError => e
+  puts "Exception when calling FakeApi->test_inline_additional_properties: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **request_body** | [**Hash&lt;String, String&gt;**](String.md)| request body | 
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: Not defined
+
+
+
+# **test_json_form_data**
+> test_json_form_data(param, param2)
+
+test json serialization of form data
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+
+api_instance = Petstore::FakeApi.new
+param = 'param_example' # String | field1
+param2 = 'param2_example' # String | field2
+
+begin
+  #test json serialization of form data
+  api_instance.test_json_form_data(param, param2)
+rescue Petstore::ApiError => e
+  puts "Exception when calling FakeApi->test_json_form_data: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **param** | **String**| field1 | 
+ **param2** | **String**| field2 | 
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: application/x-www-form-urlencoded
+ - **Accept**: Not defined
+
+
+

samples/client/petstore/ruby-faraday/docs/FakeClassnameTags123Api.md

@@ -0,0 +1,61 @@
+# Petstore::FakeClassnameTags123Api
+
+All URIs are relative to *http://petstore.swagger.io:80/v2*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**test_classname**](FakeClassnameTags123Api.md#test_classname) | **PATCH** /fake_classname_test | To test class name in snake case
+
+
+# **test_classname**
+> Client test_classname(client)
+
+To test class name in snake case
+
+To test class name in snake case
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+# setup authorization
+Petstore.configure do |config|
+  # Configure API key authorization: api_key_query
+  config.api_key['api_key_query'] = 'YOUR API KEY'
+  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
+  #config.api_key_prefix['api_key_query'] = 'Bearer'
+end
+
+api_instance = Petstore::FakeClassnameTags123Api.new
+client = Petstore::Client.new # Client | client model
+
+begin
+  #To test class name in snake case
+  result = api_instance.test_classname(client)
+  p result
+rescue Petstore::ApiError => e
+  puts "Exception when calling FakeClassnameTags123Api->test_classname: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **client** | [**Client**](Client.md)| client model | 
+
+### Return type
+
+[**Client**](Client.md)
+
+### Authorization
+
+[api_key_query](../README.md#api_key_query)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+
+

samples/client/petstore/ruby-faraday/docs/File.md

@@ -0,0 +1,8 @@
+# Petstore::File
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**source_uri** | **String** | Test capitalization | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/FileSchemaTestClass.md

@@ -0,0 +1,9 @@
+# Petstore::FileSchemaTestClass
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**file** | **File** |  | [optional] 
+**files** | **Array<File>** |  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/FormatTest.md

@@ -0,0 +1,20 @@
+# Petstore::FormatTest
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**integer** | **Integer** |  | [optional] 
+**int32** | **Integer** |  | [optional] 
+**int64** | **Integer** |  | [optional] 
+**number** | **Float** |  | 
+**float** | **Float** |  | [optional] 
+**double** | **Float** |  | [optional] 
+**string** | **String** |  | [optional] 
+**byte** | **String** |  | 
+**binary** | **File** |  | [optional] 
+**date** | **Date** |  | 
+**date_time** | **DateTime** |  | [optional] 
+**uuid** | **String** |  | [optional] 
+**password** | **String** |  | 
+
+

samples/client/petstore/ruby-faraday/docs/HasOnlyReadOnly.md

@@ -0,0 +1,9 @@
+# Petstore::HasOnlyReadOnly
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**bar** | **String** |  | [optional] 
+**foo** | **String** |  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/List.md

@@ -0,0 +1,8 @@
+# Petstore::List
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**_123_list** | **String** |  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/MapTest.md

@@ -0,0 +1,11 @@
+# Petstore::MapTest
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**map_map_of_string** | **Hash<String, Hash<String, String>>** |  | [optional] 
+**map_of_enum_string** | **Hash<String, String>** |  | [optional] 
+**direct_map** | **Hash<String, BOOLEAN>** |  | [optional] 
+**indirect_map** | **Hash<String, BOOLEAN>** |  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/MixedPropertiesAndAdditionalPropertiesClass.md

@@ -0,0 +1,10 @@
+# Petstore::MixedPropertiesAndAdditionalPropertiesClass
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**uuid** | **String** |  | [optional] 
+**date_time** | **DateTime** |  | [optional] 
+**map** | [**Hash<String, Animal>**](Animal.md) |  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/Model200Response.md

@@ -0,0 +1,9 @@
+# Petstore::Model200Response
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**name** | **Integer** |  | [optional] 
+**_class** | **String** |  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/ModelReturn.md

@@ -0,0 +1,8 @@
+# Petstore::ModelReturn
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**_return** | **Integer** |  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/Name.md

@@ -0,0 +1,11 @@
+# Petstore::Name
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**name** | **Integer** |  | 
+**snake_case** | **Integer** |  | [optional] 
+**property** | **String** |  | [optional] 
+**_123_number** | **Integer** |  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/NumberOnly.md

@@ -0,0 +1,8 @@
+# Petstore::NumberOnly
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**just_number** | **Float** |  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/Order.md

@@ -0,0 +1,13 @@
+# Petstore::Order
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**id** | **Integer** |  | [optional] 
+**pet_id** | **Integer** |  | [optional] 
+**quantity** | **Integer** |  | [optional] 
+**ship_date** | **DateTime** |  | [optional] 
+**status** | **String** | Order Status | [optional] 
+**complete** | **BOOLEAN** |  | [optional] [default to false]
+
+

samples/client/petstore/ruby-faraday/docs/OuterComposite.md

@@ -0,0 +1,10 @@
+# Petstore::OuterComposite
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**my_number** | **Float** |  | [optional] 
+**my_string** | **String** |  | [optional] 
+**my_boolean** | **BOOLEAN** |  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/OuterEnum.md

@@ -0,0 +1,7 @@
+# Petstore::OuterEnum
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+
+

samples/client/petstore/ruby-faraday/docs/Pet.md

@@ -0,0 +1,13 @@
+# Petstore::Pet
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**id** | **Integer** |  | [optional] 
+**category** | [**Category**](Category.md) |  | [optional] 
+**name** | **String** |  | 
+**photo_urls** | **Array<String>** |  | 
+**tags** | [**Array<Tag>**](Tag.md) |  | [optional] 
+**status** | **String** | pet status in the store | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/PetApi.md

@@ -0,0 +1,475 @@
+# Petstore::PetApi
+
+All URIs are relative to *http://petstore.swagger.io:80/v2*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**add_pet**](PetApi.md#add_pet) | **POST** /pet | Add a new pet to the store
+[**delete_pet**](PetApi.md#delete_pet) | **DELETE** /pet/{petId} | Deletes a pet
+[**find_pets_by_status**](PetApi.md#find_pets_by_status) | **GET** /pet/findByStatus | Finds Pets by status
+[**find_pets_by_tags**](PetApi.md#find_pets_by_tags) | **GET** /pet/findByTags | Finds Pets by tags
+[**get_pet_by_id**](PetApi.md#get_pet_by_id) | **GET** /pet/{petId} | Find pet by ID
+[**update_pet**](PetApi.md#update_pet) | **PUT** /pet | Update an existing pet
+[**update_pet_with_form**](PetApi.md#update_pet_with_form) | **POST** /pet/{petId} | Updates a pet in the store with form data
+[**upload_file**](PetApi.md#upload_file) | **POST** /pet/{petId}/uploadImage | uploads an image
+[**upload_file_with_required_file**](PetApi.md#upload_file_with_required_file) | **POST** /fake/{petId}/uploadImageWithRequiredFile | uploads an image (required)
+
+
+# **add_pet**
+> add_pet(pet)
+
+Add a new pet to the store
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+# setup authorization
+Petstore.configure do |config|
+  # Configure OAuth2 access token for authorization: petstore_auth
+  config.access_token = 'YOUR ACCESS TOKEN'
+end
+
+api_instance = Petstore::PetApi.new
+pet = Petstore::Pet.new # Pet | Pet object that needs to be added to the store
+
+begin
+  #Add a new pet to the store
+  api_instance.add_pet(pet)
+rescue Petstore::ApiError => e
+  puts "Exception when calling PetApi->add_pet: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **pet** | [**Pet**](Pet.md)| Pet object that needs to be added to the store | 
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+[petstore_auth](../README.md#petstore_auth)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json, application/xml
+ - **Accept**: Not defined
+
+
+
+# **delete_pet**
+> delete_pet(pet_id, opts)
+
+Deletes a pet
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+# setup authorization
+Petstore.configure do |config|
+  # Configure OAuth2 access token for authorization: petstore_auth
+  config.access_token = 'YOUR ACCESS TOKEN'
+end
+
+api_instance = Petstore::PetApi.new
+pet_id = 56 # Integer | Pet id to delete
+opts = {
+  api_key: 'api_key_example' # String | 
+}
+
+begin
+  #Deletes a pet
+  api_instance.delete_pet(pet_id, opts)
+rescue Petstore::ApiError => e
+  puts "Exception when calling PetApi->delete_pet: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **pet_id** | **Integer**| Pet id to delete | 
+ **api_key** | **String**|  | [optional] 
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+[petstore_auth](../README.md#petstore_auth)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: Not defined
+
+
+
+# **find_pets_by_status**
+> Array<Pet> find_pets_by_status(status)
+
+Finds Pets by status
+
+Multiple status values can be provided with comma separated strings
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+# setup authorization
+Petstore.configure do |config|
+  # Configure OAuth2 access token for authorization: petstore_auth
+  config.access_token = 'YOUR ACCESS TOKEN'
+end
+
+api_instance = Petstore::PetApi.new
+status = ['status_example'] # Array<String> | Status values that need to be considered for filter
+
+begin
+  #Finds Pets by status
+  result = api_instance.find_pets_by_status(status)
+  p result
+rescue Petstore::ApiError => e
+  puts "Exception when calling PetApi->find_pets_by_status: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **status** | [**Array&lt;String&gt;**](String.md)| Status values that need to be considered for filter | 
+
+### Return type
+
+[**Array&lt;Pet&gt;**](Pet.md)
+
+### Authorization
+
+[petstore_auth](../README.md#petstore_auth)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+
+
+# **find_pets_by_tags**
+> Array&lt;Pet&gt; find_pets_by_tags(tags)
+
+Finds Pets by tags
+
+Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+# setup authorization
+Petstore.configure do |config|
+  # Configure OAuth2 access token for authorization: petstore_auth
+  config.access_token = 'YOUR ACCESS TOKEN'
+end
+
+api_instance = Petstore::PetApi.new
+tags = ['tags_example'] # Array<String> | Tags to filter by
+
+begin
+  #Finds Pets by tags
+  result = api_instance.find_pets_by_tags(tags)
+  p result
+rescue Petstore::ApiError => e
+  puts "Exception when calling PetApi->find_pets_by_tags: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **tags** | [**Array&lt;String&gt;**](String.md)| Tags to filter by | 
+
+### Return type
+
+[**Array&lt;Pet&gt;**](Pet.md)
+
+### Authorization
+
+[petstore_auth](../README.md#petstore_auth)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+
+
+# **get_pet_by_id**
+> Pet get_pet_by_id(pet_id)
+
+Find pet by ID
+
+Returns a single pet
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+# setup authorization
+Petstore.configure do |config|
+  # Configure API key authorization: api_key
+  config.api_key['api_key'] = 'YOUR API KEY'
+  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
+  #config.api_key_prefix['api_key'] = 'Bearer'
+end
+
+api_instance = Petstore::PetApi.new
+pet_id = 56 # Integer | ID of pet to return
+
+begin
+  #Find pet by ID
+  result = api_instance.get_pet_by_id(pet_id)
+  p result
+rescue Petstore::ApiError => e
+  puts "Exception when calling PetApi->get_pet_by_id: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **pet_id** | **Integer**| ID of pet to return | 
+
+### Return type
+
+[**Pet**](Pet.md)
+
+### Authorization
+
+[api_key](../README.md#api_key)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+
+
+# **update_pet**
+> update_pet(pet)
+
+Update an existing pet
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+# setup authorization
+Petstore.configure do |config|
+  # Configure OAuth2 access token for authorization: petstore_auth
+  config.access_token = 'YOUR ACCESS TOKEN'
+end
+
+api_instance = Petstore::PetApi.new
+pet = Petstore::Pet.new # Pet | Pet object that needs to be added to the store
+
+begin
+  #Update an existing pet
+  api_instance.update_pet(pet)
+rescue Petstore::ApiError => e
+  puts "Exception when calling PetApi->update_pet: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **pet** | [**Pet**](Pet.md)| Pet object that needs to be added to the store | 
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+[petstore_auth](../README.md#petstore_auth)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json, application/xml
+ - **Accept**: Not defined
+
+
+
+# **update_pet_with_form**
+> update_pet_with_form(pet_id, opts)
+
+Updates a pet in the store with form data
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+# setup authorization
+Petstore.configure do |config|
+  # Configure OAuth2 access token for authorization: petstore_auth
+  config.access_token = 'YOUR ACCESS TOKEN'
+end
+
+api_instance = Petstore::PetApi.new
+pet_id = 56 # Integer | ID of pet that needs to be updated
+opts = {
+  name: 'name_example', # String | Updated name of the pet
+  status: 'status_example' # String | Updated status of the pet
+}
+
+begin
+  #Updates a pet in the store with form data
+  api_instance.update_pet_with_form(pet_id, opts)
+rescue Petstore::ApiError => e
+  puts "Exception when calling PetApi->update_pet_with_form: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **pet_id** | **Integer**| ID of pet that needs to be updated | 
+ **name** | **String**| Updated name of the pet | [optional] 
+ **status** | **String**| Updated status of the pet | [optional] 
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+[petstore_auth](../README.md#petstore_auth)
+
+### HTTP request headers
+
+ - **Content-Type**: application/x-www-form-urlencoded
+ - **Accept**: Not defined
+
+
+
+# **upload_file**
+> ApiResponse upload_file(pet_id, opts)
+
+uploads an image
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+# setup authorization
+Petstore.configure do |config|
+  # Configure OAuth2 access token for authorization: petstore_auth
+  config.access_token = 'YOUR ACCESS TOKEN'
+end
+
+api_instance = Petstore::PetApi.new
+pet_id = 56 # Integer | ID of pet to update
+opts = {
+  additional_metadata: 'additional_metadata_example', # String | Additional data to pass to server
+  file: File.new('/path/to/file') # File | file to upload
+}
+
+begin
+  #uploads an image
+  result = api_instance.upload_file(pet_id, opts)
+  p result
+rescue Petstore::ApiError => e
+  puts "Exception when calling PetApi->upload_file: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **pet_id** | **Integer**| ID of pet to update | 
+ **additional_metadata** | **String**| Additional data to pass to server | [optional] 
+ **file** | **File**| file to upload | [optional] 
+
+### Return type
+
+[**ApiResponse**](ApiResponse.md)
+
+### Authorization
+
+[petstore_auth](../README.md#petstore_auth)
+
+### HTTP request headers
+
+ - **Content-Type**: multipart/form-data
+ - **Accept**: application/json
+
+
+
+# **upload_file_with_required_file**
+> ApiResponse upload_file_with_required_file(pet_id, required_file, opts)
+
+uploads an image (required)
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+# setup authorization
+Petstore.configure do |config|
+  # Configure OAuth2 access token for authorization: petstore_auth
+  config.access_token = 'YOUR ACCESS TOKEN'
+end
+
+api_instance = Petstore::PetApi.new
+pet_id = 56 # Integer | ID of pet to update
+required_file = File.new('/path/to/file') # File | file to upload
+opts = {
+  additional_metadata: 'additional_metadata_example' # String | Additional data to pass to server
+}
+
+begin
+  #uploads an image (required)
+  result = api_instance.upload_file_with_required_file(pet_id, required_file, opts)
+  p result
+rescue Petstore::ApiError => e
+  puts "Exception when calling PetApi->upload_file_with_required_file: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **pet_id** | **Integer**| ID of pet to update | 
+ **required_file** | **File**| file to upload | 
+ **additional_metadata** | **String**| Additional data to pass to server | [optional] 
+
+### Return type
+
+[**ApiResponse**](ApiResponse.md)
+
+### Authorization
+
+[petstore_auth](../README.md#petstore_auth)
+
+### HTTP request headers
+
+ - **Content-Type**: multipart/form-data
+ - **Accept**: application/json
+
+
+

samples/client/petstore/ruby-faraday/docs/ReadOnlyFirst.md

@@ -0,0 +1,9 @@
+# Petstore::ReadOnlyFirst
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**bar** | **String** |  | [optional] 
+**baz** | **String** |  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/SpecialModelName.md

@@ -0,0 +1,8 @@
+# Petstore::SpecialModelName
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**special_property_name** | **Integer** |  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/StoreApi.md

@@ -0,0 +1,192 @@
+# Petstore::StoreApi
+
+All URIs are relative to *http://petstore.swagger.io:80/v2*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**delete_order**](StoreApi.md#delete_order) | **DELETE** /store/order/{order_id} | Delete purchase order by ID
+[**get_inventory**](StoreApi.md#get_inventory) | **GET** /store/inventory | Returns pet inventories by status
+[**get_order_by_id**](StoreApi.md#get_order_by_id) | **GET** /store/order/{order_id} | Find purchase order by ID
+[**place_order**](StoreApi.md#place_order) | **POST** /store/order | Place an order for a pet
+
+
+# **delete_order**
+> delete_order(order_id)
+
+Delete purchase order by ID
+
+For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+
+api_instance = Petstore::StoreApi.new
+order_id = 'order_id_example' # String | ID of the order that needs to be deleted
+
+begin
+  #Delete purchase order by ID
+  api_instance.delete_order(order_id)
+rescue Petstore::ApiError => e
+  puts "Exception when calling StoreApi->delete_order: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **order_id** | **String**| ID of the order that needs to be deleted | 
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: Not defined
+
+
+
+# **get_inventory**
+> Hash&lt;String, Integer&gt; get_inventory
+
+Returns pet inventories by status
+
+Returns a map of status codes to quantities
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+# setup authorization
+Petstore.configure do |config|
+  # Configure API key authorization: api_key
+  config.api_key['api_key'] = 'YOUR API KEY'
+  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
+  #config.api_key_prefix['api_key'] = 'Bearer'
+end
+
+api_instance = Petstore::StoreApi.new
+
+begin
+  #Returns pet inventories by status
+  result = api_instance.get_inventory
+  p result
+rescue Petstore::ApiError => e
+  puts "Exception when calling StoreApi->get_inventory: #{e}"
+end
+```
+
+### Parameters
+This endpoint does not need any parameter.
+
+### Return type
+
+**Hash&lt;String, Integer&gt;**
+
+### Authorization
+
+[api_key](../README.md#api_key)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+
+
+# **get_order_by_id**
+> Order get_order_by_id(order_id)
+
+Find purchase order by ID
+
+For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+
+api_instance = Petstore::StoreApi.new
+order_id = 56 # Integer | ID of pet that needs to be fetched
+
+begin
+  #Find purchase order by ID
+  result = api_instance.get_order_by_id(order_id)
+  p result
+rescue Petstore::ApiError => e
+  puts "Exception when calling StoreApi->get_order_by_id: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **order_id** | **Integer**| ID of pet that needs to be fetched | 
+
+### Return type
+
+[**Order**](Order.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+
+
+# **place_order**
+> Order place_order(order)
+
+Place an order for a pet
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+
+api_instance = Petstore::StoreApi.new
+order = Petstore::Order.new # Order | order placed for purchasing the pet
+
+begin
+  #Place an order for a pet
+  result = api_instance.place_order(order)
+  p result
+rescue Petstore::ApiError => e
+  puts "Exception when calling StoreApi->place_order: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **order** | [**Order**](Order.md)| order placed for purchasing the pet | 
+
+### Return type
+
+[**Order**](Order.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+
+

samples/client/petstore/ruby-faraday/docs/StringBooleanMap.md

@@ -0,0 +1,7 @@
+# Petstore::StringBooleanMap
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+
+

samples/client/petstore/ruby-faraday/docs/Tag.md

@@ -0,0 +1,9 @@
+# Petstore::Tag
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**id** | **Integer** |  | [optional] 
+**name** | **String** |  | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/User.md

@@ -0,0 +1,15 @@
+# Petstore::User
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**id** | **Integer** |  | [optional] 
+**username** | **String** |  | [optional] 
+**first_name** | **String** |  | [optional] 
+**last_name** | **String** |  | [optional] 
+**email** | **String** |  | [optional] 
+**password** | **String** |  | [optional] 
+**phone** | **String** |  | [optional] 
+**user_status** | **Integer** | User Status | [optional] 
+
+

samples/client/petstore/ruby-faraday/docs/UserApi.md

@@ -0,0 +1,360 @@
+# Petstore::UserApi
+
+All URIs are relative to *http://petstore.swagger.io:80/v2*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_user**](UserApi.md#create_user) | **POST** /user | Create user
+[**create_users_with_array_input**](UserApi.md#create_users_with_array_input) | **POST** /user/createWithArray | Creates list of users with given input array
+[**create_users_with_list_input**](UserApi.md#create_users_with_list_input) | **POST** /user/createWithList | Creates list of users with given input array
+[**delete_user**](UserApi.md#delete_user) | **DELETE** /user/{username} | Delete user
+[**get_user_by_name**](UserApi.md#get_user_by_name) | **GET** /user/{username} | Get user by user name
+[**login_user**](UserApi.md#login_user) | **GET** /user/login | Logs user into the system
+[**logout_user**](UserApi.md#logout_user) | **GET** /user/logout | Logs out current logged in user session
+[**update_user**](UserApi.md#update_user) | **PUT** /user/{username} | Updated user
+
+
+# **create_user**
+> create_user(user)
+
+Create user
+
+This can only be done by the logged in user.
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+
+api_instance = Petstore::UserApi.new
+user = Petstore::User.new # User | Created user object
+
+begin
+  #Create user
+  api_instance.create_user(user)
+rescue Petstore::ApiError => e
+  puts "Exception when calling UserApi->create_user: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **user** | [**User**](User.md)| Created user object | 
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: Not defined
+
+
+
+# **create_users_with_array_input**
+> create_users_with_array_input(user)
+
+Creates list of users with given input array
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+
+api_instance = Petstore::UserApi.new
+user = nil # Array<User> | List of user object
+
+begin
+  #Creates list of users with given input array
+  api_instance.create_users_with_array_input(user)
+rescue Petstore::ApiError => e
+  puts "Exception when calling UserApi->create_users_with_array_input: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **user** | [**Array&lt;User&gt;**](Array.md)| List of user object | 
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: Not defined
+
+
+
+# **create_users_with_list_input**
+> create_users_with_list_input(user)
+
+Creates list of users with given input array
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+
+api_instance = Petstore::UserApi.new
+user = nil # Array<User> | List of user object
+
+begin
+  #Creates list of users with given input array
+  api_instance.create_users_with_list_input(user)
+rescue Petstore::ApiError => e
+  puts "Exception when calling UserApi->create_users_with_list_input: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **user** | [**Array&lt;User&gt;**](Array.md)| List of user object | 
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: Not defined
+
+
+
+# **delete_user**
+> delete_user(username)
+
+Delete user
+
+This can only be done by the logged in user.
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+
+api_instance = Petstore::UserApi.new
+username = 'username_example' # String | The name that needs to be deleted
+
+begin
+  #Delete user
+  api_instance.delete_user(username)
+rescue Petstore::ApiError => e
+  puts "Exception when calling UserApi->delete_user: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **username** | **String**| The name that needs to be deleted | 
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: Not defined
+
+
+
+# **get_user_by_name**
+> User get_user_by_name(username)
+
+Get user by user name
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+
+api_instance = Petstore::UserApi.new
+username = 'username_example' # String | The name that needs to be fetched. Use user1 for testing.
+
+begin
+  #Get user by user name
+  result = api_instance.get_user_by_name(username)
+  p result
+rescue Petstore::ApiError => e
+  puts "Exception when calling UserApi->get_user_by_name: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **username** | **String**| The name that needs to be fetched. Use user1 for testing. | 
+
+### Return type
+
+[**User**](User.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+
+
+# **login_user**
+> String login_user(username, password)
+
+Logs user into the system
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+
+api_instance = Petstore::UserApi.new
+username = 'username_example' # String | The user name for login
+password = 'password_example' # String | The password for login in clear text
+
+begin
+  #Logs user into the system
+  result = api_instance.login_user(username, password)
+  p result
+rescue Petstore::ApiError => e
+  puts "Exception when calling UserApi->login_user: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **username** | **String**| The user name for login | 
+ **password** | **String**| The password for login in clear text | 
+
+### Return type
+
+**String**
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+
+
+# **logout_user**
+> logout_user
+
+Logs out current logged in user session
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+
+api_instance = Petstore::UserApi.new
+
+begin
+  #Logs out current logged in user session
+  api_instance.logout_user
+rescue Petstore::ApiError => e
+  puts "Exception when calling UserApi->logout_user: #{e}"
+end
+```
+
+### Parameters
+This endpoint does not need any parameter.
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: Not defined
+
+
+
+# **update_user**
+> update_user(username, user)
+
+Updated user
+
+This can only be done by the logged in user.
+
+### Example
+```ruby
+# load the gem
+require 'petstore'
+
+api_instance = Petstore::UserApi.new
+username = 'username_example' # String | name that need to be deleted
+user = Petstore::User.new # User | Updated user object
+
+begin
+  #Updated user
+  api_instance.update_user(username, user)
+rescue Petstore::ApiError => e
+  puts "Exception when calling UserApi->update_user: #{e}"
+end
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **username** | **String**| name that need to be deleted | 
+ **user** | [**User**](User.md)| Updated user object | 
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: Not defined
+
+
+

samples/client/petstore/ruby-faraday/git_push.sh

@@ -0,0 +1,55 @@
+#!/bin/sh
+#
+# Generated by: https://openapi-generator.tech
+#
+# ref: https://help.github.com/articles/adding-an-existing-project-to-github-using-the-command-line/
+#
+# Usage example: /bin/sh ./git_push.sh wing328 openapi-pestore-perl "minor update"
+
+git_user_id=$1
+git_repo_id=$2
+release_note=$3
+
+if [ "$git_user_id" = "" ]; then
+    git_user_id="GIT_USER_ID"
+    echo "[INFO] No command line input provided. Set \$git_user_id to $git_user_id"
+fi
+
+if [ "$git_repo_id" = "" ]; then
+    git_repo_id="GIT_REPO_ID"
+    echo "[INFO] No command line input provided. Set \$git_repo_id to $git_repo_id"
+fi
+
+if [ "$release_note" = "" ]; then
+    release_note="Minor update"
+    echo "[INFO] No command line input provided. Set \$release_note to $release_note"
+fi
+
+# Initialize the local directory as a Git repository
+git init
+
+# Adds the files in the local repository and stages them for commit.
+git add .
+
+# Commits the tracked changes and prepares them to be pushed to a remote repository.
+git commit -m "$release_note"
+
+# Sets the new remote
+git_remote=`git remote`
+if [ "$git_remote" = "" ]; then # git remote not defined
+
+    if [ "$GIT_TOKEN" = "" ]; then
+        echo "[INFO] \$GIT_TOKEN (environment variable) is not set. Using the git credential in your environment."
+        git remote add origin https://github.com/${git_user_id}/${git_repo_id}.git
+    else
+        git remote add origin https://${git_user_id}:${GIT_TOKEN}@github.com/${git_user_id}/${git_repo_id}.git
+    fi
+
+fi
+
+git pull origin master
+
+# Pushes (Forces) the changes in the local repository up to the remote repository
+echo "Git pushing to https://github.com/${git_user_id}/${git_repo_id}.git"
+git push origin master 2>&1 | grep -v 'To https'
+

samples/client/petstore/ruby-faraday/lib/petstore.rb

@@ -0,0 +1,81 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+# Common files
+require 'petstore/api_client'
+require 'petstore/api_error'
+require 'petstore/version'
+require 'petstore/configuration'
+
+# Models
+require 'petstore/models/additional_properties_class'
+require 'petstore/models/animal'
+require 'petstore/models/animal_farm'
+require 'petstore/models/api_response'
+require 'petstore/models/array_of_array_of_number_only'
+require 'petstore/models/array_of_number_only'
+require 'petstore/models/array_test'
+require 'petstore/models/capitalization'
+require 'petstore/models/cat'
+require 'petstore/models/category'
+require 'petstore/models/class_model'
+require 'petstore/models/client'
+require 'petstore/models/dog'
+require 'petstore/models/enum_arrays'
+require 'petstore/models/enum_class'
+require 'petstore/models/enum_test'
+require 'petstore/models/file'
+require 'petstore/models/file_schema_test_class'
+require 'petstore/models/format_test'
+require 'petstore/models/has_only_read_only'
+require 'petstore/models/list'
+require 'petstore/models/map_test'
+require 'petstore/models/mixed_properties_and_additional_properties_class'
+require 'petstore/models/model200_response'
+require 'petstore/models/model_return'
+require 'petstore/models/name'
+require 'petstore/models/number_only'
+require 'petstore/models/order'
+require 'petstore/models/outer_composite'
+require 'petstore/models/outer_enum'
+require 'petstore/models/pet'
+require 'petstore/models/read_only_first'
+require 'petstore/models/special_model_name'
+require 'petstore/models/string_boolean_map'
+require 'petstore/models/tag'
+require 'petstore/models/user'
+
+# APIs
+require 'petstore/api/another_fake_api'
+require 'petstore/api/fake_api'
+require 'petstore/api/fake_classname_tags123_api'
+require 'petstore/api/pet_api'
+require 'petstore/api/store_api'
+require 'petstore/api/user_api'
+
+module Petstore
+  class << self
+    # Customize default settings for the SDK using block.
+    #   Petstore.configure do |config|
+    #     config.username = "xxx"
+    #     config.password = "xxx"
+    #   end
+    # If no block given, return the default Configuration object.
+    def configure
+      if block_given?
+        yield(Configuration.default)
+      else
+        Configuration.default
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/api/another_fake_api.rb

@@ -0,0 +1,78 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'uri'
+
+module Petstore
+  class AnotherFakeApi
+    attr_accessor :api_client
+
+    def initialize(api_client = ApiClient.default)
+      @api_client = api_client
+    end
+    # To test special tags
+    # To test special tags and operation ID starting with number
+    # @param client client model
+    # @param [Hash] opts the optional parameters
+    # @return [Client]
+    def call_123_test_special_tags(client, opts = {})
+      data, _status_code, _headers = call_123_test_special_tags_with_http_info(client, opts)
+      data
+    end
+
+    # To test special tags
+    # To test special tags and operation ID starting with number
+    # @param client client model
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(Client, Fixnum, Hash)>] Client data, response status code and response headers
+    def call_123_test_special_tags_with_http_info(client, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: AnotherFakeApi.call_123_test_special_tags ...'
+      end
+      # verify the required parameter 'client' is set
+      if @api_client.config.client_side_validation && client.nil?
+        fail ArgumentError, "Missing the required parameter 'client' when calling AnotherFakeApi.call_123_test_special_tags"
+      end
+      # resource path
+      local_var_path = '/another-fake/dummy'
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+      # HTTP header 'Content-Type'
+      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = @api_client.object_to_http_body(client)
+      auth_names = []
+      data, status_code, headers = @api_client.call_api(:PATCH, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => 'Client')
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: AnotherFakeApi#call_123_test_special_tags\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/api/fake_api.rb

@@ -0,0 +1,803 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'uri'
+
+module Petstore
+  class FakeApi
+    attr_accessor :api_client
+
+    def initialize(api_client = ApiClient.default)
+      @api_client = api_client
+    end
+    # Test serialization of outer boolean types
+    # @param [Hash] opts the optional parameters
+    # @option opts [BOOLEAN] :body Input boolean as post body
+    # @return [BOOLEAN]
+    def fake_outer_boolean_serialize(opts = {})
+      data, _status_code, _headers = fake_outer_boolean_serialize_with_http_info(opts)
+      data
+    end
+
+    # Test serialization of outer boolean types
+    # @param [Hash] opts the optional parameters
+    # @option opts [BOOLEAN] :body Input boolean as post body
+    # @return [Array<(BOOLEAN, Fixnum, Hash)>] BOOLEAN data, response status code and response headers
+    def fake_outer_boolean_serialize_with_http_info(opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: FakeApi.fake_outer_boolean_serialize ...'
+      end
+      # resource path
+      local_var_path = '/fake/outer/boolean'
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['*/*'])
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = @api_client.object_to_http_body(opts[:'body'])
+      auth_names = []
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => 'BOOLEAN')
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: FakeApi#fake_outer_boolean_serialize\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Test serialization of object with outer number type
+    # @param [Hash] opts the optional parameters
+    # @option opts [OuterComposite] :outer_composite Input composite as post body
+    # @return [OuterComposite]
+    def fake_outer_composite_serialize(opts = {})
+      data, _status_code, _headers = fake_outer_composite_serialize_with_http_info(opts)
+      data
+    end
+
+    # Test serialization of object with outer number type
+    # @param [Hash] opts the optional parameters
+    # @option opts [OuterComposite] :outer_composite Input composite as post body
+    # @return [Array<(OuterComposite, Fixnum, Hash)>] OuterComposite data, response status code and response headers
+    def fake_outer_composite_serialize_with_http_info(opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: FakeApi.fake_outer_composite_serialize ...'
+      end
+      # resource path
+      local_var_path = '/fake/outer/composite'
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['*/*'])
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = @api_client.object_to_http_body(opts[:'outer_composite'])
+      auth_names = []
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => 'OuterComposite')
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: FakeApi#fake_outer_composite_serialize\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Test serialization of outer number types
+    # @param [Hash] opts the optional parameters
+    # @option opts [Float] :body Input number as post body
+    # @return [Float]
+    def fake_outer_number_serialize(opts = {})
+      data, _status_code, _headers = fake_outer_number_serialize_with_http_info(opts)
+      data
+    end
+
+    # Test serialization of outer number types
+    # @param [Hash] opts the optional parameters
+    # @option opts [Float] :body Input number as post body
+    # @return [Array<(Float, Fixnum, Hash)>] Float data, response status code and response headers
+    def fake_outer_number_serialize_with_http_info(opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: FakeApi.fake_outer_number_serialize ...'
+      end
+      # resource path
+      local_var_path = '/fake/outer/number'
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['*/*'])
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = @api_client.object_to_http_body(opts[:'body'])
+      auth_names = []
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => 'Float')
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: FakeApi#fake_outer_number_serialize\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Test serialization of outer string types
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :body Input string as post body
+    # @return [String]
+    def fake_outer_string_serialize(opts = {})
+      data, _status_code, _headers = fake_outer_string_serialize_with_http_info(opts)
+      data
+    end
+
+    # Test serialization of outer string types
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :body Input string as post body
+    # @return [Array<(String, Fixnum, Hash)>] String data, response status code and response headers
+    def fake_outer_string_serialize_with_http_info(opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: FakeApi.fake_outer_string_serialize ...'
+      end
+      # resource path
+      local_var_path = '/fake/outer/string'
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['*/*'])
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = @api_client.object_to_http_body(opts[:'body'])
+      auth_names = []
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => 'String')
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: FakeApi#fake_outer_string_serialize\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # For this test, the body for this request much reference a schema named `File`.
+    # @param file_schema_test_class 
+    # @param [Hash] opts the optional parameters
+    # @return [nil]
+    def test_body_with_file_schema(file_schema_test_class, opts = {})
+      test_body_with_file_schema_with_http_info(file_schema_test_class, opts)
+      nil
+    end
+
+    # For this test, the body for this request much reference a schema named &#x60;File&#x60;.
+    # @param file_schema_test_class 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
+    def test_body_with_file_schema_with_http_info(file_schema_test_class, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: FakeApi.test_body_with_file_schema ...'
+      end
+      # verify the required parameter 'file_schema_test_class' is set
+      if @api_client.config.client_side_validation && file_schema_test_class.nil?
+        fail ArgumentError, "Missing the required parameter 'file_schema_test_class' when calling FakeApi.test_body_with_file_schema"
+      end
+      # resource path
+      local_var_path = '/fake/body-with-file-schema'
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Content-Type'
+      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = @api_client.object_to_http_body(file_schema_test_class)
+      auth_names = []
+      data, status_code, headers = @api_client.call_api(:PUT, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: FakeApi#test_body_with_file_schema\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # @param query 
+    # @param user 
+    # @param [Hash] opts the optional parameters
+    # @return [nil]
+    def test_body_with_query_params(query, user, opts = {})
+      test_body_with_query_params_with_http_info(query, user, opts)
+      nil
+    end
+
+    # @param query 
+    # @param user 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
+    def test_body_with_query_params_with_http_info(query, user, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: FakeApi.test_body_with_query_params ...'
+      end
+      # verify the required parameter 'query' is set
+      if @api_client.config.client_side_validation && query.nil?
+        fail ArgumentError, "Missing the required parameter 'query' when calling FakeApi.test_body_with_query_params"
+      end
+      # verify the required parameter 'user' is set
+      if @api_client.config.client_side_validation && user.nil?
+        fail ArgumentError, "Missing the required parameter 'user' when calling FakeApi.test_body_with_query_params"
+      end
+      # resource path
+      local_var_path = '/fake/body-with-query-params'
+
+      # query parameters
+      query_params = {}
+      query_params[:'query'] = query
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Content-Type'
+      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = @api_client.object_to_http_body(user)
+      auth_names = []
+      data, status_code, headers = @api_client.call_api(:PUT, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: FakeApi#test_body_with_query_params\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # To test \"client\" model
+    # To test \"client\" model
+    # @param client client model
+    # @param [Hash] opts the optional parameters
+    # @return [Client]
+    def test_client_model(client, opts = {})
+      data, _status_code, _headers = test_client_model_with_http_info(client, opts)
+      data
+    end
+
+    # To test \&quot;client\&quot; model
+    # To test \&quot;client\&quot; model
+    # @param client client model
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(Client, Fixnum, Hash)>] Client data, response status code and response headers
+    def test_client_model_with_http_info(client, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: FakeApi.test_client_model ...'
+      end
+      # verify the required parameter 'client' is set
+      if @api_client.config.client_side_validation && client.nil?
+        fail ArgumentError, "Missing the required parameter 'client' when calling FakeApi.test_client_model"
+      end
+      # resource path
+      local_var_path = '/fake'
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+      # HTTP header 'Content-Type'
+      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = @api_client.object_to_http_body(client)
+      auth_names = []
+      data, status_code, headers = @api_client.call_api(:PATCH, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => 'Client')
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: FakeApi#test_client_model\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
+    # Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
+    # @param number None
+    # @param double None
+    # @param pattern_without_delimiter None
+    # @param byte None
+    # @param [Hash] opts the optional parameters
+    # @option opts [Integer] :integer None
+    # @option opts [Integer] :int32 None
+    # @option opts [Integer] :int64 None
+    # @option opts [Float] :float None
+    # @option opts [String] :string None
+    # @option opts [File] :binary None
+    # @option opts [Date] :date None
+    # @option opts [DateTime] :date_time None
+    # @option opts [String] :password None
+    # @option opts [String] :callback None
+    # @return [nil]
+    def test_endpoint_parameters(number, double, pattern_without_delimiter, byte, opts = {})
+      test_endpoint_parameters_with_http_info(number, double, pattern_without_delimiter, byte, opts)
+      nil
+    end
+
+    # Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
+    # Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
+    # @param number None
+    # @param double None
+    # @param pattern_without_delimiter None
+    # @param byte None
+    # @param [Hash] opts the optional parameters
+    # @option opts [Integer] :integer None
+    # @option opts [Integer] :int32 None
+    # @option opts [Integer] :int64 None
+    # @option opts [Float] :float None
+    # @option opts [String] :string None
+    # @option opts [File] :binary None
+    # @option opts [Date] :date None
+    # @option opts [DateTime] :date_time None
+    # @option opts [String] :password None
+    # @option opts [String] :callback None
+    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
+    def test_endpoint_parameters_with_http_info(number, double, pattern_without_delimiter, byte, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: FakeApi.test_endpoint_parameters ...'
+      end
+      # verify the required parameter 'number' is set
+      if @api_client.config.client_side_validation && number.nil?
+        fail ArgumentError, "Missing the required parameter 'number' when calling FakeApi.test_endpoint_parameters"
+      end
+      if @api_client.config.client_side_validation && number > 543.2
+        fail ArgumentError, 'invalid value for "number" when calling FakeApi.test_endpoint_parameters, must be smaller than or equal to 543.2.'
+      end
+
+      if @api_client.config.client_side_validation && number < 32.1
+        fail ArgumentError, 'invalid value for "number" when calling FakeApi.test_endpoint_parameters, must be greater than or equal to 32.1.'
+      end
+
+      # verify the required parameter 'double' is set
+      if @api_client.config.client_side_validation && double.nil?
+        fail ArgumentError, "Missing the required parameter 'double' when calling FakeApi.test_endpoint_parameters"
+      end
+      if @api_client.config.client_side_validation && double > 123.4
+        fail ArgumentError, 'invalid value for "double" when calling FakeApi.test_endpoint_parameters, must be smaller than or equal to 123.4.'
+      end
+
+      if @api_client.config.client_side_validation && double < 67.8
+        fail ArgumentError, 'invalid value for "double" when calling FakeApi.test_endpoint_parameters, must be greater than or equal to 67.8.'
+      end
+
+      # verify the required parameter 'pattern_without_delimiter' is set
+      if @api_client.config.client_side_validation && pattern_without_delimiter.nil?
+        fail ArgumentError, "Missing the required parameter 'pattern_without_delimiter' when calling FakeApi.test_endpoint_parameters"
+      end
+      if @api_client.config.client_side_validation && pattern_without_delimiter !~ Regexp.new(/^[A-Z].*/)
+        fail ArgumentError, "invalid value for 'pattern_without_delimiter' when calling FakeApi.test_endpoint_parameters, must conform to the pattern /^[A-Z].*/."
+      end
+
+      # verify the required parameter 'byte' is set
+      if @api_client.config.client_side_validation && byte.nil?
+        fail ArgumentError, "Missing the required parameter 'byte' when calling FakeApi.test_endpoint_parameters"
+      end
+      if @api_client.config.client_side_validation && !opts[:'integer'].nil? && opts[:'integer'] > 100
+        fail ArgumentError, 'invalid value for "opts[:"integer"]" when calling FakeApi.test_endpoint_parameters, must be smaller than or equal to 100.'
+      end
+
+      if @api_client.config.client_side_validation && !opts[:'integer'].nil? && opts[:'integer'] < 10
+        fail ArgumentError, 'invalid value for "opts[:"integer"]" when calling FakeApi.test_endpoint_parameters, must be greater than or equal to 10.'
+      end
+
+      if @api_client.config.client_side_validation && !opts[:'int32'].nil? && opts[:'int32'] > 200
+        fail ArgumentError, 'invalid value for "opts[:"int32"]" when calling FakeApi.test_endpoint_parameters, must be smaller than or equal to 200.'
+      end
+
+      if @api_client.config.client_side_validation && !opts[:'int32'].nil? && opts[:'int32'] < 20
+        fail ArgumentError, 'invalid value for "opts[:"int32"]" when calling FakeApi.test_endpoint_parameters, must be greater than or equal to 20.'
+      end
+
+      if @api_client.config.client_side_validation && !opts[:'float'].nil? && opts[:'float'] > 987.6
+        fail ArgumentError, 'invalid value for "opts[:"float"]" when calling FakeApi.test_endpoint_parameters, must be smaller than or equal to 987.6.'
+      end
+
+      if @api_client.config.client_side_validation && !opts[:'string'].nil? && opts[:'string'] !~ Regexp.new(/[a-z]/i)
+        fail ArgumentError, "invalid value for 'opts[:\"string\"]' when calling FakeApi.test_endpoint_parameters, must conform to the pattern /[a-z]/i."
+      end
+
+      if @api_client.config.client_side_validation && !opts[:'password'].nil? && opts[:'password'].to_s.length > 64
+        fail ArgumentError, 'invalid value for "opts[:"password"]" when calling FakeApi.test_endpoint_parameters, the character length must be smaller than or equal to 64.'
+      end
+
+      if @api_client.config.client_side_validation && !opts[:'password'].nil? && opts[:'password'].to_s.length < 10
+        fail ArgumentError, 'invalid value for "opts[:"password"]" when calling FakeApi.test_endpoint_parameters, the character length must be great than or equal to 10.'
+      end
+
+      # resource path
+      local_var_path = '/fake'
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Content-Type'
+      header_params['Content-Type'] = @api_client.select_header_content_type(['application/x-www-form-urlencoded'])
+
+      # form parameters
+      form_params = {}
+      form_params['number'] = number
+      form_params['double'] = double
+      form_params['pattern_without_delimiter'] = pattern_without_delimiter
+      form_params['byte'] = byte
+      form_params['integer'] = opts[:'integer'] if !opts[:'integer'].nil?
+      form_params['int32'] = opts[:'int32'] if !opts[:'int32'].nil?
+      form_params['int64'] = opts[:'int64'] if !opts[:'int64'].nil?
+      form_params['float'] = opts[:'float'] if !opts[:'float'].nil?
+      form_params['string'] = opts[:'string'] if !opts[:'string'].nil?
+      form_params['binary'] = opts[:'binary'] if !opts[:'binary'].nil?
+      form_params['date'] = opts[:'date'] if !opts[:'date'].nil?
+      form_params['dateTime'] = opts[:'date_time'] if !opts[:'date_time'].nil?
+      form_params['password'] = opts[:'password'] if !opts[:'password'].nil?
+      form_params['callback'] = opts[:'callback'] if !opts[:'callback'].nil?
+
+      # http body (model)
+      post_body = nil
+      auth_names = ['http_basic_test']
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: FakeApi#test_endpoint_parameters\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # To test enum parameters
+    # To test enum parameters
+    # @param [Hash] opts the optional parameters
+    # @option opts [Array<String>] :enum_header_string_array Header parameter enum test (string array)
+    # @option opts [String] :enum_header_string Header parameter enum test (string) (default to '-efg')
+    # @option opts [Array<String>] :enum_query_string_array Query parameter enum test (string array)
+    # @option opts [String] :enum_query_string Query parameter enum test (string) (default to '-efg')
+    # @option opts [Integer] :enum_query_integer Query parameter enum test (double)
+    # @option opts [Float] :enum_query_double Query parameter enum test (double)
+    # @option opts [Array<String>] :enum_form_string_array Form parameter enum test (string array) (default to '$')
+    # @option opts [String] :enum_form_string Form parameter enum test (string) (default to '-efg')
+    # @return [nil]
+    def test_enum_parameters(opts = {})
+      test_enum_parameters_with_http_info(opts)
+      nil
+    end
+
+    # To test enum parameters
+    # To test enum parameters
+    # @param [Hash] opts the optional parameters
+    # @option opts [Array<String>] :enum_header_string_array Header parameter enum test (string array)
+    # @option opts [String] :enum_header_string Header parameter enum test (string)
+    # @option opts [Array<String>] :enum_query_string_array Query parameter enum test (string array)
+    # @option opts [String] :enum_query_string Query parameter enum test (string)
+    # @option opts [Integer] :enum_query_integer Query parameter enum test (double)
+    # @option opts [Float] :enum_query_double Query parameter enum test (double)
+    # @option opts [Array<String>] :enum_form_string_array Form parameter enum test (string array)
+    # @option opts [String] :enum_form_string Form parameter enum test (string)
+    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
+    def test_enum_parameters_with_http_info(opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: FakeApi.test_enum_parameters ...'
+      end
+      if @api_client.config.client_side_validation && opts[:'enum_header_string_array'] && !opts[:'enum_header_string_array'].all? { |item| ['>', '$'].include?(item) }
+        fail ArgumentError, 'invalid value for "enum_header_string_array", must include one of >, $'
+      end
+      if @api_client.config.client_side_validation && opts[:'enum_header_string'] && !['_abc', '-efg', '(xyz)'].include?(opts[:'enum_header_string'])
+        fail ArgumentError, 'invalid value for "enum_header_string", must be one of _abc, -efg, (xyz)'
+      end
+      if @api_client.config.client_side_validation && opts[:'enum_query_string_array'] && !opts[:'enum_query_string_array'].all? { |item| ['>', '$'].include?(item) }
+        fail ArgumentError, 'invalid value for "enum_query_string_array", must include one of >, $'
+      end
+      if @api_client.config.client_side_validation && opts[:'enum_query_string'] && !['_abc', '-efg', '(xyz)'].include?(opts[:'enum_query_string'])
+        fail ArgumentError, 'invalid value for "enum_query_string", must be one of _abc, -efg, (xyz)'
+      end
+      if @api_client.config.client_side_validation && opts[:'enum_query_integer'] && !['1', '-2'].include?(opts[:'enum_query_integer'])
+        fail ArgumentError, 'invalid value for "enum_query_integer", must be one of 1, -2'
+      end
+      if @api_client.config.client_side_validation && opts[:'enum_query_double'] && !['1.1', '-1.2'].include?(opts[:'enum_query_double'])
+        fail ArgumentError, 'invalid value for "enum_query_double", must be one of 1.1, -1.2'
+      end
+      if @api_client.config.client_side_validation && opts[:'enum_form_string_array'] && !opts[:'enum_form_string_array'].all? { |item| ['>', '$'].include?(item) }
+        fail ArgumentError, 'invalid value for "enum_form_string_array", must include one of >, $'
+      end
+      if @api_client.config.client_side_validation && opts[:'enum_form_string'] && !['_abc', '-efg', '(xyz)'].include?(opts[:'enum_form_string'])
+        fail ArgumentError, 'invalid value for "enum_form_string", must be one of _abc, -efg, (xyz)'
+      end
+      # resource path
+      local_var_path = '/fake'
+
+      # query parameters
+      query_params = {}
+      query_params[:'enum_query_string_array'] = @api_client.build_collection_param(opts[:'enum_query_string_array'], :csv) if !opts[:'enum_query_string_array'].nil?
+      query_params[:'enum_query_string'] = opts[:'enum_query_string'] if !opts[:'enum_query_string'].nil?
+      query_params[:'enum_query_integer'] = opts[:'enum_query_integer'] if !opts[:'enum_query_integer'].nil?
+      query_params[:'enum_query_double'] = opts[:'enum_query_double'] if !opts[:'enum_query_double'].nil?
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Content-Type'
+      header_params['Content-Type'] = @api_client.select_header_content_type(['application/x-www-form-urlencoded'])
+      header_params[:'enum_header_string_array'] = @api_client.build_collection_param(opts[:'enum_header_string_array'], :csv) if !opts[:'enum_header_string_array'].nil?
+      header_params[:'enum_header_string'] = opts[:'enum_header_string'] if !opts[:'enum_header_string'].nil?
+
+      # form parameters
+      form_params = {}
+      form_params['enum_form_string_array'] = @api_client.build_collection_param(opts[:'enum_form_string_array'], :csv) if !opts[:'enum_form_string_array'].nil?
+      form_params['enum_form_string'] = opts[:'enum_form_string'] if !opts[:'enum_form_string'].nil?
+
+      # http body (model)
+      post_body = nil
+      auth_names = []
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: FakeApi#test_enum_parameters\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Fake endpoint to test group parameters (optional)
+    # Fake endpoint to test group parameters (optional)
+    # @param required_string_group Required String in group parameters
+    # @param required_boolean_group Required Boolean in group parameters
+    # @param required_int64_group Required Integer in group parameters
+    # @param [Hash] opts the optional parameters
+    # @option opts [Integer] :string_group String in group parameters
+    # @option opts [BOOLEAN] :boolean_group Boolean in group parameters
+    # @option opts [Integer] :int64_group Integer in group parameters
+    # @return [nil]
+    def test_group_parameters(required_string_group, required_boolean_group, required_int64_group, opts = {})
+      test_group_parameters_with_http_info(required_string_group, required_boolean_group, required_int64_group, opts)
+      nil
+    end
+
+    # Fake endpoint to test group parameters (optional)
+    # Fake endpoint to test group parameters (optional)
+    # @param required_string_group Required String in group parameters
+    # @param required_boolean_group Required Boolean in group parameters
+    # @param required_int64_group Required Integer in group parameters
+    # @param [Hash] opts the optional parameters
+    # @option opts [Integer] :string_group String in group parameters
+    # @option opts [BOOLEAN] :boolean_group Boolean in group parameters
+    # @option opts [Integer] :int64_group Integer in group parameters
+    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
+    def test_group_parameters_with_http_info(required_string_group, required_boolean_group, required_int64_group, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: FakeApi.test_group_parameters ...'
+      end
+      # verify the required parameter 'required_string_group' is set
+      if @api_client.config.client_side_validation && required_string_group.nil?
+        fail ArgumentError, "Missing the required parameter 'required_string_group' when calling FakeApi.test_group_parameters"
+      end
+      # verify the required parameter 'required_boolean_group' is set
+      if @api_client.config.client_side_validation && required_boolean_group.nil?
+        fail ArgumentError, "Missing the required parameter 'required_boolean_group' when calling FakeApi.test_group_parameters"
+      end
+      # verify the required parameter 'required_int64_group' is set
+      if @api_client.config.client_side_validation && required_int64_group.nil?
+        fail ArgumentError, "Missing the required parameter 'required_int64_group' when calling FakeApi.test_group_parameters"
+      end
+      # resource path
+      local_var_path = '/fake'
+
+      # query parameters
+      query_params = {}
+      query_params[:'required_string_group'] = required_string_group
+      query_params[:'required_int64_group'] = required_int64_group
+      query_params[:'string_group'] = opts[:'string_group'] if !opts[:'string_group'].nil?
+      query_params[:'int64_group'] = opts[:'int64_group'] if !opts[:'int64_group'].nil?
+
+      # header parameters
+      header_params = {}
+      header_params[:'required_boolean_group'] = required_boolean_group
+      header_params[:'boolean_group'] = opts[:'boolean_group'] if !opts[:'boolean_group'].nil?
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = nil
+      auth_names = []
+      data, status_code, headers = @api_client.call_api(:DELETE, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: FakeApi#test_group_parameters\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # test inline additionalProperties
+    # @param request_body request body
+    # @param [Hash] opts the optional parameters
+    # @return [nil]
+    def test_inline_additional_properties(request_body, opts = {})
+      test_inline_additional_properties_with_http_info(request_body, opts)
+      nil
+    end
+
+    # test inline additionalProperties
+    # @param request_body request body
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
+    def test_inline_additional_properties_with_http_info(request_body, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: FakeApi.test_inline_additional_properties ...'
+      end
+      # verify the required parameter 'request_body' is set
+      if @api_client.config.client_side_validation && request_body.nil?
+        fail ArgumentError, "Missing the required parameter 'request_body' when calling FakeApi.test_inline_additional_properties"
+      end
+      # resource path
+      local_var_path = '/fake/inline-additionalProperties'
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Content-Type'
+      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = @api_client.object_to_http_body(request_body)
+      auth_names = []
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: FakeApi#test_inline_additional_properties\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # test json serialization of form data
+    # @param param field1
+    # @param param2 field2
+    # @param [Hash] opts the optional parameters
+    # @return [nil]
+    def test_json_form_data(param, param2, opts = {})
+      test_json_form_data_with_http_info(param, param2, opts)
+      nil
+    end
+
+    # test json serialization of form data
+    # @param param field1
+    # @param param2 field2
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
+    def test_json_form_data_with_http_info(param, param2, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: FakeApi.test_json_form_data ...'
+      end
+      # verify the required parameter 'param' is set
+      if @api_client.config.client_side_validation && param.nil?
+        fail ArgumentError, "Missing the required parameter 'param' when calling FakeApi.test_json_form_data"
+      end
+      # verify the required parameter 'param2' is set
+      if @api_client.config.client_side_validation && param2.nil?
+        fail ArgumentError, "Missing the required parameter 'param2' when calling FakeApi.test_json_form_data"
+      end
+      # resource path
+      local_var_path = '/fake/jsonFormData'
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Content-Type'
+      header_params['Content-Type'] = @api_client.select_header_content_type(['application/x-www-form-urlencoded'])
+
+      # form parameters
+      form_params = {}
+      form_params['param'] = param
+      form_params['param2'] = param2
+
+      # http body (model)
+      post_body = nil
+      auth_names = []
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: FakeApi#test_json_form_data\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/api/fake_classname_tags123_api.rb

@@ -0,0 +1,78 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'uri'
+
+module Petstore
+  class FakeClassnameTags123Api
+    attr_accessor :api_client
+
+    def initialize(api_client = ApiClient.default)
+      @api_client = api_client
+    end
+    # To test class name in snake case
+    # To test class name in snake case
+    # @param client client model
+    # @param [Hash] opts the optional parameters
+    # @return [Client]
+    def test_classname(client, opts = {})
+      data, _status_code, _headers = test_classname_with_http_info(client, opts)
+      data
+    end
+
+    # To test class name in snake case
+    # To test class name in snake case
+    # @param client client model
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(Client, Fixnum, Hash)>] Client data, response status code and response headers
+    def test_classname_with_http_info(client, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: FakeClassnameTags123Api.test_classname ...'
+      end
+      # verify the required parameter 'client' is set
+      if @api_client.config.client_side_validation && client.nil?
+        fail ArgumentError, "Missing the required parameter 'client' when calling FakeClassnameTags123Api.test_classname"
+      end
+      # resource path
+      local_var_path = '/fake_classname_test'
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+      # HTTP header 'Content-Type'
+      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = @api_client.object_to_http_body(client)
+      auth_names = ['api_key_query']
+      data, status_code, headers = @api_client.call_api(:PATCH, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => 'Client')
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: FakeClassnameTags123Api#test_classname\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/api/pet_api.rb

@@ -0,0 +1,513 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'uri'
+
+module Petstore
+  class PetApi
+    attr_accessor :api_client
+
+    def initialize(api_client = ApiClient.default)
+      @api_client = api_client
+    end
+    # Add a new pet to the store
+    # @param pet Pet object that needs to be added to the store
+    # @param [Hash] opts the optional parameters
+    # @return [nil]
+    def add_pet(pet, opts = {})
+      add_pet_with_http_info(pet, opts)
+      nil
+    end
+
+    # Add a new pet to the store
+    # @param pet Pet object that needs to be added to the store
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
+    def add_pet_with_http_info(pet, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: PetApi.add_pet ...'
+      end
+      # verify the required parameter 'pet' is set
+      if @api_client.config.client_side_validation && pet.nil?
+        fail ArgumentError, "Missing the required parameter 'pet' when calling PetApi.add_pet"
+      end
+      # resource path
+      local_var_path = '/pet'
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Content-Type'
+      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json', 'application/xml'])
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = @api_client.object_to_http_body(pet)
+      auth_names = ['petstore_auth']
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: PetApi#add_pet\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Deletes a pet
+    # @param pet_id Pet id to delete
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :api_key 
+    # @return [nil]
+    def delete_pet(pet_id, opts = {})
+      delete_pet_with_http_info(pet_id, opts)
+      nil
+    end
+
+    # Deletes a pet
+    # @param pet_id Pet id to delete
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :api_key 
+    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
+    def delete_pet_with_http_info(pet_id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: PetApi.delete_pet ...'
+      end
+      # verify the required parameter 'pet_id' is set
+      if @api_client.config.client_side_validation && pet_id.nil?
+        fail ArgumentError, "Missing the required parameter 'pet_id' when calling PetApi.delete_pet"
+      end
+      # resource path
+      local_var_path = '/pet/{petId}'.sub('{' + 'petId' + '}', pet_id.to_s)
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+      header_params[:'api_key'] = opts[:'api_key'] if !opts[:'api_key'].nil?
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = nil
+      auth_names = ['petstore_auth']
+      data, status_code, headers = @api_client.call_api(:DELETE, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: PetApi#delete_pet\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Finds Pets by status
+    # Multiple status values can be provided with comma separated strings
+    # @param status Status values that need to be considered for filter
+    # @param [Hash] opts the optional parameters
+    # @return [Array<Pet>]
+    def find_pets_by_status(status, opts = {})
+      data, _status_code, _headers = find_pets_by_status_with_http_info(status, opts)
+      data
+    end
+
+    # Finds Pets by status
+    # Multiple status values can be provided with comma separated strings
+    # @param status Status values that need to be considered for filter
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(Array<Pet>, Fixnum, Hash)>] Array<Pet> data, response status code and response headers
+    def find_pets_by_status_with_http_info(status, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: PetApi.find_pets_by_status ...'
+      end
+      # verify the required parameter 'status' is set
+      if @api_client.config.client_side_validation && status.nil?
+        fail ArgumentError, "Missing the required parameter 'status' when calling PetApi.find_pets_by_status"
+      end
+      # resource path
+      local_var_path = '/pet/findByStatus'
+
+      # query parameters
+      query_params = {}
+      query_params[:'status'] = @api_client.build_collection_param(status, :csv)
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/xml', 'application/json'])
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = nil
+      auth_names = ['petstore_auth']
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => 'Array<Pet>')
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: PetApi#find_pets_by_status\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Finds Pets by tags
+    # Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+    # @param tags Tags to filter by
+    # @param [Hash] opts the optional parameters
+    # @return [Array<Pet>]
+    def find_pets_by_tags(tags, opts = {})
+      data, _status_code, _headers = find_pets_by_tags_with_http_info(tags, opts)
+      data
+    end
+
+    # Finds Pets by tags
+    # Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+    # @param tags Tags to filter by
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(Array<Pet>, Fixnum, Hash)>] Array<Pet> data, response status code and response headers
+    def find_pets_by_tags_with_http_info(tags, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: PetApi.find_pets_by_tags ...'
+      end
+      # verify the required parameter 'tags' is set
+      if @api_client.config.client_side_validation && tags.nil?
+        fail ArgumentError, "Missing the required parameter 'tags' when calling PetApi.find_pets_by_tags"
+      end
+      # resource path
+      local_var_path = '/pet/findByTags'
+
+      # query parameters
+      query_params = {}
+      query_params[:'tags'] = @api_client.build_collection_param(tags, :csv)
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/xml', 'application/json'])
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = nil
+      auth_names = ['petstore_auth']
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => 'Array<Pet>')
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: PetApi#find_pets_by_tags\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Find pet by ID
+    # Returns a single pet
+    # @param pet_id ID of pet to return
+    # @param [Hash] opts the optional parameters
+    # @return [Pet]
+    def get_pet_by_id(pet_id, opts = {})
+      data, _status_code, _headers = get_pet_by_id_with_http_info(pet_id, opts)
+      data
+    end
+
+    # Find pet by ID
+    # Returns a single pet
+    # @param pet_id ID of pet to return
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(Pet, Fixnum, Hash)>] Pet data, response status code and response headers
+    def get_pet_by_id_with_http_info(pet_id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: PetApi.get_pet_by_id ...'
+      end
+      # verify the required parameter 'pet_id' is set
+      if @api_client.config.client_side_validation && pet_id.nil?
+        fail ArgumentError, "Missing the required parameter 'pet_id' when calling PetApi.get_pet_by_id"
+      end
+      # resource path
+      local_var_path = '/pet/{petId}'.sub('{' + 'petId' + '}', pet_id.to_s)
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/xml', 'application/json'])
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = nil
+      auth_names = ['api_key']
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => 'Pet')
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: PetApi#get_pet_by_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Update an existing pet
+    # @param pet Pet object that needs to be added to the store
+    # @param [Hash] opts the optional parameters
+    # @return [nil]
+    def update_pet(pet, opts = {})
+      update_pet_with_http_info(pet, opts)
+      nil
+    end
+
+    # Update an existing pet
+    # @param pet Pet object that needs to be added to the store
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
+    def update_pet_with_http_info(pet, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: PetApi.update_pet ...'
+      end
+      # verify the required parameter 'pet' is set
+      if @api_client.config.client_side_validation && pet.nil?
+        fail ArgumentError, "Missing the required parameter 'pet' when calling PetApi.update_pet"
+      end
+      # resource path
+      local_var_path = '/pet'
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Content-Type'
+      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json', 'application/xml'])
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = @api_client.object_to_http_body(pet)
+      auth_names = ['petstore_auth']
+      data, status_code, headers = @api_client.call_api(:PUT, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: PetApi#update_pet\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Updates a pet in the store with form data
+    # @param pet_id ID of pet that needs to be updated
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :name Updated name of the pet
+    # @option opts [String] :status Updated status of the pet
+    # @return [nil]
+    def update_pet_with_form(pet_id, opts = {})
+      update_pet_with_form_with_http_info(pet_id, opts)
+      nil
+    end
+
+    # Updates a pet in the store with form data
+    # @param pet_id ID of pet that needs to be updated
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :name Updated name of the pet
+    # @option opts [String] :status Updated status of the pet
+    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
+    def update_pet_with_form_with_http_info(pet_id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: PetApi.update_pet_with_form ...'
+      end
+      # verify the required parameter 'pet_id' is set
+      if @api_client.config.client_side_validation && pet_id.nil?
+        fail ArgumentError, "Missing the required parameter 'pet_id' when calling PetApi.update_pet_with_form"
+      end
+      # resource path
+      local_var_path = '/pet/{petId}'.sub('{' + 'petId' + '}', pet_id.to_s)
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Content-Type'
+      header_params['Content-Type'] = @api_client.select_header_content_type(['application/x-www-form-urlencoded'])
+
+      # form parameters
+      form_params = {}
+      form_params['name'] = opts[:'name'] if !opts[:'name'].nil?
+      form_params['status'] = opts[:'status'] if !opts[:'status'].nil?
+
+      # http body (model)
+      post_body = nil
+      auth_names = ['petstore_auth']
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: PetApi#update_pet_with_form\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # uploads an image
+    # @param pet_id ID of pet to update
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :additional_metadata Additional data to pass to server
+    # @option opts [File] :file file to upload
+    # @return [ApiResponse]
+    def upload_file(pet_id, opts = {})
+      data, _status_code, _headers = upload_file_with_http_info(pet_id, opts)
+      data
+    end
+
+    # uploads an image
+    # @param pet_id ID of pet to update
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :additional_metadata Additional data to pass to server
+    # @option opts [File] :file file to upload
+    # @return [Array<(ApiResponse, Fixnum, Hash)>] ApiResponse data, response status code and response headers
+    def upload_file_with_http_info(pet_id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: PetApi.upload_file ...'
+      end
+      # verify the required parameter 'pet_id' is set
+      if @api_client.config.client_side_validation && pet_id.nil?
+        fail ArgumentError, "Missing the required parameter 'pet_id' when calling PetApi.upload_file"
+      end
+      # resource path
+      local_var_path = '/pet/{petId}/uploadImage'.sub('{' + 'petId' + '}', pet_id.to_s)
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+      # HTTP header 'Content-Type'
+      header_params['Content-Type'] = @api_client.select_header_content_type(['multipart/form-data'])
+
+      # form parameters
+      form_params = {}
+      form_params['additionalMetadata'] = opts[:'additional_metadata'] if !opts[:'additional_metadata'].nil?
+      form_params['file'] = opts[:'file'] if !opts[:'file'].nil?
+
+      # http body (model)
+      post_body = nil
+      auth_names = ['petstore_auth']
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => 'ApiResponse')
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: PetApi#upload_file\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # uploads an image (required)
+    # @param pet_id ID of pet to update
+    # @param required_file file to upload
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :additional_metadata Additional data to pass to server
+    # @return [ApiResponse]
+    def upload_file_with_required_file(pet_id, required_file, opts = {})
+      data, _status_code, _headers = upload_file_with_required_file_with_http_info(pet_id, required_file, opts)
+      data
+    end
+
+    # uploads an image (required)
+    # @param pet_id ID of pet to update
+    # @param required_file file to upload
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :additional_metadata Additional data to pass to server
+    # @return [Array<(ApiResponse, Fixnum, Hash)>] ApiResponse data, response status code and response headers
+    def upload_file_with_required_file_with_http_info(pet_id, required_file, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: PetApi.upload_file_with_required_file ...'
+      end
+      # verify the required parameter 'pet_id' is set
+      if @api_client.config.client_side_validation && pet_id.nil?
+        fail ArgumentError, "Missing the required parameter 'pet_id' when calling PetApi.upload_file_with_required_file"
+      end
+      # verify the required parameter 'required_file' is set
+      if @api_client.config.client_side_validation && required_file.nil?
+        fail ArgumentError, "Missing the required parameter 'required_file' when calling PetApi.upload_file_with_required_file"
+      end
+      # resource path
+      local_var_path = '/fake/{petId}/uploadImageWithRequiredFile'.sub('{' + 'petId' + '}', pet_id.to_s)
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+      # HTTP header 'Content-Type'
+      header_params['Content-Type'] = @api_client.select_header_content_type(['multipart/form-data'])
+
+      # form parameters
+      form_params = {}
+      form_params['requiredFile'] = required_file
+      form_params['additionalMetadata'] = opts[:'additional_metadata'] if !opts[:'additional_metadata'].nil?
+
+      # http body (model)
+      post_body = nil
+      auth_names = ['petstore_auth']
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => 'ApiResponse')
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: PetApi#upload_file_with_required_file\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/api/store_api.rb

@@ -0,0 +1,232 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'uri'
+
+module Petstore
+  class StoreApi
+    attr_accessor :api_client
+
+    def initialize(api_client = ApiClient.default)
+      @api_client = api_client
+    end
+    # Delete purchase order by ID
+    # For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
+    # @param order_id ID of the order that needs to be deleted
+    # @param [Hash] opts the optional parameters
+    # @return [nil]
+    def delete_order(order_id, opts = {})
+      delete_order_with_http_info(order_id, opts)
+      nil
+    end
+
+    # Delete purchase order by ID
+    # For valid response try integer IDs with value &lt; 1000. Anything above 1000 or nonintegers will generate API errors
+    # @param order_id ID of the order that needs to be deleted
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
+    def delete_order_with_http_info(order_id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: StoreApi.delete_order ...'
+      end
+      # verify the required parameter 'order_id' is set
+      if @api_client.config.client_side_validation && order_id.nil?
+        fail ArgumentError, "Missing the required parameter 'order_id' when calling StoreApi.delete_order"
+      end
+      # resource path
+      local_var_path = '/store/order/{order_id}'.sub('{' + 'order_id' + '}', order_id.to_s)
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = nil
+      auth_names = []
+      data, status_code, headers = @api_client.call_api(:DELETE, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: StoreApi#delete_order\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Returns pet inventories by status
+    # Returns a map of status codes to quantities
+    # @param [Hash] opts the optional parameters
+    # @return [Hash<String, Integer>]
+    def get_inventory(opts = {})
+      data, _status_code, _headers = get_inventory_with_http_info(opts)
+      data
+    end
+
+    # Returns pet inventories by status
+    # Returns a map of status codes to quantities
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(Hash<String, Integer>, Fixnum, Hash)>] Hash<String, Integer> data, response status code and response headers
+    def get_inventory_with_http_info(opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: StoreApi.get_inventory ...'
+      end
+      # resource path
+      local_var_path = '/store/inventory'
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = nil
+      auth_names = ['api_key']
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => 'Hash<String, Integer>')
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: StoreApi#get_inventory\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Find purchase order by ID
+    # For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions
+    # @param order_id ID of pet that needs to be fetched
+    # @param [Hash] opts the optional parameters
+    # @return [Order]
+    def get_order_by_id(order_id, opts = {})
+      data, _status_code, _headers = get_order_by_id_with_http_info(order_id, opts)
+      data
+    end
+
+    # Find purchase order by ID
+    # For valid response try integer IDs with value &lt;&#x3D; 5 or &gt; 10. Other values will generated exceptions
+    # @param order_id ID of pet that needs to be fetched
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(Order, Fixnum, Hash)>] Order data, response status code and response headers
+    def get_order_by_id_with_http_info(order_id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: StoreApi.get_order_by_id ...'
+      end
+      # verify the required parameter 'order_id' is set
+      if @api_client.config.client_side_validation && order_id.nil?
+        fail ArgumentError, "Missing the required parameter 'order_id' when calling StoreApi.get_order_by_id"
+      end
+      if @api_client.config.client_side_validation && order_id > 5
+        fail ArgumentError, 'invalid value for "order_id" when calling StoreApi.get_order_by_id, must be smaller than or equal to 5.'
+      end
+
+      if @api_client.config.client_side_validation && order_id < 1
+        fail ArgumentError, 'invalid value for "order_id" when calling StoreApi.get_order_by_id, must be greater than or equal to 1.'
+      end
+
+      # resource path
+      local_var_path = '/store/order/{order_id}'.sub('{' + 'order_id' + '}', order_id.to_s)
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/xml', 'application/json'])
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = nil
+      auth_names = []
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => 'Order')
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: StoreApi#get_order_by_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Place an order for a pet
+    # @param order order placed for purchasing the pet
+    # @param [Hash] opts the optional parameters
+    # @return [Order]
+    def place_order(order, opts = {})
+      data, _status_code, _headers = place_order_with_http_info(order, opts)
+      data
+    end
+
+    # Place an order for a pet
+    # @param order order placed for purchasing the pet
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(Order, Fixnum, Hash)>] Order data, response status code and response headers
+    def place_order_with_http_info(order, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: StoreApi.place_order ...'
+      end
+      # verify the required parameter 'order' is set
+      if @api_client.config.client_side_validation && order.nil?
+        fail ArgumentError, "Missing the required parameter 'order' when calling StoreApi.place_order"
+      end
+      # resource path
+      local_var_path = '/store/order'
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/xml', 'application/json'])
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = @api_client.object_to_http_body(order)
+      auth_names = []
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => 'Order')
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: StoreApi#place_order\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/api/user_api.rb

@@ -0,0 +1,427 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'uri'
+
+module Petstore
+  class UserApi
+    attr_accessor :api_client
+
+    def initialize(api_client = ApiClient.default)
+      @api_client = api_client
+    end
+    # Create user
+    # This can only be done by the logged in user.
+    # @param user Created user object
+    # @param [Hash] opts the optional parameters
+    # @return [nil]
+    def create_user(user, opts = {})
+      create_user_with_http_info(user, opts)
+      nil
+    end
+
+    # Create user
+    # This can only be done by the logged in user.
+    # @param user Created user object
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
+    def create_user_with_http_info(user, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: UserApi.create_user ...'
+      end
+      # verify the required parameter 'user' is set
+      if @api_client.config.client_side_validation && user.nil?
+        fail ArgumentError, "Missing the required parameter 'user' when calling UserApi.create_user"
+      end
+      # resource path
+      local_var_path = '/user'
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = @api_client.object_to_http_body(user)
+      auth_names = []
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: UserApi#create_user\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Creates list of users with given input array
+    # @param user List of user object
+    # @param [Hash] opts the optional parameters
+    # @return [nil]
+    def create_users_with_array_input(user, opts = {})
+      create_users_with_array_input_with_http_info(user, opts)
+      nil
+    end
+
+    # Creates list of users with given input array
+    # @param user List of user object
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
+    def create_users_with_array_input_with_http_info(user, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: UserApi.create_users_with_array_input ...'
+      end
+      # verify the required parameter 'user' is set
+      if @api_client.config.client_side_validation && user.nil?
+        fail ArgumentError, "Missing the required parameter 'user' when calling UserApi.create_users_with_array_input"
+      end
+      # resource path
+      local_var_path = '/user/createWithArray'
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = @api_client.object_to_http_body(user)
+      auth_names = []
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: UserApi#create_users_with_array_input\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Creates list of users with given input array
+    # @param user List of user object
+    # @param [Hash] opts the optional parameters
+    # @return [nil]
+    def create_users_with_list_input(user, opts = {})
+      create_users_with_list_input_with_http_info(user, opts)
+      nil
+    end
+
+    # Creates list of users with given input array
+    # @param user List of user object
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
+    def create_users_with_list_input_with_http_info(user, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: UserApi.create_users_with_list_input ...'
+      end
+      # verify the required parameter 'user' is set
+      if @api_client.config.client_side_validation && user.nil?
+        fail ArgumentError, "Missing the required parameter 'user' when calling UserApi.create_users_with_list_input"
+      end
+      # resource path
+      local_var_path = '/user/createWithList'
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = @api_client.object_to_http_body(user)
+      auth_names = []
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: UserApi#create_users_with_list_input\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Delete user
+    # This can only be done by the logged in user.
+    # @param username The name that needs to be deleted
+    # @param [Hash] opts the optional parameters
+    # @return [nil]
+    def delete_user(username, opts = {})
+      delete_user_with_http_info(username, opts)
+      nil
+    end
+
+    # Delete user
+    # This can only be done by the logged in user.
+    # @param username The name that needs to be deleted
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
+    def delete_user_with_http_info(username, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: UserApi.delete_user ...'
+      end
+      # verify the required parameter 'username' is set
+      if @api_client.config.client_side_validation && username.nil?
+        fail ArgumentError, "Missing the required parameter 'username' when calling UserApi.delete_user"
+      end
+      # resource path
+      local_var_path = '/user/{username}'.sub('{' + 'username' + '}', username.to_s)
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = nil
+      auth_names = []
+      data, status_code, headers = @api_client.call_api(:DELETE, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: UserApi#delete_user\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Get user by user name
+    # @param username The name that needs to be fetched. Use user1 for testing.
+    # @param [Hash] opts the optional parameters
+    # @return [User]
+    def get_user_by_name(username, opts = {})
+      data, _status_code, _headers = get_user_by_name_with_http_info(username, opts)
+      data
+    end
+
+    # Get user by user name
+    # @param username The name that needs to be fetched. Use user1 for testing.
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(User, Fixnum, Hash)>] User data, response status code and response headers
+    def get_user_by_name_with_http_info(username, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: UserApi.get_user_by_name ...'
+      end
+      # verify the required parameter 'username' is set
+      if @api_client.config.client_side_validation && username.nil?
+        fail ArgumentError, "Missing the required parameter 'username' when calling UserApi.get_user_by_name"
+      end
+      # resource path
+      local_var_path = '/user/{username}'.sub('{' + 'username' + '}', username.to_s)
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/xml', 'application/json'])
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = nil
+      auth_names = []
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => 'User')
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: UserApi#get_user_by_name\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Logs user into the system
+    # @param username The user name for login
+    # @param password The password for login in clear text
+    # @param [Hash] opts the optional parameters
+    # @return [String]
+    def login_user(username, password, opts = {})
+      data, _status_code, _headers = login_user_with_http_info(username, password, opts)
+      data
+    end
+
+    # Logs user into the system
+    # @param username The user name for login
+    # @param password The password for login in clear text
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(String, Fixnum, Hash)>] String data, response status code and response headers
+    def login_user_with_http_info(username, password, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: UserApi.login_user ...'
+      end
+      # verify the required parameter 'username' is set
+      if @api_client.config.client_side_validation && username.nil?
+        fail ArgumentError, "Missing the required parameter 'username' when calling UserApi.login_user"
+      end
+      # verify the required parameter 'password' is set
+      if @api_client.config.client_side_validation && password.nil?
+        fail ArgumentError, "Missing the required parameter 'password' when calling UserApi.login_user"
+      end
+      # resource path
+      local_var_path = '/user/login'
+
+      # query parameters
+      query_params = {}
+      query_params[:'username'] = username
+      query_params[:'password'] = password
+
+      # header parameters
+      header_params = {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/xml', 'application/json'])
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = nil
+      auth_names = []
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => 'String')
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: UserApi#login_user\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Logs out current logged in user session
+    # @param [Hash] opts the optional parameters
+    # @return [nil]
+    def logout_user(opts = {})
+      logout_user_with_http_info(opts)
+      nil
+    end
+
+    # Logs out current logged in user session
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
+    def logout_user_with_http_info(opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: UserApi.logout_user ...'
+      end
+      # resource path
+      local_var_path = '/user/logout'
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = nil
+      auth_names = []
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: UserApi#logout_user\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Updated user
+    # This can only be done by the logged in user.
+    # @param username name that need to be deleted
+    # @param user Updated user object
+    # @param [Hash] opts the optional parameters
+    # @return [nil]
+    def update_user(username, user, opts = {})
+      update_user_with_http_info(username, user, opts)
+      nil
+    end
+
+    # Updated user
+    # This can only be done by the logged in user.
+    # @param username name that need to be deleted
+    # @param user Updated user object
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
+    def update_user_with_http_info(username, user, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: UserApi.update_user ...'
+      end
+      # verify the required parameter 'username' is set
+      if @api_client.config.client_side_validation && username.nil?
+        fail ArgumentError, "Missing the required parameter 'username' when calling UserApi.update_user"
+      end
+      # verify the required parameter 'user' is set
+      if @api_client.config.client_side_validation && user.nil?
+        fail ArgumentError, "Missing the required parameter 'user' when calling UserApi.update_user"
+      end
+      # resource path
+      local_var_path = '/user/{username}'.sub('{' + 'username' + '}', username.to_s)
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = @api_client.object_to_http_body(user)
+      auth_names = []
+      data, status_code, headers = @api_client.call_api(:PUT, local_var_path,
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: UserApi#update_user\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/api_client.rb

@@ -0,0 +1,204 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+require 'json'
+require 'logger'
+require 'faraday'
+
+module Petstore
+  class ApiClient
+    def self.default
+      @@default ||= ApiClient.new
+    end
+
+    def initialize(config = Configuration.default)
+      @config = config
+    end
+
+    attr_reader :config
+
+    def call_api(http_method, path, opts = {})
+      normalized_path = ::File.join(config.base_path, path)
+
+      @last_response = connection.public_send(http_method.to_sym.downcase) do |req|
+        req.url(normalized_path)
+
+        req.headers = default_headers.merge(opts[:header_params] || {})
+        req.body = opts[:body]
+
+        query_params = opts[:query_params] || {}
+        form_params = opts[:form_params] || {}
+        req.params = query_params.merge(form_params)
+      end
+
+      if @config.debugging
+        @config.logger.debug "HTTP response body ~BEGIN~\n#{@last_response.body}\n~END~\n"
+      end
+
+      if opts[:return_type]
+        data = deserialize(@last_response, opts[:return_type])
+      else
+        data = nil
+      end
+
+      return data, @last_response.status, @last_response.headers
+    end
+
+    attr_reader :last_response
+
+    # Convert object (array, hash, object, etc) to JSON string.
+    # @param [Object] model object to be converted into JSON string
+    # @return [String] JSON string representation of the object
+    def object_to_http_body(model)
+      return model if model.nil? || model.is_a?(String)
+      local_body = nil
+      if model.is_a?(Array)
+        local_body = model.map { |m| object_to_hash(m) }
+      else
+        local_body = object_to_hash(model)
+      end
+      local_body.to_json
+    end
+
+    # Convert object(non-array) to hash.
+    # @param [Object] obj object to be converted into JSON string
+    # @return [String] JSON string representation of the object
+    def object_to_hash(obj)
+      if obj.respond_to?(:to_hash)
+        obj.to_hash
+      else
+        obj
+      end
+    end
+
+    # Return Accept header based on an array of accepts provided.
+    # @param [Array] accepts array for Accept
+    # @return [String] the Accept header (e.g. application/json)
+    def select_header_accept(accepts)
+      return nil if accepts.nil? || accepts.empty?
+      # use JSON when present, otherwise use all of the provided
+      json_accept = accepts.find { |s| json_mime?(s) }
+      json_accept || accepts.join(',')
+    end
+
+    # Return Content-Type header based on an array of content types provided.
+    # @param [Array] content_types array for Content-Type
+    # @return [String] the Content-Type header  (e.g. application/json)
+    def select_header_content_type(content_types)
+      # use application/json by default
+      return 'application/json' if content_types.nil? || content_types.empty?
+      # use JSON when present, otherwise use the first one
+      json_content_type = content_types.find { |s| json_mime?(s) }
+      json_content_type || content_types.first
+    end
+
+    def json_mime?(mime)
+      (mime == '*/*') || !(mime =~ /Application\/.*json(?!p)(;.*)?/i).nil?
+    end
+
+    private
+
+    def connection
+      @connection ||= bulid_connection
+    end
+
+    def bulid_connection
+      Faraday.new(:url => config.base_url) do |builder|
+        builder.adapter(Faraday.default_adapter)
+      end
+    end
+
+    def user_agent
+      @user_agent ||= "OpenAPI-Generator/#{VERSION}/ruby"
+    end
+
+    def default_headers
+      {
+        'Content-Type' => 'application/json',
+        'User-Agent' => user_agent
+      }
+    end
+
+    # Deserialize the response to the given return type.
+    #
+    # @param [Response] response HTTP response
+    # @param [String] return_type some examples: "User", "Array<User>", "Hash<String, Integer>"
+    def deserialize(response, return_type)
+      body = response.body
+
+      return nil if body.nil? || body.empty?
+
+      # return response body directly for String return type
+      return body if return_type == 'String'
+
+      # ensuring a default content type
+      content_type = response.headers['Content-Type'] || 'application/json'
+
+      fail "Content-Type is not supported: #{content_type}" unless json_mime?(content_type)
+
+      begin
+        data = JSON.parse("[#{body}]", :symbolize_names => true)[0]
+      rescue JSON::ParserError => e
+        if %w(String Date DateTime).include?(return_type)
+          data = body
+        else
+          raise e
+        end
+      end
+
+      convert_to_type data, return_type
+    end
+
+    # Convert data to the given return type.
+    # @param [Object] data Data to be converted
+    # @param [String] return_type Return type
+    # @return [Mixed] Data in a particular type
+    def convert_to_type(data, return_type)
+      return nil if data.nil?
+      case return_type
+      when 'String'
+        data.to_s
+      when 'Integer'
+        data.to_i
+      when 'Float'
+        data.to_f
+      when 'BOOLEAN'
+        data == true
+      when 'DateTime'
+        # parse date time (expecting ISO 8601 format)
+        DateTime.parse data
+      when 'Date'
+        # parse date time (expecting ISO 8601 format)
+        Date.parse data
+      when 'Object'
+        # generic object (usually a Hash), return directly
+        data
+      when /\AArray<(.+)>\z/
+        # e.g. Array<Pet>
+        sub_type = $1
+        data.map { |item| convert_to_type(item, sub_type) }
+      when /\AHash\<String, (.+)\>\z/
+        # e.g. Hash<String, Integer>
+        sub_type = $1
+        {}.tap do |hash|
+          data.each { |k, v| hash[k] = convert_to_type(v, sub_type) }
+        end
+      else
+        # models, e.g. Pet
+        Petstore.const_get(return_type).new.tap do |model|
+          model.build_from_hash data
+        end
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/api_error.rb

@@ -0,0 +1,38 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+module Petstore
+  class ApiError < StandardError
+    attr_reader :code, :response_headers, :response_body
+
+    # Usage examples:
+    #   ApiError.new
+    #   ApiError.new("message")
+    #   ApiError.new(:code => 500, :response_headers => {}, :response_body => "")
+    #   ApiError.new(:code => 404, :message => "Not Found")
+    def initialize(arg = nil)
+      if arg.is_a? Hash
+        if arg.key?(:message) || arg.key?('message')
+          super(arg[:message] || arg['message'])
+        else
+          super arg
+        end
+
+        arg.each do |k, v|
+          instance_variable_set "@#{k}", v
+        end
+      else
+        super arg
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/configuration.rb

@@ -0,0 +1,272 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'uri'
+
+module Petstore
+  class Configuration
+    # Defines url scheme
+    attr_accessor :scheme
+
+    # Defines url host
+    attr_accessor :host
+
+    # Defines url base path
+    attr_accessor :base_path
+
+    # Defines API keys used with API Key authentications.
+    #
+    # @return [Hash] key: parameter name, value: parameter value (API key)
+    #
+    # @example parameter name is "api_key", API key is "xxx" (e.g. "api_key=xxx" in query string)
+    #   config.api_key['api_key'] = 'xxx'
+    attr_accessor :api_key
+
+    # Defines API key prefixes used with API Key authentications.
+    #
+    # @return [Hash] key: parameter name, value: API key prefix
+    #
+    # @example parameter name is "Authorization", API key prefix is "Token" (e.g. "Authorization: Token xxx" in headers)
+    #   config.api_key_prefix['api_key'] = 'Token'
+    attr_accessor :api_key_prefix
+
+    # Defines the username used with HTTP basic authentication.
+    #
+    # @return [String]
+    attr_accessor :username
+
+    # Defines the password used with HTTP basic authentication.
+    #
+    # @return [String]
+    attr_accessor :password
+
+    # Defines the access token (Bearer) used with OAuth2.
+    attr_accessor :access_token
+
+    # Set this to enable/disable debugging. When enabled (set to true), HTTP request/response
+    # details will be logged with `logger.debug` (see the `logger` attribute).
+    # Default to false.
+    #
+    # @return [true, false]
+    attr_accessor :debugging
+
+    # Defines the logger used for debugging.
+    # Default to `Rails.logger` (when in Rails) or logging to STDOUT.
+    #
+    # @return [#debug]
+    attr_accessor :logger
+
+    # Defines the temporary folder to store downloaded files
+    # (for API endpoints that have file response).
+    # Default to use `Tempfile`.
+    #
+    # @return [String]
+    attr_accessor :temp_folder_path
+
+    # The time limit for HTTP request in seconds.
+    # Default to 0 (never times out).
+    attr_accessor :timeout
+
+    # Set this to false to skip client side validation in the operation.
+    # Default to true.
+    # @return [true, false]
+    attr_accessor :client_side_validation
+
+    ### TLS/SSL setting
+    # Set this to false to skip verifying SSL certificate when calling API from https server.
+    # Default to true.
+    #
+    # @note Do NOT set it to false in production code, otherwise you would face multiple types of cryptographic attacks.
+    #
+    # @return [true, false]
+    attr_accessor :verify_ssl
+
+    ### TLS/SSL setting
+    # Set this to false to skip verifying SSL host name
+    # Default to true.
+    #
+    # @note Do NOT set it to false in production code, otherwise you would face multiple types of cryptographic attacks.
+    #
+    # @return [true, false]
+    attr_accessor :verify_ssl_host
+
+    ### TLS/SSL setting
+    # Set this to customize the certificate file to verify the peer.
+    #
+    # @return [String] the path to the certificate file
+    #
+    # @see The `cainfo` option of Typhoeus, `--cert` option of libcurl. Related source code:
+    # https://github.com/typhoeus/typhoeus/blob/master/lib/typhoeus/easy_factory.rb#L145
+    attr_accessor :ssl_ca_cert
+
+    ### TLS/SSL setting
+    # Client certificate file (for client certificate)
+    attr_accessor :cert_file
+
+    ### TLS/SSL setting
+    # Client private key file (for client certificate)
+    attr_accessor :key_file
+
+    # Set this to customize parameters encoding of array parameter with multi collectionFormat.
+    # Default to nil.
+    #
+    # @see The params_encoding option of Ethon. Related source code:
+    # https://github.com/typhoeus/ethon/blob/master/lib/ethon/easy/queryable.rb#L96
+    attr_accessor :params_encoding
+
+    attr_accessor :inject_format
+
+    attr_accessor :force_ending_format
+
+    def initialize
+      @scheme = 'https'
+      @host = 'petstore.swagger.io'
+      @base_path = '/v2'
+      @api_key = {}
+      @api_key_prefix = {}
+      @timeout = 0
+      @client_side_validation = true
+      @verify_ssl = true
+      @verify_ssl_host = true
+      @params_encoding = nil
+      @cert_file = nil
+      @key_file = nil
+      @debugging = false
+      @inject_format = false
+      @force_ending_format = false
+      @logger = defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
+
+      yield(self) if block_given?
+    end
+
+    # The default Configuration object.
+    def self.default
+      @@default ||= Configuration.new
+    end
+
+    def configure
+      yield(self) if block_given?
+    end
+
+    def scheme=(scheme)
+      # remove :// from scheme
+      @scheme = scheme.sub(/:\/\//, '')
+    end
+
+    def host=(host)
+      # remove http(s):// and anything after a slash
+      @host = host.sub(/https?:\/\//, '').split('/').first
+    end
+
+    def base_path=(base_path)
+      # Add leading and trailing slashes to base_path
+      @base_path = "/#{base_path}".gsub(/\/+/, '/')
+      @base_path = '' if @base_path == '/'
+    end
+
+    def base_url
+      url = "#{scheme}://#{[host, base_path].join('/').gsub(/\/+/, '/')}".sub(/\/+\z/, '')
+      URI.encode(url)
+    end
+
+    # Gets API key (with prefix if set).
+    # @param [String] param_name the parameter name of API key auth
+    def api_key_with_prefix(param_name)
+      if @api_key_prefix[param_name]
+        "#{@api_key_prefix[param_name]} #{@api_key[param_name]}"
+      else
+        @api_key[param_name]
+      end
+    end
+
+    # Gets Basic Auth token string
+    def basic_auth_token
+      'Basic ' + ["#{username}:#{password}"].pack('m').delete("\r\n")
+    end
+
+    # Returns Auth Settings hash for api client.
+    def auth_settings
+      {
+        'api_key' =>
+          {
+            type: 'api_key',
+            in: 'header',
+            key: 'api_key',
+            value: api_key_with_prefix('api_key')
+          },
+        'api_key_query' =>
+          {
+            type: 'api_key',
+            in: 'query',
+            key: 'api_key_query',
+            value: api_key_with_prefix('api_key_query')
+          },
+        'http_basic_test' =>
+          {
+            type: 'basic',
+            in: 'header',
+            key: 'Authorization',
+            value: basic_auth_token
+          },
+        'petstore_auth' =>
+          {
+            type: 'oauth2',
+            in: 'header',
+            key: 'Authorization',
+            value: "Bearer #{access_token}"
+          },
+      }
+    end
+
+    # Returns an array of Server setting
+    def server_settings
+      [
+        {
+          url: "http://petstore.swagger.io:80/v2",
+          description: "No descriptoin provided",
+        }
+      ]
+    end
+
+    # Returns URL based on server settings
+    #
+    # @param index array index of the server settings
+    # @param variables hash of variable and the corresponding value
+    def server_url(index, variables = {})
+      servers = server_settings
+
+      # check array index out of bound
+      if (index < 0 || index > servers.size)
+        fail ArgumentError "Invalid index #{index} when selecting the server. Must be less than #{servers.size}"
+      end
+
+      server = servers[index]
+      url = server[:url]
+
+      # go through variable and assign a value
+      server[:variables].each do |name, variable|
+        if variables.key?(name)
+          if (server[:variables][name][:enum_values].include? variables[name])
+            url.gsub! "{" + name.to_s + "}", variables[name]
+          else
+            fail ArgumentError, "The variable `#{name}` in the server URL has invalid value #{variables[name]}. Must be #{server[:variables][name][:enum_values]}."
+          end
+        else
+          # use default value
+          url.gsub! "{" + name.to_s + "}", server[:variables][name][:default_value]
+        end
+      end
+
+      url
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/additional_properties_class.rb

@@ -0,0 +1,196 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class AdditionalPropertiesClass
+    attr_accessor :map_property
+
+    attr_accessor :map_of_map_property
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'map_property' => :'map_property',
+        :'map_of_map_property' => :'map_of_map_property'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'map_property' => :'Hash<String, String>',
+        :'map_of_map_property' => :'Hash<String, Hash<String, String>>'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'map_property')
+        if (value = attributes[:'map_property']).is_a?(Hash)
+          self.map_property = value
+        end
+      end
+
+      if attributes.has_key?(:'map_of_map_property')
+        if (value = attributes[:'map_of_map_property']).is_a?(Hash)
+          self.map_of_map_property = value
+        end
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          map_property == o.map_property &&
+          map_of_map_property == o.map_of_map_property
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [map_property, map_of_map_property].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/animal.rb

@@ -0,0 +1,199 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class Animal
+    attr_accessor :class_name
+
+    attr_accessor :color
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'class_name' => :'className',
+        :'color' => :'color'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'class_name' => :'String',
+        :'color' => :'String'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'className')
+        self.class_name = attributes[:'className']
+      end
+
+      if attributes.has_key?(:'color')
+        self.color = attributes[:'color']
+      else
+        self.color = 'red'
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      if @class_name.nil?
+        invalid_properties.push('invalid value for "class_name", class_name cannot be nil.')
+      end
+
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      return false if @class_name.nil?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          class_name == o.class_name &&
+          color == o.color
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [class_name, color].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/animal_farm.rb

@@ -0,0 +1,174 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class AnimalFarm
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/api_response.rb

@@ -0,0 +1,201 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class ApiResponse
+    attr_accessor :code
+
+    attr_accessor :type
+
+    attr_accessor :message
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'code' => :'code',
+        :'type' => :'type',
+        :'message' => :'message'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'code' => :'Integer',
+        :'type' => :'String',
+        :'message' => :'String'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'code')
+        self.code = attributes[:'code']
+      end
+
+      if attributes.has_key?(:'type')
+        self.type = attributes[:'type']
+      end
+
+      if attributes.has_key?(:'message')
+        self.message = attributes[:'message']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          code == o.code &&
+          type == o.type &&
+          message == o.message
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [code, type, message].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/array_of_array_of_number_only.rb

@@ -0,0 +1,185 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class ArrayOfArrayOfNumberOnly
+    attr_accessor :array_array_number
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'array_array_number' => :'ArrayArrayNumber'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'array_array_number' => :'Array<Array<Float>>'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'ArrayArrayNumber')
+        if (value = attributes[:'ArrayArrayNumber']).is_a?(Array)
+          self.array_array_number = value
+        end
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          array_array_number == o.array_array_number
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [array_array_number].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/array_of_number_only.rb

@@ -0,0 +1,185 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class ArrayOfNumberOnly
+    attr_accessor :array_number
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'array_number' => :'ArrayNumber'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'array_number' => :'Array<Float>'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'ArrayNumber')
+        if (value = attributes[:'ArrayNumber']).is_a?(Array)
+          self.array_number = value
+        end
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          array_number == o.array_number
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [array_number].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/array_test.rb

@@ -0,0 +1,207 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class ArrayTest
+    attr_accessor :array_of_string
+
+    attr_accessor :array_array_of_integer
+
+    attr_accessor :array_array_of_model
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'array_of_string' => :'array_of_string',
+        :'array_array_of_integer' => :'array_array_of_integer',
+        :'array_array_of_model' => :'array_array_of_model'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'array_of_string' => :'Array<String>',
+        :'array_array_of_integer' => :'Array<Array<Integer>>',
+        :'array_array_of_model' => :'Array<Array<ReadOnlyFirst>>'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'array_of_string')
+        if (value = attributes[:'array_of_string']).is_a?(Array)
+          self.array_of_string = value
+        end
+      end
+
+      if attributes.has_key?(:'array_array_of_integer')
+        if (value = attributes[:'array_array_of_integer']).is_a?(Array)
+          self.array_array_of_integer = value
+        end
+      end
+
+      if attributes.has_key?(:'array_array_of_model')
+        if (value = attributes[:'array_array_of_model']).is_a?(Array)
+          self.array_array_of_model = value
+        end
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          array_of_string == o.array_of_string &&
+          array_array_of_integer == o.array_array_of_integer &&
+          array_array_of_model == o.array_array_of_model
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [array_of_string, array_array_of_integer, array_array_of_model].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/capitalization.rb

@@ -0,0 +1,229 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class Capitalization
+    attr_accessor :small_camel
+
+    attr_accessor :capital_camel
+
+    attr_accessor :small_snake
+
+    attr_accessor :capital_snake
+
+    attr_accessor :sca_eth_flow_points
+
+    # Name of the pet 
+    attr_accessor :att_name
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'small_camel' => :'smallCamel',
+        :'capital_camel' => :'CapitalCamel',
+        :'small_snake' => :'small_Snake',
+        :'capital_snake' => :'Capital_Snake',
+        :'sca_eth_flow_points' => :'SCA_ETH_Flow_Points',
+        :'att_name' => :'ATT_NAME'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'small_camel' => :'String',
+        :'capital_camel' => :'String',
+        :'small_snake' => :'String',
+        :'capital_snake' => :'String',
+        :'sca_eth_flow_points' => :'String',
+        :'att_name' => :'String'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'smallCamel')
+        self.small_camel = attributes[:'smallCamel']
+      end
+
+      if attributes.has_key?(:'CapitalCamel')
+        self.capital_camel = attributes[:'CapitalCamel']
+      end
+
+      if attributes.has_key?(:'small_Snake')
+        self.small_snake = attributes[:'small_Snake']
+      end
+
+      if attributes.has_key?(:'Capital_Snake')
+        self.capital_snake = attributes[:'Capital_Snake']
+      end
+
+      if attributes.has_key?(:'SCA_ETH_Flow_Points')
+        self.sca_eth_flow_points = attributes[:'SCA_ETH_Flow_Points']
+      end
+
+      if attributes.has_key?(:'ATT_NAME')
+        self.att_name = attributes[:'ATT_NAME']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          small_camel == o.small_camel &&
+          capital_camel == o.capital_camel &&
+          small_snake == o.small_snake &&
+          capital_snake == o.capital_snake &&
+          sca_eth_flow_points == o.sca_eth_flow_points &&
+          att_name == o.att_name
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [small_camel, capital_camel, small_snake, capital_snake, sca_eth_flow_points, att_name].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/cat.rb

@@ -0,0 +1,208 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class Cat
+    attr_accessor :class_name
+
+    attr_accessor :color
+
+    attr_accessor :declawed
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'class_name' => :'className',
+        :'color' => :'color',
+        :'declawed' => :'declawed'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'class_name' => :'String',
+        :'color' => :'String',
+        :'declawed' => :'BOOLEAN'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'className')
+        self.class_name = attributes[:'className']
+      end
+
+      if attributes.has_key?(:'color')
+        self.color = attributes[:'color']
+      else
+        self.color = 'red'
+      end
+
+      if attributes.has_key?(:'declawed')
+        self.declawed = attributes[:'declawed']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      if @class_name.nil?
+        invalid_properties.push('invalid value for "class_name", class_name cannot be nil.')
+      end
+
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      return false if @class_name.nil?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          class_name == o.class_name &&
+          color == o.color &&
+          declawed == o.declawed
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [class_name, color, declawed].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/category.rb

@@ -0,0 +1,199 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class Category
+    attr_accessor :id
+
+    attr_accessor :name
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'id' => :'id',
+        :'name' => :'name'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'id' => :'Integer',
+        :'name' => :'String'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'id')
+        self.id = attributes[:'id']
+      end
+
+      if attributes.has_key?(:'name')
+        self.name = attributes[:'name']
+      else
+        self.name = 'default-name'
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      if @name.nil?
+        invalid_properties.push('invalid value for "name", name cannot be nil.')
+      end
+
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      return false if @name.nil?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          id == o.id &&
+          name == o.name
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [id, name].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/class_model.rb

@@ -0,0 +1,184 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  # Model for testing model with \"_class\" property
+  class ClassModel
+    attr_accessor :_class
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'_class' => :'_class'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'_class' => :'String'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'_class')
+        self._class = attributes[:'_class']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          _class == o._class
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [_class].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/client.rb

@@ -0,0 +1,183 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class Client
+    attr_accessor :client
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'client' => :'client'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'client' => :'String'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'client')
+        self.client = attributes[:'client']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          client == o.client
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [client].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/dog.rb

@@ -0,0 +1,208 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class Dog
+    attr_accessor :class_name
+
+    attr_accessor :color
+
+    attr_accessor :breed
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'class_name' => :'className',
+        :'color' => :'color',
+        :'breed' => :'breed'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'class_name' => :'String',
+        :'color' => :'String',
+        :'breed' => :'String'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'className')
+        self.class_name = attributes[:'className']
+      end
+
+      if attributes.has_key?(:'color')
+        self.color = attributes[:'color']
+      else
+        self.color = 'red'
+      end
+
+      if attributes.has_key?(:'breed')
+        self.breed = attributes[:'breed']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      if @class_name.nil?
+        invalid_properties.push('invalid value for "class_name", class_name cannot be nil.')
+      end
+
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      return false if @class_name.nil?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          class_name == o.class_name &&
+          color == o.color &&
+          breed == o.breed
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [class_name, color, breed].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/enum_arrays.rb

@@ -0,0 +1,228 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class EnumArrays
+    attr_accessor :just_symbol
+
+    attr_accessor :array_enum
+
+    class EnumAttributeValidator
+      attr_reader :datatype
+      attr_reader :allowable_values
+
+      def initialize(datatype, allowable_values)
+        @allowable_values = allowable_values.map do |value|
+          case datatype.to_s
+          when /Integer/i
+            value.to_i
+          when /Float/i
+            value.to_f
+          else
+            value
+          end
+        end
+      end
+
+      def valid?(value)
+        !value || allowable_values.include?(value)
+      end
+    end
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'just_symbol' => :'just_symbol',
+        :'array_enum' => :'array_enum'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'just_symbol' => :'String',
+        :'array_enum' => :'Array<String>'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'just_symbol')
+        self.just_symbol = attributes[:'just_symbol']
+      end
+
+      if attributes.has_key?(:'array_enum')
+        if (value = attributes[:'array_enum']).is_a?(Array)
+          self.array_enum = value
+        end
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      just_symbol_validator = EnumAttributeValidator.new('String', ['>=', '$'])
+      return false unless just_symbol_validator.valid?(@just_symbol)
+      true
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] just_symbol Object to be assigned
+    def just_symbol=(just_symbol)
+      validator = EnumAttributeValidator.new('String', ['>=', '$'])
+      unless validator.valid?(just_symbol)
+        fail ArgumentError, 'invalid value for "just_symbol", must be one of #{validator.allowable_values}.'
+      end
+      @just_symbol = just_symbol
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          just_symbol == o.just_symbol &&
+          array_enum == o.array_enum
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [just_symbol, array_enum].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/enum_class.rb

@@ -0,0 +1,31 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class EnumClass
+    
+    ABC = '_abc'.freeze
+    EFG = '-efg'.freeze
+    XYZ = '(xyz)'.freeze
+
+    # Builds the enum from string
+    # @param [String] The enum value in the form of the string
+    # @return [String] The enum value
+    def build_from_hash(value)
+      constantValues = EnumClass.constants.select { |c| EnumClass::const_get(c) == value }
+      raise "Invalid ENUM value #{value} for class #EnumClass" if constantValues.empty?
+      value
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/enum_test.rb

@@ -0,0 +1,294 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class EnumTest
+    attr_accessor :enum_string
+
+    attr_accessor :enum_string_required
+
+    attr_accessor :enum_integer
+
+    attr_accessor :enum_number
+
+    attr_accessor :outer_enum
+
+    class EnumAttributeValidator
+      attr_reader :datatype
+      attr_reader :allowable_values
+
+      def initialize(datatype, allowable_values)
+        @allowable_values = allowable_values.map do |value|
+          case datatype.to_s
+          when /Integer/i
+            value.to_i
+          when /Float/i
+            value.to_f
+          else
+            value
+          end
+        end
+      end
+
+      def valid?(value)
+        !value || allowable_values.include?(value)
+      end
+    end
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'enum_string' => :'enum_string',
+        :'enum_string_required' => :'enum_string_required',
+        :'enum_integer' => :'enum_integer',
+        :'enum_number' => :'enum_number',
+        :'outer_enum' => :'outerEnum'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'enum_string' => :'String',
+        :'enum_string_required' => :'String',
+        :'enum_integer' => :'Integer',
+        :'enum_number' => :'Float',
+        :'outer_enum' => :'OuterEnum'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'enum_string')
+        self.enum_string = attributes[:'enum_string']
+      end
+
+      if attributes.has_key?(:'enum_string_required')
+        self.enum_string_required = attributes[:'enum_string_required']
+      end
+
+      if attributes.has_key?(:'enum_integer')
+        self.enum_integer = attributes[:'enum_integer']
+      end
+
+      if attributes.has_key?(:'enum_number')
+        self.enum_number = attributes[:'enum_number']
+      end
+
+      if attributes.has_key?(:'outerEnum')
+        self.outer_enum = attributes[:'outerEnum']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      if @enum_string_required.nil?
+        invalid_properties.push('invalid value for "enum_string_required", enum_string_required cannot be nil.')
+      end
+
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      enum_string_validator = EnumAttributeValidator.new('String', ['UPPER', 'lower', ''])
+      return false unless enum_string_validator.valid?(@enum_string)
+      return false if @enum_string_required.nil?
+      enum_string_required_validator = EnumAttributeValidator.new('String', ['UPPER', 'lower', ''])
+      return false unless enum_string_required_validator.valid?(@enum_string_required)
+      enum_integer_validator = EnumAttributeValidator.new('Integer', ['1', '-1'])
+      return false unless enum_integer_validator.valid?(@enum_integer)
+      enum_number_validator = EnumAttributeValidator.new('Float', ['1.1', '-1.2'])
+      return false unless enum_number_validator.valid?(@enum_number)
+      true
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] enum_string Object to be assigned
+    def enum_string=(enum_string)
+      validator = EnumAttributeValidator.new('String', ['UPPER', 'lower', ''])
+      unless validator.valid?(enum_string)
+        fail ArgumentError, 'invalid value for "enum_string", must be one of #{validator.allowable_values}.'
+      end
+      @enum_string = enum_string
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] enum_string_required Object to be assigned
+    def enum_string_required=(enum_string_required)
+      validator = EnumAttributeValidator.new('String', ['UPPER', 'lower', ''])
+      unless validator.valid?(enum_string_required)
+        fail ArgumentError, 'invalid value for "enum_string_required", must be one of #{validator.allowable_values}.'
+      end
+      @enum_string_required = enum_string_required
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] enum_integer Object to be assigned
+    def enum_integer=(enum_integer)
+      validator = EnumAttributeValidator.new('Integer', ['1', '-1'])
+      unless validator.valid?(enum_integer)
+        fail ArgumentError, 'invalid value for "enum_integer", must be one of #{validator.allowable_values}.'
+      end
+      @enum_integer = enum_integer
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] enum_number Object to be assigned
+    def enum_number=(enum_number)
+      validator = EnumAttributeValidator.new('Float', ['1.1', '-1.2'])
+      unless validator.valid?(enum_number)
+        fail ArgumentError, 'invalid value for "enum_number", must be one of #{validator.allowable_values}.'
+      end
+      @enum_number = enum_number
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          enum_string == o.enum_string &&
+          enum_string_required == o.enum_string_required &&
+          enum_integer == o.enum_integer &&
+          enum_number == o.enum_number &&
+          outer_enum == o.outer_enum
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [enum_string, enum_string_required, enum_integer, enum_number, outer_enum].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/file.rb

@@ -0,0 +1,185 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  # Must be named `File` for test.
+  class File
+    # Test capitalization
+    attr_accessor :source_uri
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'source_uri' => :'sourceURI'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'source_uri' => :'String'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'sourceURI')
+        self.source_uri = attributes[:'sourceURI']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          source_uri == o.source_uri
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [source_uri].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/file_schema_test_class.rb

@@ -0,0 +1,194 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class FileSchemaTestClass
+    attr_accessor :file
+
+    attr_accessor :files
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'file' => :'file',
+        :'files' => :'files'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'file' => :'File',
+        :'files' => :'Array<File>'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'file')
+        self.file = attributes[:'file']
+      end
+
+      if attributes.has_key?(:'files')
+        if (value = attributes[:'files']).is_a?(Array)
+          self.files = value
+        end
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          file == o.file &&
+          files == o.files
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [file, files].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/format_test.rb

@@ -0,0 +1,497 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class FormatTest
+    attr_accessor :integer
+
+    attr_accessor :int32
+
+    attr_accessor :int64
+
+    attr_accessor :number
+
+    attr_accessor :float
+
+    attr_accessor :double
+
+    attr_accessor :string
+
+    attr_accessor :byte
+
+    attr_accessor :binary
+
+    attr_accessor :date
+
+    attr_accessor :date_time
+
+    attr_accessor :uuid
+
+    attr_accessor :password
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'integer' => :'integer',
+        :'int32' => :'int32',
+        :'int64' => :'int64',
+        :'number' => :'number',
+        :'float' => :'float',
+        :'double' => :'double',
+        :'string' => :'string',
+        :'byte' => :'byte',
+        :'binary' => :'binary',
+        :'date' => :'date',
+        :'date_time' => :'dateTime',
+        :'uuid' => :'uuid',
+        :'password' => :'password'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'integer' => :'Integer',
+        :'int32' => :'Integer',
+        :'int64' => :'Integer',
+        :'number' => :'Float',
+        :'float' => :'Float',
+        :'double' => :'Float',
+        :'string' => :'String',
+        :'byte' => :'String',
+        :'binary' => :'File',
+        :'date' => :'Date',
+        :'date_time' => :'DateTime',
+        :'uuid' => :'String',
+        :'password' => :'String'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'integer')
+        self.integer = attributes[:'integer']
+      end
+
+      if attributes.has_key?(:'int32')
+        self.int32 = attributes[:'int32']
+      end
+
+      if attributes.has_key?(:'int64')
+        self.int64 = attributes[:'int64']
+      end
+
+      if attributes.has_key?(:'number')
+        self.number = attributes[:'number']
+      end
+
+      if attributes.has_key?(:'float')
+        self.float = attributes[:'float']
+      end
+
+      if attributes.has_key?(:'double')
+        self.double = attributes[:'double']
+      end
+
+      if attributes.has_key?(:'string')
+        self.string = attributes[:'string']
+      end
+
+      if attributes.has_key?(:'byte')
+        self.byte = attributes[:'byte']
+      end
+
+      if attributes.has_key?(:'binary')
+        self.binary = attributes[:'binary']
+      end
+
+      if attributes.has_key?(:'date')
+        self.date = attributes[:'date']
+      end
+
+      if attributes.has_key?(:'dateTime')
+        self.date_time = attributes[:'dateTime']
+      end
+
+      if attributes.has_key?(:'uuid')
+        self.uuid = attributes[:'uuid']
+      end
+
+      if attributes.has_key?(:'password')
+        self.password = attributes[:'password']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      if !@integer.nil? && @integer > 100
+        invalid_properties.push('invalid value for "integer", must be smaller than or equal to 100.')
+      end
+
+      if !@integer.nil? && @integer < 10
+        invalid_properties.push('invalid value for "integer", must be greater than or equal to 10.')
+      end
+
+      if !@int32.nil? && @int32 > 200
+        invalid_properties.push('invalid value for "int32", must be smaller than or equal to 200.')
+      end
+
+      if !@int32.nil? && @int32 < 20
+        invalid_properties.push('invalid value for "int32", must be greater than or equal to 20.')
+      end
+
+      if @number.nil?
+        invalid_properties.push('invalid value for "number", number cannot be nil.')
+      end
+
+      if @number > 543.2
+        invalid_properties.push('invalid value for "number", must be smaller than or equal to 543.2.')
+      end
+
+      if @number < 32.1
+        invalid_properties.push('invalid value for "number", must be greater than or equal to 32.1.')
+      end
+
+      if !@float.nil? && @float > 987.6
+        invalid_properties.push('invalid value for "float", must be smaller than or equal to 987.6.')
+      end
+
+      if !@float.nil? && @float < 54.3
+        invalid_properties.push('invalid value for "float", must be greater than or equal to 54.3.')
+      end
+
+      if !@double.nil? && @double > 123.4
+        invalid_properties.push('invalid value for "double", must be smaller than or equal to 123.4.')
+      end
+
+      if !@double.nil? && @double < 67.8
+        invalid_properties.push('invalid value for "double", must be greater than or equal to 67.8.')
+      end
+
+      if !@string.nil? && @string !~ Regexp.new(/[a-z]/i)
+        invalid_properties.push('invalid value for "string", must conform to the pattern /[a-z]/i.')
+      end
+
+      if @byte.nil?
+        invalid_properties.push('invalid value for "byte", byte cannot be nil.')
+      end
+
+      if @byte !~ Regexp.new(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$)
+        invalid_properties.push('invalid value for "byte", must conform to the pattern /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$.')
+      end
+
+      if @date.nil?
+        invalid_properties.push('invalid value for "date", date cannot be nil.')
+      end
+
+      if @password.nil?
+        invalid_properties.push('invalid value for "password", password cannot be nil.')
+      end
+
+      if @password.to_s.length > 64
+        invalid_properties.push('invalid value for "password", the character length must be smaller than or equal to 64.')
+      end
+
+      if @password.to_s.length < 10
+        invalid_properties.push('invalid value for "password", the character length must be great than or equal to 10.')
+      end
+
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      return false if !@integer.nil? && @integer > 100
+      return false if !@integer.nil? && @integer < 10
+      return false if !@int32.nil? && @int32 > 200
+      return false if !@int32.nil? && @int32 < 20
+      return false if @number.nil?
+      return false if @number > 543.2
+      return false if @number < 32.1
+      return false if !@float.nil? && @float > 987.6
+      return false if !@float.nil? && @float < 54.3
+      return false if !@double.nil? && @double > 123.4
+      return false if !@double.nil? && @double < 67.8
+      return false if !@string.nil? && @string !~ Regexp.new(/[a-z]/i)
+      return false if @byte.nil?
+      return false if @byte !~ Regexp.new(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$)
+      return false if @date.nil?
+      return false if @password.nil?
+      return false if @password.to_s.length > 64
+      return false if @password.to_s.length < 10
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] integer Value to be assigned
+    def integer=(integer)
+      if !integer.nil? && integer > 100
+        fail ArgumentError, 'invalid value for "integer", must be smaller than or equal to 100.'
+      end
+
+      if !integer.nil? && integer < 10
+        fail ArgumentError, 'invalid value for "integer", must be greater than or equal to 10.'
+      end
+
+      @integer = integer
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] int32 Value to be assigned
+    def int32=(int32)
+      if !int32.nil? && int32 > 200
+        fail ArgumentError, 'invalid value for "int32", must be smaller than or equal to 200.'
+      end
+
+      if !int32.nil? && int32 < 20
+        fail ArgumentError, 'invalid value for "int32", must be greater than or equal to 20.'
+      end
+
+      @int32 = int32
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] number Value to be assigned
+    def number=(number)
+      if number.nil?
+        fail ArgumentError, 'number cannot be nil'
+      end
+
+      if number > 543.2
+        fail ArgumentError, 'invalid value for "number", must be smaller than or equal to 543.2.'
+      end
+
+      if number < 32.1
+        fail ArgumentError, 'invalid value for "number", must be greater than or equal to 32.1.'
+      end
+
+      @number = number
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] float Value to be assigned
+    def float=(float)
+      if !float.nil? && float > 987.6
+        fail ArgumentError, 'invalid value for "float", must be smaller than or equal to 987.6.'
+      end
+
+      if !float.nil? && float < 54.3
+        fail ArgumentError, 'invalid value for "float", must be greater than or equal to 54.3.'
+      end
+
+      @float = float
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] double Value to be assigned
+    def double=(double)
+      if !double.nil? && double > 123.4
+        fail ArgumentError, 'invalid value for "double", must be smaller than or equal to 123.4.'
+      end
+
+      if !double.nil? && double < 67.8
+        fail ArgumentError, 'invalid value for "double", must be greater than or equal to 67.8.'
+      end
+
+      @double = double
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] string Value to be assigned
+    def string=(string)
+      if !string.nil? && string !~ Regexp.new(/[a-z]/i)
+        fail ArgumentError, 'invalid value for "string", must conform to the pattern /[a-z]/i.'
+      end
+
+      @string = string
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] byte Value to be assigned
+    def byte=(byte)
+      if byte.nil?
+        fail ArgumentError, 'byte cannot be nil'
+      end
+
+      if byte !~ Regexp.new(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$)
+        fail ArgumentError, 'invalid value for "byte", must conform to the pattern /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$.'
+      end
+
+      @byte = byte
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] password Value to be assigned
+    def password=(password)
+      if password.nil?
+        fail ArgumentError, 'password cannot be nil'
+      end
+
+      if password.to_s.length > 64
+        fail ArgumentError, 'invalid value for "password", the character length must be smaller than or equal to 64.'
+      end
+
+      if password.to_s.length < 10
+        fail ArgumentError, 'invalid value for "password", the character length must be great than or equal to 10.'
+      end
+
+      @password = password
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          integer == o.integer &&
+          int32 == o.int32 &&
+          int64 == o.int64 &&
+          number == o.number &&
+          float == o.float &&
+          double == o.double &&
+          string == o.string &&
+          byte == o.byte &&
+          binary == o.binary &&
+          date == o.date &&
+          date_time == o.date_time &&
+          uuid == o.uuid &&
+          password == o.password
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [integer, int32, int64, number, float, double, string, byte, binary, date, date_time, uuid, password].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/has_only_read_only.rb

@@ -0,0 +1,192 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class HasOnlyReadOnly
+    attr_accessor :bar
+
+    attr_accessor :foo
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'bar' => :'bar',
+        :'foo' => :'foo'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'bar' => :'String',
+        :'foo' => :'String'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'bar')
+        self.bar = attributes[:'bar']
+      end
+
+      if attributes.has_key?(:'foo')
+        self.foo = attributes[:'foo']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          bar == o.bar &&
+          foo == o.foo
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [bar, foo].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/list.rb

@@ -0,0 +1,183 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class List
+    attr_accessor :_123_list
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'_123_list' => :'123-list'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'_123_list' => :'String'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'123-list')
+        self._123_list = attributes[:'123-list']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          _123_list == o._123_list
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [_123_list].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/map_test.rb

@@ -0,0 +1,240 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class MapTest
+    attr_accessor :map_map_of_string
+
+    attr_accessor :map_of_enum_string
+
+    attr_accessor :direct_map
+
+    attr_accessor :indirect_map
+
+    class EnumAttributeValidator
+      attr_reader :datatype
+      attr_reader :allowable_values
+
+      def initialize(datatype, allowable_values)
+        @allowable_values = allowable_values.map do |value|
+          case datatype.to_s
+          when /Integer/i
+            value.to_i
+          when /Float/i
+            value.to_f
+          else
+            value
+          end
+        end
+      end
+
+      def valid?(value)
+        !value || allowable_values.include?(value)
+      end
+    end
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'map_map_of_string' => :'map_map_of_string',
+        :'map_of_enum_string' => :'map_of_enum_string',
+        :'direct_map' => :'direct_map',
+        :'indirect_map' => :'indirect_map'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'map_map_of_string' => :'Hash<String, Hash<String, String>>',
+        :'map_of_enum_string' => :'Hash<String, String>',
+        :'direct_map' => :'Hash<String, BOOLEAN>',
+        :'indirect_map' => :'Hash<String, BOOLEAN>'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'map_map_of_string')
+        if (value = attributes[:'map_map_of_string']).is_a?(Hash)
+          self.map_map_of_string = value
+        end
+      end
+
+      if attributes.has_key?(:'map_of_enum_string')
+        if (value = attributes[:'map_of_enum_string']).is_a?(Hash)
+          self.map_of_enum_string = value
+        end
+      end
+
+      if attributes.has_key?(:'direct_map')
+        if (value = attributes[:'direct_map']).is_a?(Hash)
+          self.direct_map = value
+        end
+      end
+
+      if attributes.has_key?(:'indirect_map')
+        if (value = attributes[:'indirect_map']).is_a?(Hash)
+          self.indirect_map = value
+        end
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          map_map_of_string == o.map_map_of_string &&
+          map_of_enum_string == o.map_of_enum_string &&
+          direct_map == o.direct_map &&
+          indirect_map == o.indirect_map
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [map_map_of_string, map_of_enum_string, direct_map, indirect_map].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/mixed_properties_and_additional_properties_class.rb

@@ -0,0 +1,203 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class MixedPropertiesAndAdditionalPropertiesClass
+    attr_accessor :uuid
+
+    attr_accessor :date_time
+
+    attr_accessor :map
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'uuid' => :'uuid',
+        :'date_time' => :'dateTime',
+        :'map' => :'map'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'uuid' => :'String',
+        :'date_time' => :'DateTime',
+        :'map' => :'Hash<String, Animal>'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'uuid')
+        self.uuid = attributes[:'uuid']
+      end
+
+      if attributes.has_key?(:'dateTime')
+        self.date_time = attributes[:'dateTime']
+      end
+
+      if attributes.has_key?(:'map')
+        if (value = attributes[:'map']).is_a?(Hash)
+          self.map = value
+        end
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          uuid == o.uuid &&
+          date_time == o.date_time &&
+          map == o.map
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [uuid, date_time, map].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/model200_response.rb

@@ -0,0 +1,193 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  # Model for testing model name starting with number
+  class Model200Response
+    attr_accessor :name
+
+    attr_accessor :_class
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'name' => :'name',
+        :'_class' => :'class'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'name' => :'Integer',
+        :'_class' => :'String'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'name')
+        self.name = attributes[:'name']
+      end
+
+      if attributes.has_key?(:'class')
+        self._class = attributes[:'class']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          name == o.name &&
+          _class == o._class
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [name, _class].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/model_return.rb

@@ -0,0 +1,184 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  # Model for testing reserved words
+  class ModelReturn
+    attr_accessor :_return
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'_return' => :'return'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'_return' => :'Integer'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'return')
+        self._return = attributes[:'return']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          _return == o._return
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [_return].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/name.rb

@@ -0,0 +1,216 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  # Model for testing model name same as property name
+  class Name
+    attr_accessor :name
+
+    attr_accessor :snake_case
+
+    attr_accessor :property
+
+    attr_accessor :_123_number
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'name' => :'name',
+        :'snake_case' => :'snake_case',
+        :'property' => :'property',
+        :'_123_number' => :'123Number'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'name' => :'Integer',
+        :'snake_case' => :'Integer',
+        :'property' => :'String',
+        :'_123_number' => :'Integer'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'name')
+        self.name = attributes[:'name']
+      end
+
+      if attributes.has_key?(:'snake_case')
+        self.snake_case = attributes[:'snake_case']
+      end
+
+      if attributes.has_key?(:'property')
+        self.property = attributes[:'property']
+      end
+
+      if attributes.has_key?(:'123Number')
+        self._123_number = attributes[:'123Number']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      if @name.nil?
+        invalid_properties.push('invalid value for "name", name cannot be nil.')
+      end
+
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      return false if @name.nil?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          name == o.name &&
+          snake_case == o.snake_case &&
+          property == o.property &&
+          _123_number == o._123_number
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [name, snake_case, property, _123_number].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/number_only.rb

@@ -0,0 +1,183 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class NumberOnly
+    attr_accessor :just_number
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'just_number' => :'JustNumber'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'just_number' => :'Float'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'JustNumber')
+        self.just_number = attributes[:'JustNumber']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          just_number == o.just_number
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [just_number].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/order.rb

@@ -0,0 +1,265 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class Order
+    attr_accessor :id
+
+    attr_accessor :pet_id
+
+    attr_accessor :quantity
+
+    attr_accessor :ship_date
+
+    # Order Status
+    attr_accessor :status
+
+    attr_accessor :complete
+
+    class EnumAttributeValidator
+      attr_reader :datatype
+      attr_reader :allowable_values
+
+      def initialize(datatype, allowable_values)
+        @allowable_values = allowable_values.map do |value|
+          case datatype.to_s
+          when /Integer/i
+            value.to_i
+          when /Float/i
+            value.to_f
+          else
+            value
+          end
+        end
+      end
+
+      def valid?(value)
+        !value || allowable_values.include?(value)
+      end
+    end
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'id' => :'id',
+        :'pet_id' => :'petId',
+        :'quantity' => :'quantity',
+        :'ship_date' => :'shipDate',
+        :'status' => :'status',
+        :'complete' => :'complete'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'id' => :'Integer',
+        :'pet_id' => :'Integer',
+        :'quantity' => :'Integer',
+        :'ship_date' => :'DateTime',
+        :'status' => :'String',
+        :'complete' => :'BOOLEAN'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'id')
+        self.id = attributes[:'id']
+      end
+
+      if attributes.has_key?(:'petId')
+        self.pet_id = attributes[:'petId']
+      end
+
+      if attributes.has_key?(:'quantity')
+        self.quantity = attributes[:'quantity']
+      end
+
+      if attributes.has_key?(:'shipDate')
+        self.ship_date = attributes[:'shipDate']
+      end
+
+      if attributes.has_key?(:'status')
+        self.status = attributes[:'status']
+      end
+
+      if attributes.has_key?(:'complete')
+        self.complete = attributes[:'complete']
+      else
+        self.complete = false
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      status_validator = EnumAttributeValidator.new('String', ['placed', 'approved', 'delivered'])
+      return false unless status_validator.valid?(@status)
+      true
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] status Object to be assigned
+    def status=(status)
+      validator = EnumAttributeValidator.new('String', ['placed', 'approved', 'delivered'])
+      unless validator.valid?(status)
+        fail ArgumentError, 'invalid value for "status", must be one of #{validator.allowable_values}.'
+      end
+      @status = status
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          id == o.id &&
+          pet_id == o.pet_id &&
+          quantity == o.quantity &&
+          ship_date == o.ship_date &&
+          status == o.status &&
+          complete == o.complete
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [id, pet_id, quantity, ship_date, status, complete].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/outer_composite.rb

@@ -0,0 +1,201 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class OuterComposite
+    attr_accessor :my_number
+
+    attr_accessor :my_string
+
+    attr_accessor :my_boolean
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'my_number' => :'my_number',
+        :'my_string' => :'my_string',
+        :'my_boolean' => :'my_boolean'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'my_number' => :'Float',
+        :'my_string' => :'String',
+        :'my_boolean' => :'BOOLEAN'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'my_number')
+        self.my_number = attributes[:'my_number']
+      end
+
+      if attributes.has_key?(:'my_string')
+        self.my_string = attributes[:'my_string']
+      end
+
+      if attributes.has_key?(:'my_boolean')
+        self.my_boolean = attributes[:'my_boolean']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          my_number == o.my_number &&
+          my_string == o.my_string &&
+          my_boolean == o.my_boolean
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [my_number, my_string, my_boolean].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Petstore.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

samples/client/petstore/ruby-faraday/lib/petstore/models/outer_enum.rb

@@ -0,0 +1,31 @@
+=begin
+#OpenAPI Petstore
+
+#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 3.3.3-SNAPSHOT
+
+=end
+
+require 'date'
+
+module Petstore
+  class OuterEnum
+    
+    PLACED = 'placed'.freeze
+    APPROVED = 'approved'.freeze
+    DELIVERED = 'delivered'.freeze
+
+    # Builds the enum from string
+    # @param [String] The enum value in the form of the string
+    # @return [String] The enum value
+    def build_from_hash(value)
+      constantValues = OuterEnum.constants.select { |c| OuterEnum::const_get(c) == value }
+      raise "Invalid ENUM value #{value} for class #OuterEnum" if constantValues.empty?
+      value
+    end
+  end
+end