# Generated by API Builder - https://www.apibuilder.io
# Service version: 0.16.74
# User agent: apibuilder app.apibuilder.io/apicollective/apibuilder-swagger/0.16.74/ruby_client

require 'cgi'
require 'net/http'
require 'net/https'
require 'uri'
require 'base64'

require 'date'
require 'rubygems'
require 'json'
require 'bigdecimal'

# Specification of swagger using the apibuilder format
module Io
  module Apibuilder
    module Swagger
      module V0

        class Client

          module Constants

            NAMESPACE = 'io.apibuilder.swagger.v0' unless defined?(Constants::NAMESPACE)
            USER_AGENT = 'apibuilder app.apibuilder.io/apicollective/apibuilder-swagger/0.16.74/ruby_client' unless defined?(Constants::USER_AGENT)
            VERSION = '0.16.74' unless defined?(Constants::VERSION)
            VERSION_MAJOR = 0 unless defined?(VERSION_MAJOR)

          end

          attr_reader :url

          def initialize(url, opts={})
            @url = HttpClient::Preconditions.assert_class('url', url, String)
            @base_url = URI(url)
            @authorization = HttpClient::Preconditions.assert_class_or_nil('authorization', opts.delete(:authorization), HttpClient::Authorization)
            @default_headers = HttpClient::Preconditions.assert_class('default_headers', opts.delete(:default_headers) || {}, Hash)
            @http_handler = opts.delete(:http_handler) || HttpClient::DefaultHttpHandler.new

            HttpClient::Preconditions.assert_empty_opts(opts)
            HttpClient::Preconditions.check_state(url.match(/http.+/i), "URL[%s] must start with http" % url)
          end

          def request(path=nil)
            HttpClient::Preconditions.assert_class_or_nil('path', path, String)
            request = HttpClient::Request.new(@http_handler, @base_url, path.to_s).with_header('User-Agent', Constants::USER_AGENT).with_header('X-Apidoc-Version', Constants::VERSION).with_header('X-Apidoc-Version-Major', Constants::VERSION_MAJOR)

            @default_headers.each do |key, value|
              request = request.with_header(key, value)
            end

            if @authorization
              request = request.with_auth(@authorization)
            end

            request
          end


        end

        module Clients



        end

        module Models

          class ParameterOrRef

            module Types
              PARAMETER = 'parameter' unless defined?(PARAMETER)
              REFERENCE = 'reference' unless defined?(REFERENCE)
            end

            attr_reader :__discriminator__

            def initialize(incoming={})
              opts = HttpClient::Helper.symbolize_keys(incoming)
              @__discriminator__ = opts[:__discriminator__] ||'parameter_or_ref'
            end

            def subtype_to_hash
              raise 'Cannot serialize an instance of parameter_or_ref directly - must use one of the specific types: parameter, reference'
            end

            def to_hash
              { @__discriminator__ => subtype_to_hash }
            end

            def ParameterOrRef.from_json(hash)
              HttpClient::Preconditions.assert_class('hash', hash, Hash)
              hash.map do |union_type_name, data|
                case union_type_name
                  when Types::PARAMETER; Parameter.new(data)
                  when Types::REFERENCE; Reference.new(data)
                  else ParameterOrRefUndefinedType.new(:__discriminator__ => union_type_name)
                end
              end.first
            end

          end

          class ParameterOrRefUndefinedType < ParameterOrRef

            attr_reader :name

            def initialize(incoming={})
              super(:__discriminator__ => 'undefined_type')
              opts = HttpClient::Helper.symbolize_keys(incoming)
              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:__discriminator__), String)
            end

            def subtype_to_hash
              raise 'Unable to serialize undefined type to json'
            end

            def copy(incoming={})
              raise 'Operation not supported for undefined type'
            end

            def to_hash
              raise 'Operation not supported for undefined type'
            end

          end

          class ResponseOrRef

            module Types
              RESPONSE = 'response' unless defined?(RESPONSE)
              REFERENCE = 'reference' unless defined?(REFERENCE)
            end

            attr_reader :__discriminator__

            def initialize(incoming={})
              opts = HttpClient::Helper.symbolize_keys(incoming)
              @__discriminator__ = opts[:__discriminator__] ||'response_or_ref'
            end

            def subtype_to_hash
              raise 'Cannot serialize an instance of response_or_ref directly - must use one of the specific types: response, reference'
            end

            def to_hash
              { @__discriminator__ => subtype_to_hash }
            end

            def ResponseOrRef.from_json(hash)
              HttpClient::Preconditions.assert_class('hash', hash, Hash)
              hash.map do |union_type_name, data|
                case union_type_name
                  when Types::RESPONSE; Response.new(data)
                  when Types::REFERENCE; Reference.new(data)
                  else ResponseOrRefUndefinedType.new(:__discriminator__ => union_type_name)
                end
              end.first
            end

          end

          class ResponseOrRefUndefinedType < ResponseOrRef

            attr_reader :name

            def initialize(incoming={})
              super(:__discriminator__ => 'undefined_type')
              opts = HttpClient::Helper.symbolize_keys(incoming)
              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:__discriminator__), String)
            end

            def subtype_to_hash
              raise 'Unable to serialize undefined type to json'
            end

            def copy(incoming={})
              raise 'Operation not supported for undefined type'
            end

            def to_hash
              raise 'Operation not supported for undefined type'
            end

          end

          class ApiKeyInType

            attr_reader :value

            def initialize(value)
              @value = HttpClient::Preconditions.assert_class('value', value, String)
            end

            # Returns the instance of ApiKeyInType for this value, creating a new instance for an unknown value
            def ApiKeyInType.apply(value)
              if value.instance_of?(ApiKeyInType)
                value
              else
                HttpClient::Preconditions.assert_class_or_nil('value', value, String)
                value.nil? ? nil : (from_string(value) || ApiKeyInType.new(value))
              end
            end

            # Returns the instance of ApiKeyInType for this value, or nil if not found
            def ApiKeyInType.from_string(value)
              HttpClient::Preconditions.assert_class('value', value, String)
              ApiKeyInType.ALL.find { |v| v.value == value }
            end

            def ApiKeyInType.ALL
              @@all ||= [ApiKeyInType.query, ApiKeyInType.header]
            end

            def ApiKeyInType.query
              @@_query ||= ApiKeyInType.new('query')
            end

            def ApiKeyInType.header
              @@_header ||= ApiKeyInType.new('header')
            end

            def to_hash
              value
            end

          end

          class CollectionFormatType

            attr_reader :value

            def initialize(value)
              @value = HttpClient::Preconditions.assert_class('value', value, String)
            end

            # Returns the instance of CollectionFormatType for this value, creating a new instance for an unknown value
            def CollectionFormatType.apply(value)
              if value.instance_of?(CollectionFormatType)
                value
              else
                HttpClient::Preconditions.assert_class_or_nil('value', value, String)
                value.nil? ? nil : (from_string(value) || CollectionFormatType.new(value))
              end
            end

            # Returns the instance of CollectionFormatType for this value, or nil if not found
            def CollectionFormatType.from_string(value)
              HttpClient::Preconditions.assert_class('value', value, String)
              CollectionFormatType.ALL.find { |v| v.value == value }
            end

            def CollectionFormatType.ALL
              @@all ||= [CollectionFormatType.csv, CollectionFormatType.ssv, CollectionFormatType.tsv, CollectionFormatType.pipes]
            end

            def CollectionFormatType.csv
              @@_csv ||= CollectionFormatType.new('csv')
            end

            def CollectionFormatType.ssv
              @@_ssv ||= CollectionFormatType.new('ssv')
            end

            def CollectionFormatType.tsv
              @@_tsv ||= CollectionFormatType.new('tsv')
            end

            def CollectionFormatType.pipes
              @@_pipes ||= CollectionFormatType.new('pipes')
            end

            def to_hash
              value
            end

          end

          class FormatType

            attr_reader :value

            def initialize(value)
              @value = HttpClient::Preconditions.assert_class('value', value, String)
            end

            # Returns the instance of FormatType for this value, creating a new instance for an unknown value
            def FormatType.apply(value)
              if value.instance_of?(FormatType)
                value
              else
                HttpClient::Preconditions.assert_class_or_nil('value', value, String)
                value.nil? ? nil : (from_string(value) || FormatType.new(value))
              end
            end

            # Returns the instance of FormatType for this value, or nil if not found
            def FormatType.from_string(value)
              HttpClient::Preconditions.assert_class('value', value, String)
              FormatType.ALL.find { |v| v.value == value }
            end

            def FormatType.ALL
              @@all ||= [FormatType.binary, FormatType.byte, FormatType.date, FormatType.date_time, FormatType.double, FormatType.float, FormatType.int32, FormatType.int64, FormatType.password]
            end

            def FormatType.binary
              @@_binary ||= FormatType.new('binary')
            end

            def FormatType.byte
              @@_byte ||= FormatType.new('byte')
            end

            def FormatType.date
              @@_date ||= FormatType.new('date')
            end

            def FormatType.date_time
              @@_date_time ||= FormatType.new('date-time')
            end

            def FormatType.double
              @@_double ||= FormatType.new('double')
            end

            def FormatType.float
              @@_float ||= FormatType.new('float')
            end

            def FormatType.int32
              @@_int32 ||= FormatType.new('int32')
            end

            def FormatType.int64
              @@_int64 ||= FormatType.new('int64')
            end

            def FormatType.password
              @@_password ||= FormatType.new('password')
            end

            def to_hash
              value
            end

          end

          class ItemsType

            attr_reader :value

            def initialize(value)
              @value = HttpClient::Preconditions.assert_class('value', value, String)
            end

            # Returns the instance of ItemsType for this value, creating a new instance for an unknown value
            def ItemsType.apply(value)
              if value.instance_of?(ItemsType)
                value
              else
                HttpClient::Preconditions.assert_class_or_nil('value', value, String)
                value.nil? ? nil : (from_string(value) || ItemsType.new(value))
              end
            end

            # Returns the instance of ItemsType for this value, or nil if not found
            def ItemsType.from_string(value)
              HttpClient::Preconditions.assert_class('value', value, String)
              ItemsType.ALL.find { |v| v.value == value }
            end

            def ItemsType.ALL
              @@all ||= [ItemsType.string, ItemsType.number, ItemsType.integer, ItemsType.boolean, ItemsType.array]
            end

            def ItemsType.string
              @@_string ||= ItemsType.new('string')
            end

            def ItemsType.number
              @@_number ||= ItemsType.new('number')
            end

            def ItemsType.integer
              @@_integer ||= ItemsType.new('integer')
            end

            def ItemsType.boolean
              @@_boolean ||= ItemsType.new('boolean')
            end

            def ItemsType.array
              @@_array ||= ItemsType.new('array')
            end

            def to_hash
              value
            end

          end

          class ParameterInType

            attr_reader :value

            def initialize(value)
              @value = HttpClient::Preconditions.assert_class('value', value, String)
            end

            # Returns the instance of ParameterInType for this value, creating a new instance for an unknown value
            def ParameterInType.apply(value)
              if value.instance_of?(ParameterInType)
                value
              else
                HttpClient::Preconditions.assert_class_or_nil('value', value, String)
                value.nil? ? nil : (from_string(value) || ParameterInType.new(value))
              end
            end

            # Returns the instance of ParameterInType for this value, or nil if not found
            def ParameterInType.from_string(value)
              HttpClient::Preconditions.assert_class('value', value, String)
              ParameterInType.ALL.find { |v| v.value == value }
            end

            def ParameterInType.ALL
              @@all ||= [ParameterInType.query, ParameterInType.header, ParameterInType.path, ParameterInType.form_data, ParameterInType.body]
            end

            def ParameterInType.query
              @@_query ||= ParameterInType.new('query')
            end

            def ParameterInType.header
              @@_header ||= ParameterInType.new('header')
            end

            def ParameterInType.path
              @@_path ||= ParameterInType.new('path')
            end

            def ParameterInType.form_data
              @@_form_data ||= ParameterInType.new('formData')
            end

            def ParameterInType.body
              @@_body ||= ParameterInType.new('body')
            end

            def to_hash
              value
            end

          end

          class SecuritySchemeType

            attr_reader :value

            def initialize(value)
              @value = HttpClient::Preconditions.assert_class('value', value, String)
            end

            # Returns the instance of SecuritySchemeType for this value, creating a new instance for an unknown value
            def SecuritySchemeType.apply(value)
              if value.instance_of?(SecuritySchemeType)
                value
              else
                HttpClient::Preconditions.assert_class_or_nil('value', value, String)
                value.nil? ? nil : (from_string(value) || SecuritySchemeType.new(value))
              end
            end

            # Returns the instance of SecuritySchemeType for this value, or nil if not found
            def SecuritySchemeType.from_string(value)
              HttpClient::Preconditions.assert_class('value', value, String)
              SecuritySchemeType.ALL.find { |v| v.value == value }
            end

            def SecuritySchemeType.ALL
              @@all ||= [SecuritySchemeType.basic, SecuritySchemeType.api_key, SecuritySchemeType.oauth2]
            end

            def SecuritySchemeType.basic
              @@_basic ||= SecuritySchemeType.new('basic')
            end

            def SecuritySchemeType.api_key
              @@_api_key ||= SecuritySchemeType.new('apiKey')
            end

            def SecuritySchemeType.oauth2
              @@_oauth2 ||= SecuritySchemeType.new('oauth2')
            end

            def to_hash
              value
            end

          end

          class Contact

            attr_reader :name, :url, :email

            def initialize(incoming={})
              opts = HttpClient::Helper.symbolize_keys(incoming)
              @name = (x = opts.delete(:name); x.nil? ? nil : HttpClient::Preconditions.assert_class('name', x, String))
              @url = (x = opts.delete(:url); x.nil? ? nil : HttpClient::Preconditions.assert_class('url', x, String))
              @email = (x = opts.delete(:email); x.nil? ? nil : HttpClient::Preconditions.assert_class('email', x, String))
            end

            def to_json
              JSON.dump(to_hash)
            end

            def copy(incoming={})
              Contact.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
            end

            def to_hash
              {
                :name => name,
                :url => url,
                :email => email
              }
            end

          end

          class ExternalDocumentation

            attr_reader :description, :url

            def initialize(incoming={})
              opts = HttpClient::Helper.symbolize_keys(incoming)
              HttpClient::Preconditions.require_keys(opts, [:url], 'ExternalDocumentation')
              @description = (x = opts.delete(:description); x.nil? ? nil : HttpClient::Preconditions.assert_class('description', x, String))
              @url = HttpClient::Preconditions.assert_class('url', opts.delete(:url), String)
            end

            def to_json
              JSON.dump(to_hash)
            end

            def copy(incoming={})
              ExternalDocumentation.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
            end

            def to_hash
              {
                :description => description,
                :url => url
              }
            end

          end

          # TODO: Can this be a union type with items?
          class Header

            attr_reader :description, :type, :format, :items, :collectionFormat, :default, :maximum, :exclusiveMaximum, :minimum, :exclusiveMinimum, :maxLength, :minLength, :pattern, :maxItems, :minItems, :uniqueItems, :enum, :multipleOf

            def initialize(incoming={})
              opts = HttpClient::Helper.symbolize_keys(incoming)
              HttpClient::Preconditions.require_keys(opts, [:type], 'Header')
              @description = (x = opts.delete(:description); x.nil? ? nil : HttpClient::Preconditions.assert_class('description', x, String))
              @type = (x = opts.delete(:type); x.is_a?(::Io::Apibuilder::Swagger::V0::Models::ItemsType) ? x : ::Io::Apibuilder::Swagger::V0::Models::ItemsType.apply(x))
              @format = (x = opts.delete(:format); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::FormatType) ? x : ::Io::Apibuilder::Swagger::V0::Models::FormatType.apply(x)))
              @items = (x = opts.delete(:items); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::Items) ? x : ::Io::Apibuilder::Swagger::V0::Models::Items.new(x)))
              @collectionFormat = (x = opts.delete(:collectionFormat); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::CollectionFormatType) ? x : ::Io::Apibuilder::Swagger::V0::Models::CollectionFormatType.apply(x)))
              @default = (x = opts.delete(:default); x.nil? ? nil : HttpClient::Preconditions.assert_class('default', HttpClient::Helper.to_object(x), Hash))
              @maximum = (x = opts.delete(:maximum); x.nil? ? nil : HttpClient::Preconditions.assert_class('maximum', x, Integer))
              @exclusiveMaximum = (x = opts.delete(:exclusiveMaximum); x.nil? ? nil : HttpClient::Preconditions.assert_boolean('exclusiveMaximum', x))
              @minimum = (x = opts.delete(:minimum); x.nil? ? nil : HttpClient::Preconditions.assert_class('minimum', x, Integer))
              @exclusiveMinimum = (x = opts.delete(:exclusiveMinimum); x.nil? ? nil : HttpClient::Preconditions.assert_boolean('exclusiveMinimum', x))
              @maxLength = (x = opts.delete(:maxLength); x.nil? ? nil : HttpClient::Preconditions.assert_class('maxLength', x, Integer))
              @minLength = (x = opts.delete(:minLength); x.nil? ? nil : HttpClient::Preconditions.assert_class('minLength', x, Integer))
              @pattern = (x = opts.delete(:pattern); x.nil? ? nil : HttpClient::Preconditions.assert_class('pattern', x, String))
              @maxItems = (x = opts.delete(:maxItems); x.nil? ? nil : HttpClient::Preconditions.assert_class('maxItems', x, Integer))
              @minItems = (x = opts.delete(:minItems); x.nil? ? nil : HttpClient::Preconditions.assert_class('minItems', x, Integer))
              @uniqueItems = (x = opts.delete(:uniqueItems); x.nil? ? nil : HttpClient::Preconditions.assert_boolean('uniqueItems', x))
              @enum = (x = opts.delete(:enum); x.nil? ? nil : HttpClient::Preconditions.assert_class('enum', x, Array).map { |v| HttpClient::Preconditions.assert_class('enum', HttpClient::Helper.to_object(v), Hash) })
              @multipleOf = (x = opts.delete(:multipleOf); x.nil? ? nil : HttpClient::Preconditions.assert_class('multipleOf', x, Integer))
            end

            def to_json
              JSON.dump(to_hash)
            end

            def copy(incoming={})
              Header.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
            end

            def to_hash
              {
                :description => description,
                :type => type.value,
                :format => format.nil? ? nil : format.value,
                :items => items.nil? ? nil : items.to_hash,
                :collectionFormat => collectionFormat.nil? ? nil : collectionFormat.value,
                :default => default,
                :maximum => maximum,
                :exclusiveMaximum => exclusiveMaximum,
                :minimum => minimum,
                :exclusiveMinimum => exclusiveMinimum,
                :maxLength => maxLength,
                :minLength => minLength,
                :pattern => pattern,
                :maxItems => maxItems,
                :minItems => minItems,
                :uniqueItems => uniqueItems,
                :enum => enum.nil? ? nil : enum,
                :multipleOf => multipleOf
              }
            end

          end

          class Info

            attr_reader :title, :description, :termsOfService, :contact, :license, :version

            def initialize(incoming={})
              opts = HttpClient::Helper.symbolize_keys(incoming)
              HttpClient::Preconditions.require_keys(opts, [:title, :version], 'Info')
              @title = HttpClient::Preconditions.assert_class('title', opts.delete(:title), String)
              @description = (x = opts.delete(:description); x.nil? ? nil : HttpClient::Preconditions.assert_class('description', x, String))
              @termsOfService = (x = opts.delete(:termsOfService); x.nil? ? nil : HttpClient::Preconditions.assert_class('termsOfService', x, String))
              @contact = (x = opts.delete(:contact); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::Contact) ? x : ::Io::Apibuilder::Swagger::V0::Models::Contact.new(x)))
              @license = (x = opts.delete(:license); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::License) ? x : ::Io::Apibuilder::Swagger::V0::Models::License.new(x)))
              @version = HttpClient::Preconditions.assert_class('version', opts.delete(:version), String)
            end

            def to_json
              JSON.dump(to_hash)
            end

            def copy(incoming={})
              Info.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
            end

            def to_hash
              {
                :title => title,
                :description => description,
                :termsOfService => termsOfService,
                :contact => contact.nil? ? nil : contact.to_hash,
                :license => license.nil? ? nil : license.to_hash,
                :version => version
              }
            end

          end

          class Items

            attr_reader :type, :format, :items, :collectionFormat, :default, :maximum, :exclusiveMaximum, :minimum, :exclusiveMinimum, :maxLength, :minLength, :pattern, :maxItems, :minItems, :uniqueItems, :enum, :multipleOf

            def initialize(incoming={})
              opts = HttpClient::Helper.symbolize_keys(incoming)
              HttpClient::Preconditions.require_keys(opts, [:type], 'Items')
              @type = (x = opts.delete(:type); x.is_a?(::Io::Apibuilder::Swagger::V0::Models::ItemsType) ? x : ::Io::Apibuilder::Swagger::V0::Models::ItemsType.apply(x))
              @format = (x = opts.delete(:format); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::FormatType) ? x : ::Io::Apibuilder::Swagger::V0::Models::FormatType.apply(x)))
              @items = (x = opts.delete(:items); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::Items) ? x : ::Io::Apibuilder::Swagger::V0::Models::Items.new(x)))
              @collectionFormat = (x = opts.delete(:collectionFormat); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::CollectionFormatType) ? x : ::Io::Apibuilder::Swagger::V0::Models::CollectionFormatType.apply(x)))
              @default = (x = opts.delete(:default); x.nil? ? nil : HttpClient::Preconditions.assert_class('default', HttpClient::Helper.to_object(x), Hash))
              @maximum = (x = opts.delete(:maximum); x.nil? ? nil : HttpClient::Preconditions.assert_class('maximum', x, Integer))
              @exclusiveMaximum = (x = opts.delete(:exclusiveMaximum); x.nil? ? nil : HttpClient::Preconditions.assert_boolean('exclusiveMaximum', x))
              @minimum = (x = opts.delete(:minimum); x.nil? ? nil : HttpClient::Preconditions.assert_class('minimum', x, Integer))
              @exclusiveMinimum = (x = opts.delete(:exclusiveMinimum); x.nil? ? nil : HttpClient::Preconditions.assert_boolean('exclusiveMinimum', x))
              @maxLength = (x = opts.delete(:maxLength); x.nil? ? nil : HttpClient::Preconditions.assert_class('maxLength', x, Integer))
              @minLength = (x = opts.delete(:minLength); x.nil? ? nil : HttpClient::Preconditions.assert_class('minLength', x, Integer))
              @pattern = (x = opts.delete(:pattern); x.nil? ? nil : HttpClient::Preconditions.assert_class('pattern', x, String))
              @maxItems = (x = opts.delete(:maxItems); x.nil? ? nil : HttpClient::Preconditions.assert_class('maxItems', x, Integer))
              @minItems = (x = opts.delete(:minItems); x.nil? ? nil : HttpClient::Preconditions.assert_class('minItems', x, Integer))
              @uniqueItems = (x = opts.delete(:uniqueItems); x.nil? ? nil : HttpClient::Preconditions.assert_boolean('uniqueItems', x))
              @enum = (x = opts.delete(:enum); x.nil? ? nil : HttpClient::Preconditions.assert_class('enum', x, Array).map { |v| HttpClient::Preconditions.assert_class('enum', HttpClient::Helper.to_object(v), Hash) })
              @multipleOf = (x = opts.delete(:multipleOf); x.nil? ? nil : HttpClient::Preconditions.assert_class('multipleOf', x, Integer))
            end

            def to_json
              JSON.dump(to_hash)
            end

            def copy(incoming={})
              Items.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
            end

            def to_hash
              {
                :type => type.value,
                :format => format.nil? ? nil : format.value,
                :items => items.nil? ? nil : items.to_hash,
                :collectionFormat => collectionFormat.nil? ? nil : collectionFormat.value,
                :default => default,
                :maximum => maximum,
                :exclusiveMaximum => exclusiveMaximum,
                :minimum => minimum,
                :exclusiveMinimum => exclusiveMinimum,
                :maxLength => maxLength,
                :minLength => minLength,
                :pattern => pattern,
                :maxItems => maxItems,
                :minItems => minItems,
                :uniqueItems => uniqueItems,
                :enum => enum.nil? ? nil : enum,
                :multipleOf => multipleOf
              }
            end

          end

          class License

            attr_reader :name, :url

            def initialize(incoming={})
              opts = HttpClient::Helper.symbolize_keys(incoming)
              HttpClient::Preconditions.require_keys(opts, [:name], 'License')
              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
              @url = (x = opts.delete(:url); x.nil? ? nil : HttpClient::Preconditions.assert_class('url', x, String))
            end

            def to_json
              JSON.dump(to_hash)
            end

            def copy(incoming={})
              License.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
            end

            def to_hash
              {
                :name => name,
                :url => url
              }
            end

          end

          class Operation

            attr_reader :tags, :summary, :description, :externalDocs, :operationId, :consumes, :produces, :parameters, :responses, :schemes, :deprecated, :security

            def initialize(incoming={})
              opts = HttpClient::Helper.symbolize_keys(incoming)
              HttpClient::Preconditions.require_keys(opts, [:responses], 'Operation')
              @tags = (x = opts.delete(:tags); x.nil? ? nil : HttpClient::Preconditions.assert_class('tags', x, Array).map { |v| HttpClient::Preconditions.assert_class('tags', v, String) })
              @summary = (x = opts.delete(:summary); x.nil? ? nil : HttpClient::Preconditions.assert_class('summary', x, String))
              @description = (x = opts.delete(:description); x.nil? ? nil : HttpClient::Preconditions.assert_class('description', x, String))
              @externalDocs = (x = opts.delete(:externalDocs); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::ExternalDocumentation) ? x : ::Io::Apibuilder::Swagger::V0::Models::ExternalDocumentation.new(x)))
              @operationId = (x = opts.delete(:operationId); x.nil? ? nil : HttpClient::Preconditions.assert_class('operationId', x, String))
              @consumes = (x = opts.delete(:consumes); x.nil? ? nil : HttpClient::Preconditions.assert_class('consumes', x, Array).map { |v| HttpClient::Preconditions.assert_class('consumes', v, String) })
              @produces = (x = opts.delete(:produces); x.nil? ? nil : HttpClient::Preconditions.assert_class('produces', x, Array).map { |v| HttpClient::Preconditions.assert_class('produces', v, String) })
              @parameters = (x = opts.delete(:parameters); x.nil? ? nil : HttpClient::Preconditions.assert_class('parameters', x, Array).map { |v| (x = v; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::ParameterOrRef) ? x : ::Io::Apibuilder::Swagger::V0::Models::ParameterOrRef.from_json(x)) })
              @responses = HttpClient::Preconditions.assert_class('responses', opts.delete(:responses), Hash).inject({}) { |h, d| h[d[0]] = (x = d[1]; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::ResponseOrRef) ? x : ::Io::Apibuilder::Swagger::V0::Models::ResponseOrRef.from_json(x)); h }
              @schemes = (x = opts.delete(:schemes); x.nil? ? nil : HttpClient::Preconditions.assert_class('schemes', x, Array).map { |v| HttpClient::Preconditions.assert_class('schemes', v, String) })
              @deprecated = (x = opts.delete(:deprecated); x.nil? ? nil : HttpClient::Preconditions.assert_boolean('deprecated', x))
              @security = (x = opts.delete(:security); x.nil? ? nil : HttpClient::Preconditions.assert_class('security', x, Array).map { |v| HttpClient::Preconditions.assert_class('security', v, Hash).inject({}) { |h, d| h[d[0]] = HttpClient::Preconditions.assert_class('security', d[1], Array).map { |v| HttpClient::Preconditions.assert_class('security', v, String) }; h } })
            end

            def to_json
              JSON.dump(to_hash)
            end

            def copy(incoming={})
              Operation.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
            end

            def to_hash
              {
                :tags => tags.nil? ? nil : tags,
                :summary => summary,
                :description => description,
                :externalDocs => externalDocs.nil? ? nil : externalDocs.to_hash,
                :operationId => operationId,
                :consumes => consumes.nil? ? nil : consumes,
                :produces => produces.nil? ? nil : produces,
                :parameters => parameters.nil? ? nil : parameters.map { |o| o.to_hash },
                :responses => responses.inject({}) { |hash, o| hash[o[0]] = o[1].nil? ? nil : o[1].to_hash; hash },
                :schemes => schemes.nil? ? nil : schemes,
                :deprecated => deprecated,
                :security => security.nil? ? nil : security.map { |o| o.inject({}) { |hash, o| hash[o[0]] = o[1].nil? ? nil : o[1]; hash } }
              }
            end

          end

          # TODO: This might need to be a complex union type, given the different
          # requirements based on the 'in' property.
          # http://swagger.io/specification/#parameterObject
          class Parameter < ParameterOrRef

            attr_reader :name, :in, :description, :required, :schema, :type, :format, :allowEmptyValue, :items, :collectionFormat, :default, :maximum, :exclusiveMaximum, :minimum, :exclusiveMinimum, :maxLength, :minLength, :pattern, :maxItems, :minItems, :uniqueItems, :enum, :multipleOf

            def initialize(incoming={})
              super(:__discriminator__ => ParameterOrRef::Types::PARAMETER)
              opts = HttpClient::Helper.symbolize_keys(incoming)
              HttpClient::Preconditions.require_keys(opts, [:name, :in, :required], 'Parameter')
              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
              @in = (x = opts.delete(:in); x.is_a?(::Io::Apibuilder::Swagger::V0::Models::ParameterInType) ? x : ::Io::Apibuilder::Swagger::V0::Models::ParameterInType.apply(x))
              @description = (x = opts.delete(:description); x.nil? ? nil : HttpClient::Preconditions.assert_class('description', x, String))
              @required = HttpClient::Preconditions.assert_boolean('required', opts.delete(:required))
              @schema = (x = opts.delete(:schema); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::Schema) ? x : ::Io::Apibuilder::Swagger::V0::Models::Schema.new(x)))
              @type = (x = opts.delete(:type); x.nil? ? nil : HttpClient::Preconditions.assert_class('type', x, String))
              @format = (x = opts.delete(:format); x.nil? ? nil : HttpClient::Preconditions.assert_class('format', x, String))
              @allowEmptyValue = (x = opts.delete(:allowEmptyValue); x.nil? ? nil : HttpClient::Preconditions.assert_boolean('allowEmptyValue', x))
              @items = (x = opts.delete(:items); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::Items) ? x : ::Io::Apibuilder::Swagger::V0::Models::Items.new(x)))
              @collectionFormat = (x = opts.delete(:collectionFormat); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::CollectionFormatType) ? x : ::Io::Apibuilder::Swagger::V0::Models::CollectionFormatType.apply(x)))
              @default = (x = opts.delete(:default); x.nil? ? nil : HttpClient::Preconditions.assert_class('default', HttpClient::Helper.to_object(x), Hash))
              @maximum = (x = opts.delete(:maximum); x.nil? ? nil : HttpClient::Preconditions.assert_class('maximum', x, Integer))
              @exclusiveMaximum = (x = opts.delete(:exclusiveMaximum); x.nil? ? nil : HttpClient::Preconditions.assert_boolean('exclusiveMaximum', x))
              @minimum = (x = opts.delete(:minimum); x.nil? ? nil : HttpClient::Preconditions.assert_class('minimum', x, Integer))
              @exclusiveMinimum = (x = opts.delete(:exclusiveMinimum); x.nil? ? nil : HttpClient::Preconditions.assert_boolean('exclusiveMinimum', x))
              @maxLength = (x = opts.delete(:maxLength); x.nil? ? nil : HttpClient::Preconditions.assert_class('maxLength', x, Integer))
              @minLength = (x = opts.delete(:minLength); x.nil? ? nil : HttpClient::Preconditions.assert_class('minLength', x, Integer))
              @pattern = (x = opts.delete(:pattern); x.nil? ? nil : HttpClient::Preconditions.assert_class('pattern', x, String))
              @maxItems = (x = opts.delete(:maxItems); x.nil? ? nil : HttpClient::Preconditions.assert_class('maxItems', x, Integer))
              @minItems = (x = opts.delete(:minItems); x.nil? ? nil : HttpClient::Preconditions.assert_class('minItems', x, Integer))
              @uniqueItems = (x = opts.delete(:uniqueItems); x.nil? ? nil : HttpClient::Preconditions.assert_boolean('uniqueItems', x))
              @enum = (x = opts.delete(:enum); x.nil? ? nil : HttpClient::Preconditions.assert_class('enum', x, Array).map { |v| HttpClient::Preconditions.assert_class('enum', HttpClient::Helper.to_object(v), Hash) })
              @multipleOf = (x = opts.delete(:multipleOf); x.nil? ? nil : HttpClient::Preconditions.assert_class('multipleOf', x, Integer))
            end

            def to_json
              JSON.dump(to_hash)
            end

            def copy(incoming={})
              Parameter.new(subtype_to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
            end

            def subtype_to_hash
              {
                :name => name,
                :in => in.value,
                :description => description,
                :required => required,
                :schema => schema.nil? ? nil : schema.to_hash,
                :type => type,
                :format => format,
                :allowEmptyValue => allowEmptyValue,
                :items => items.nil? ? nil : items.to_hash,
                :collectionFormat => collectionFormat.nil? ? nil : collectionFormat.value,
                :default => default,
                :maximum => maximum,
                :exclusiveMaximum => exclusiveMaximum,
                :minimum => minimum,
                :exclusiveMinimum => exclusiveMinimum,
                :maxLength => maxLength,
                :minLength => minLength,
                :pattern => pattern,
                :maxItems => maxItems,
                :minItems => minItems,
                :uniqueItems => uniqueItems,
                :enum => enum.nil? ? nil : enum,
                :multipleOf => multipleOf
              }
            end

          end

          class PathItem

            attr_reader :ref, :get, :put, :post, :delete, :options, :head, :patch, :parameters

            def initialize(incoming={})
              opts = HttpClient::Helper.symbolize_keys(incoming)
              @ref = (x = opts.delete(:ref); x.nil? ? nil : HttpClient::Preconditions.assert_class('ref', x, String))
              @get = (x = opts.delete(:get); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::Operation) ? x : ::Io::Apibuilder::Swagger::V0::Models::Operation.new(x)))
              @put = (x = opts.delete(:put); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::Operation) ? x : ::Io::Apibuilder::Swagger::V0::Models::Operation.new(x)))
              @post = (x = opts.delete(:post); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::Operation) ? x : ::Io::Apibuilder::Swagger::V0::Models::Operation.new(x)))
              @delete = (x = opts.delete(:delete); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::Operation) ? x : ::Io::Apibuilder::Swagger::V0::Models::Operation.new(x)))
              @options = (x = opts.delete(:options); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::Operation) ? x : ::Io::Apibuilder::Swagger::V0::Models::Operation.new(x)))
              @head = (x = opts.delete(:head); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::Operation) ? x : ::Io::Apibuilder::Swagger::V0::Models::Operation.new(x)))
              @patch = (x = opts.delete(:patch); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::Operation) ? x : ::Io::Apibuilder::Swagger::V0::Models::Operation.new(x)))
              @parameters = (x = opts.delete(:parameters); x.nil? ? nil : HttpClient::Preconditions.assert_class('parameters', x, Array).map { |v| (x = v; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::ParameterOrRef) ? x : ::Io::Apibuilder::Swagger::V0::Models::ParameterOrRef.from_json(x)) })
            end

            def to_json
              JSON.dump(to_hash)
            end

            def copy(incoming={})
              PathItem.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
            end

            def to_hash
              {
                :ref => ref,
                :get => get.nil? ? nil : get.to_hash,
                :put => put.nil? ? nil : put.to_hash,
                :post => post.nil? ? nil : post.to_hash,
                :delete => delete.nil? ? nil : delete.to_hash,
                :options => options.nil? ? nil : options.to_hash,
                :head => head.nil? ? nil : head.to_hash,
                :patch => patch.nil? ? nil : patch.to_hash,
                :parameters => parameters.nil? ? nil : parameters.map { |o| o.to_hash }
              }
            end

          end

          class Reference < ParameterOrRef

            attr_reader :ref

            def initialize(incoming={})
              super(:__discriminator__ => ParameterOrRef::Types::REFERENCE)
              opts = HttpClient::Helper.symbolize_keys(incoming)
              HttpClient::Preconditions.require_keys(opts, [:ref], 'Reference')
              @ref = HttpClient::Preconditions.assert_class('ref', opts.delete(:ref), String)
            end

            def to_json
              JSON.dump(to_hash)
            end

            def copy(incoming={})
              Reference.new(subtype_to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
            end

            def subtype_to_hash
              {
                :ref => ref
              }
            end

          end

          class Response < ResponseOrRef

            attr_reader :description, :schema, :headers, :examples

            def initialize(incoming={})
              super(:__discriminator__ => ResponseOrRef::Types::RESPONSE)
              opts = HttpClient::Helper.symbolize_keys(incoming)
              HttpClient::Preconditions.require_keys(opts, [:description], 'Response')
              @description = HttpClient::Preconditions.assert_class('description', opts.delete(:description), String)
              @schema = (x = opts.delete(:schema); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::Schema) ? x : ::Io::Apibuilder::Swagger::V0::Models::Schema.new(x)))
              @headers = (x = opts.delete(:headers); x.nil? ? nil : HttpClient::Preconditions.assert_class('headers', x, Hash).inject({}) { |h, d| h[d[0]] = (x = d[1]; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::Header) ? x : ::Io::Apibuilder::Swagger::V0::Models::Header.new(x)); h })
              @examples = (x = opts.delete(:examples); x.nil? ? nil : HttpClient::Preconditions.assert_class('examples', HttpClient::Helper.to_object(x), Hash))
            end

            def to_json
              JSON.dump(to_hash)
            end

            def copy(incoming={})
              Response.new(subtype_to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
            end

            def subtype_to_hash
              {
                :description => description,
                :schema => schema.nil? ? nil : schema.to_hash,
                :headers => headers.nil? ? nil : headers.inject({}) { |hash, o| hash[o[0]] = o[1].nil? ? nil : o[1].to_hash; hash },
                :examples => examples
              }
            end

          end

          class Schema

            attr_reader :ref, :format, :title, :description, :default, :multipleOf, :maximum, :exclusiveMaximum, :minimum, :exclusiveMinimum, :maxLength, :minLength, :pattern, :maxItems, :minItems, :uniqueItems, :maxProperties, :minProperties, :required, :enum, :type, :items, :allOf, :properties, :additionalProperties, :discriminator, :readOnly, :xml, :externalDocs, :example

            def initialize(incoming={})
              opts = HttpClient::Helper.symbolize_keys(incoming)
              @ref = (x = opts.delete(:ref); x.nil? ? nil : HttpClient::Preconditions.assert_class('ref', x, String))
              @format = (x = opts.delete(:format); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::FormatType) ? x : ::Io::Apibuilder::Swagger::V0::Models::FormatType.apply(x)))
              @title = (x = opts.delete(:title); x.nil? ? nil : HttpClient::Preconditions.assert_class('title', x, String))
              @description = (x = opts.delete(:description); x.nil? ? nil : HttpClient::Preconditions.assert_class('description', x, String))
              @default = (x = opts.delete(:default); x.nil? ? nil : HttpClient::Preconditions.assert_class('default', HttpClient::Helper.to_object(x), Hash))
              @multipleOf = (x = opts.delete(:multipleOf); x.nil? ? nil : HttpClient::Preconditions.assert_class('multipleOf', x, Integer))
              @maximum = (x = opts.delete(:maximum); x.nil? ? nil : HttpClient::Preconditions.assert_class('maximum', x, Integer))
              @exclusiveMaximum = (x = opts.delete(:exclusiveMaximum); x.nil? ? nil : HttpClient::Preconditions.assert_boolean('exclusiveMaximum', x))
              @minimum = (x = opts.delete(:minimum); x.nil? ? nil : HttpClient::Preconditions.assert_class('minimum', x, Integer))
              @exclusiveMinimum = (x = opts.delete(:exclusiveMinimum); x.nil? ? nil : HttpClient::Preconditions.assert_boolean('exclusiveMinimum', x))
              @maxLength = (x = opts.delete(:maxLength); x.nil? ? nil : HttpClient::Preconditions.assert_class('maxLength', x, Integer))
              @minLength = (x = opts.delete(:minLength); x.nil? ? nil : HttpClient::Preconditions.assert_class('minLength', x, Integer))
              @pattern = (x = opts.delete(:pattern); x.nil? ? nil : HttpClient::Preconditions.assert_class('pattern', x, String))
              @maxItems = (x = opts.delete(:maxItems); x.nil? ? nil : HttpClient::Preconditions.assert_class('maxItems', x, Integer))
              @minItems = (x = opts.delete(:minItems); x.nil? ? nil : HttpClient::Preconditions.assert_class('minItems', x, Integer))
              @uniqueItems = (x = opts.delete(:uniqueItems); x.nil? ? nil : HttpClient::Preconditions.assert_boolean('uniqueItems', x))
              @maxProperties = (x = opts.delete(:maxProperties); x.nil? ? nil : HttpClient::Preconditions.assert_class('maxProperties', x, Integer))
              @minProperties = (x = opts.delete(:minProperties); x.nil? ? nil : HttpClient::Preconditions.assert_class('minProperties', x, Integer))
              @required = (x = opts.delete(:required); x.nil? ? nil : HttpClient::Preconditions.assert_class('required', x, Array).map { |v| HttpClient::Preconditions.assert_class('required', v, String) })
              @enum = (x = opts.delete(:enum); x.nil? ? nil : HttpClient::Preconditions.assert_class('enum', x, Array).map { |v| HttpClient::Preconditions.assert_class('enum', HttpClient::Helper.to_object(v), Hash) })
              @type = (x = opts.delete(:type); x.nil? ? nil : HttpClient::Preconditions.assert_class('type', x, Array).map { |v| HttpClient::Preconditions.assert_class('type', v, String) })
              @items = (x = opts.delete(:items); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::Schema) ? x : ::Io::Apibuilder::Swagger::V0::Models::Schema.new(x)))
              @allOf = (x = opts.delete(:allOf); x.nil? ? nil : HttpClient::Preconditions.assert_class('allOf', x, Array).map { |v| (x = v; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::Schema) ? x : ::Io::Apibuilder::Swagger::V0::Models::Schema.new(x)) })
              @properties = (x = opts.delete(:properties); x.nil? ? nil : HttpClient::Preconditions.assert_class('properties', x, Hash).inject({}) { |h, d| h[d[0]] = (x = d[1]; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::Schema) ? x : ::Io::Apibuilder::Swagger::V0::Models::Schema.new(x)); h })
              @additionalProperties = (x = opts.delete(:additionalProperties); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::Schema) ? x : ::Io::Apibuilder::Swagger::V0::Models::Schema.new(x)))
              @discriminator = (x = opts.delete(:discriminator); x.nil? ? nil : HttpClient::Preconditions.assert_class('discriminator', x, String))
              @readOnly = (x = opts.delete(:readOnly); x.nil? ? nil : HttpClient::Preconditions.assert_boolean('readOnly', x))
              @xml = (x = opts.delete(:xml); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::Xml) ? x : ::Io::Apibuilder::Swagger::V0::Models::Xml.new(x)))
              @externalDocs = (x = opts.delete(:externalDocs); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::ExternalDocumentation) ? x : ::Io::Apibuilder::Swagger::V0::Models::ExternalDocumentation.new(x)))
              @example = (x = opts.delete(:example); x.nil? ? nil : HttpClient::Preconditions.assert_class('example', HttpClient::Helper.to_object(x), Hash))
            end

            def to_json
              JSON.dump(to_hash)
            end

            def copy(incoming={})
              Schema.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
            end

            def to_hash
              {
                :ref => ref,
                :format => format.nil? ? nil : format.value,
                :title => title,
                :description => description,
                :default => default,
                :multipleOf => multipleOf,
                :maximum => maximum,
                :exclusiveMaximum => exclusiveMaximum,
                :minimum => minimum,
                :exclusiveMinimum => exclusiveMinimum,
                :maxLength => maxLength,
                :minLength => minLength,
                :pattern => pattern,
                :maxItems => maxItems,
                :minItems => minItems,
                :uniqueItems => uniqueItems,
                :maxProperties => maxProperties,
                :minProperties => minProperties,
                :required => required.nil? ? nil : required,
                :enum => enum.nil? ? nil : enum,
                :type => type.nil? ? nil : type,
                :items => items.nil? ? nil : items.to_hash,
                :allOf => allOf.nil? ? nil : allOf.map { |o| o.to_hash },
                :properties => properties.nil? ? nil : properties.inject({}) { |hash, o| hash[o[0]] = o[1].nil? ? nil : o[1].to_hash; hash },
                :additionalProperties => additionalProperties.nil? ? nil : additionalProperties.to_hash,
                :discriminator => discriminator,
                :readOnly => readOnly,
                :xml => xml.nil? ? nil : xml.to_hash,
                :externalDocs => externalDocs.nil? ? nil : externalDocs.to_hash,
                :example => example
              }
            end

          end

          # TODO: Consider making this a union type of the three different schemes (and
          # their required fields)
          class SecurityScheme

            attr_reader :type, :description, :name, :in, :flow, :authorizationUrl, :tokenUrl, :scopes

            def initialize(incoming={})
              opts = HttpClient::Helper.symbolize_keys(incoming)
              HttpClient::Preconditions.require_keys(opts, [:type], 'SecurityScheme')
              @type = (x = opts.delete(:type); x.is_a?(::Io::Apibuilder::Swagger::V0::Models::SecuritySchemeType) ? x : ::Io::Apibuilder::Swagger::V0::Models::SecuritySchemeType.apply(x))
              @description = (x = opts.delete(:description); x.nil? ? nil : HttpClient::Preconditions.assert_class('description', x, String))
              @name = (x = opts.delete(:name); x.nil? ? nil : HttpClient::Preconditions.assert_class('name', x, String))
              @in = (x = opts.delete(:in); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::ApiKeyInType) ? x : ::Io::Apibuilder::Swagger::V0::Models::ApiKeyInType.apply(x)))
              @flow = (x = opts.delete(:flow); x.nil? ? nil : HttpClient::Preconditions.assert_class('flow', x, String))
              @authorizationUrl = (x = opts.delete(:authorizationUrl); x.nil? ? nil : HttpClient::Preconditions.assert_class('authorizationUrl', x, String))
              @tokenUrl = (x = opts.delete(:tokenUrl); x.nil? ? nil : HttpClient::Preconditions.assert_class('tokenUrl', x, String))
              @scopes = (x = opts.delete(:scopes); x.nil? ? nil : HttpClient::Preconditions.assert_class('scopes', x, Hash).inject({}) { |h, d| h[d[0]] = HttpClient::Preconditions.assert_class('scopes', d[1], String); h })
            end

            def to_json
              JSON.dump(to_hash)
            end

            def copy(incoming={})
              SecurityScheme.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
            end

            def to_hash
              {
                :type => type.value,
                :description => description,
                :name => name,
                :in => in.nil? ? nil : in.value,
                :flow => flow,
                :authorizationUrl => authorizationUrl,
                :tokenUrl => tokenUrl,
                :scopes => scopes.nil? ? nil : scopes
              }
            end

          end

          class Swagger

            attr_reader :swagger, :info, :host, :basePath, :schemes, :consumes, :produces, :paths, :definitions, :parameters, :responses, :securityDefinitions, :security, :tags, :externalDocs

            def initialize(incoming={})
              opts = HttpClient::Helper.symbolize_keys(incoming)
              HttpClient::Preconditions.require_keys(opts, [:swagger, :info, :paths], 'Swagger')
              @swagger = HttpClient::Preconditions.assert_class('swagger', opts.delete(:swagger), String)
              @info = (x = opts.delete(:info); x.is_a?(::Io::Apibuilder::Swagger::V0::Models::Info) ? x : ::Io::Apibuilder::Swagger::V0::Models::Info.new(x))
              @host = (x = opts.delete(:host); x.nil? ? nil : HttpClient::Preconditions.assert_class('host', x, String))
              @basePath = (x = opts.delete(:basePath); x.nil? ? nil : HttpClient::Preconditions.assert_class('basePath', x, String))
              @schemes = (x = opts.delete(:schemes); x.nil? ? nil : HttpClient::Preconditions.assert_class('schemes', x, Array).map { |v| HttpClient::Preconditions.assert_class('schemes', v, String) })
              @consumes = (x = opts.delete(:consumes); x.nil? ? nil : HttpClient::Preconditions.assert_class('consumes', x, Array).map { |v| HttpClient::Preconditions.assert_class('consumes', v, String) })
              @produces = (x = opts.delete(:produces); x.nil? ? nil : HttpClient::Preconditions.assert_class('produces', x, Array).map { |v| HttpClient::Preconditions.assert_class('produces', v, String) })
              @paths = HttpClient::Preconditions.assert_class('paths', opts.delete(:paths), Hash).inject({}) { |h, d| h[d[0]] = (x = d[1]; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::PathItem) ? x : ::Io::Apibuilder::Swagger::V0::Models::PathItem.new(x)); h }
              @definitions = (x = opts.delete(:definitions); x.nil? ? nil : HttpClient::Preconditions.assert_class('definitions', x, Hash).inject({}) { |h, d| h[d[0]] = (x = d[1]; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::Schema) ? x : ::Io::Apibuilder::Swagger::V0::Models::Schema.new(x)); h })
              @parameters = (x = opts.delete(:parameters); x.nil? ? nil : HttpClient::Preconditions.assert_class('parameters', x, Hash).inject({}) { |h, d| h[d[0]] = (x = d[1]; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::Parameter) ? x : ::Io::Apibuilder::Swagger::V0::Models::Parameter.new(x)); h })
              @responses = (x = opts.delete(:responses); x.nil? ? nil : HttpClient::Preconditions.assert_class('responses', x, Hash).inject({}) { |h, d| h[d[0]] = (x = d[1]; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::Response) ? x : ::Io::Apibuilder::Swagger::V0::Models::Response.new(x)); h })
              @securityDefinitions = (x = opts.delete(:securityDefinitions); x.nil? ? nil : HttpClient::Preconditions.assert_class('securityDefinitions', x, Hash).inject({}) { |h, d| h[d[0]] = (x = d[1]; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::SecurityScheme) ? x : ::Io::Apibuilder::Swagger::V0::Models::SecurityScheme.new(x)); h })
              @security = (x = opts.delete(:security); x.nil? ? nil : HttpClient::Preconditions.assert_class('security', x, Hash).inject({}) { |h, d| h[d[0]] = HttpClient::Preconditions.assert_class('security', d[1], String); h })
              @tags = (x = opts.delete(:tags); x.nil? ? nil : HttpClient::Preconditions.assert_class('tags', x, Array).map { |v| (x = v; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::Tag) ? x : ::Io::Apibuilder::Swagger::V0::Models::Tag.new(x)) })
              @externalDocs = (x = opts.delete(:externalDocs); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::ExternalDocumentation) ? x : ::Io::Apibuilder::Swagger::V0::Models::ExternalDocumentation.new(x)))
            end

            def to_json
              JSON.dump(to_hash)
            end

            def copy(incoming={})
              Swagger.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
            end

            def to_hash
              {
                :swagger => swagger,
                :info => info.to_hash,
                :host => host,
                :basePath => basePath,
                :schemes => schemes.nil? ? nil : schemes,
                :consumes => consumes.nil? ? nil : consumes,
                :produces => produces.nil? ? nil : produces,
                :paths => paths.inject({}) { |hash, o| hash[o[0]] = o[1].nil? ? nil : o[1].to_hash; hash },
                :definitions => definitions.nil? ? nil : definitions.inject({}) { |hash, o| hash[o[0]] = o[1].nil? ? nil : o[1].to_hash; hash },
                :parameters => parameters.nil? ? nil : parameters.inject({}) { |hash, o| hash[o[0]] = o[1].nil? ? nil : o[1].to_hash; hash },
                :responses => responses.nil? ? nil : responses.inject({}) { |hash, o| hash[o[0]] = o[1].nil? ? nil : o[1].to_hash; hash },
                :securityDefinitions => securityDefinitions.nil? ? nil : securityDefinitions.inject({}) { |hash, o| hash[o[0]] = o[1].nil? ? nil : o[1].to_hash; hash },
                :security => security.nil? ? nil : security,
                :tags => tags.nil? ? nil : tags.map { |o| o.to_hash },
                :externalDocs => externalDocs.nil? ? nil : externalDocs.to_hash
              }
            end

          end

          class Tag

            attr_reader :name, :description, :externalDocs

            def initialize(incoming={})
              opts = HttpClient::Helper.symbolize_keys(incoming)
              HttpClient::Preconditions.require_keys(opts, [:name], 'Tag')
              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
              @description = (x = opts.delete(:description); x.nil? ? nil : HttpClient::Preconditions.assert_class('description', x, String))
              @externalDocs = (x = opts.delete(:externalDocs); x.nil? ? nil : (x = x; x.is_a?(::Io::Apibuilder::Swagger::V0::Models::ExternalDocumentation) ? x : ::Io::Apibuilder::Swagger::V0::Models::ExternalDocumentation.new(x)))
            end

            def to_json
              JSON.dump(to_hash)
            end

            def copy(incoming={})
              Tag.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
            end

            def to_hash
              {
                :name => name,
                :description => description,
                :externalDocs => externalDocs.nil? ? nil : externalDocs.to_hash
              }
            end

          end

          class Xml

            attr_reader :name, :namespace, :prefix, :attribute, :wrapped

            def initialize(incoming={})
              opts = HttpClient::Helper.symbolize_keys(incoming)
              @name = (x = opts.delete(:name); x.nil? ? nil : HttpClient::Preconditions.assert_class('name', x, String))
              @namespace = (x = opts.delete(:namespace); x.nil? ? nil : HttpClient::Preconditions.assert_class('namespace', x, String))
              @prefix = (x = opts.delete(:prefix); x.nil? ? nil : HttpClient::Preconditions.assert_class('prefix', x, String))
              @attribute = (x = opts.delete(:attribute); x.nil? ? nil : HttpClient::Preconditions.assert_boolean('attribute', x))
              @wrapped = (x = opts.delete(:wrapped); x.nil? ? nil : HttpClient::Preconditions.assert_boolean('wrapped', x))
            end

            def to_json
              JSON.dump(to_hash)
            end

            def copy(incoming={})
              Xml.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
            end

            def to_hash
              {
                :name => name,
                :namespace => namespace,
                :prefix => prefix,
                :attribute => attribute,
                :wrapped => wrapped
              }
            end

          end

        end

        # ===== END OF SERVICE DEFINITION =====
        module HttpClient

          class HttpHandler

            # Returns a client instance to use
            #
            # @param base_uri The base URI for this API
            # @param path the Requested full http path (including any query strings)
            def instance(base_uri, path)
              raise "Override in subclass"
            end

          end

          class HttpHandlerInstance

            # Executes a request. The provided request object will be an
            # instance of Net::HTTP (e.g. Net::HTTP::Get)
            def execute(request)
              raise "Override in subclass"
            end

          end

          class DefaultHttpHandler < HttpHandler

            def instance(base_uri, path)
              DefaultHttpHandlerInstance.new(base_uri)
            end

          end

          class DefaultHttpHandlerInstance < HttpHandlerInstance

            attr_reader :client

            def initialize(base_uri)
              @base_uri = Preconditions.assert_class('base_uri', base_uri, URI)
              @client = Net::HTTP.new(@base_uri.host, @base_uri.port)
              if @base_uri.scheme == "https"
                configure_ssl
              end
            end

            def execute(request)
              response = begin
                           @client.request(request)
                         rescue SocketError => e
                           raise StandardError.new("Error accessing uri[#{full_uri(request.path)}]: #{e}")
                         end

              case response
              when Net::HTTPSuccess
                response.body
              else
                body = response.body rescue nil
                raise HttpClient::ServerError.new(response.code.to_i, response.message, :body => body, :uri => full_uri(request.path).to_s)
              end
            end

            def full_uri(path)
              path.start_with?(@base_uri.to_s) ? path : File.join(@base_uri.to_s, path)
            end

            # Called to configure SSL if the base uri requires it
            def configure_ssl
              @client.use_ssl = true
              @client.verify_mode = OpenSSL::SSL::VERIFY_PEER
              @client.cert_store = OpenSSL::X509::Store.new
              @client.cert_store.set_default_paths
            end

          end

          class Request

            attr_reader :base_uri, :path, :full_uri

            def initialize(http_handler, base_uri, path)
              @http_handler = http_handler
              @base_uri = Preconditions.assert_class('base_uri', base_uri, URI)
              @path = Preconditions.assert_class('path', path, String)
              @full_uri = @base_uri.to_s + @path
              @params = nil
              @body = nil
              @auth = nil
              @headers = {}
              @header_keys_lower_case = []
            end

            def with_header(name, value)
              Preconditions.check_not_blank('name', name, "Header name is required")
              Preconditions.check_not_blank('value', value, "Header value is required")
              Preconditions.check_state(!@headers.has_key?(name),
                                        "Duplicate header named[%s]" % name)
              @headers[name] = value
              @header_keys_lower_case << name.downcase
              self
            end

            def with_auth(auth)
              Preconditions.assert_class('auth', auth, HttpClient::Authorization)
              Preconditions.check_state(@auth.nil?, "auth previously set")

              if auth.scheme.name == AuthScheme::BASIC.name
                @auth = auth
              else
                raise "Auth Scheme[#{auth.scheme.name}] not supported"
              end
              self
            end

            def with_query(params)
              Preconditions.assert_class('params', params, Hash)
              Preconditions.check_state(@params.nil?, "Already have query parameters")
              @params = params
              self
            end

            # Wrapper to set Content-Type header to application/json and set
            # the provided json document as the body
            def with_json(json)
              @headers['Content-Type'] ||= 'application/json; charset=UTF-8'
              with_body(json)
            end

            def with_body(body)
              Preconditions.check_not_blank('body', body)
              @body = body
              self
            end

            def get(&block)
              do_request(Net::HTTP::Get, &block)
            end

            def delete(&block)
              do_request(Net::HTTP::Delete, &block)
            end

            def options(&block)
              do_request(Net::HTTP::Options, &block)
            end

            def post(&block)
              do_request(Net::HTTP::Post, &block)
            end

            def put(&block)
              do_request(Net::HTTP::Put, &block)
            end

            class PATCH < Net::HTTP::Put
              METHOD = "PATCH"
            end

            def patch(&block)
              do_request(PATCH, &block)
            end

            def do_request(klass)
              Preconditions.assert_class('klass', klass, Class)

              uri = @full_uri.dup
              if q = to_query(@params)
                uri += "?%s" % q
              end

              request = klass.send(:new, uri)

              # DEBUG curl = ['curl']
              # DEBUG if klass != Net::HTTP::Get
              # DEBUG  curl << "-X%s" % klass.name.split("::").last.upcase
              # DEBUG end

              if @body
                # DEBUG tmpfile = "/tmp/rest_client.tmp"
                # DEBUG File.open(tmpfile, "w") { |os| os << @body.to_s }
                # DEBUG curl << "-d@%s" % tmpfile
                request.body = @body
              end

              if @auth
                # DEBUG curl << "-u \"%s:%s\"" % [@auth.username, @auth.password]
                Preconditions.check_state(!@header_keys_lower_case.include?("authorization"),
                                          "Cannot specify both an Authorization header and an auth instance")
                user_pass = "%s:%s" % [@auth.username, @auth.password]
                encoded = Base64.encode64(user_pass).to_s.split("\n").map(&:strip).join
                request.add_field("Authorization", "Basic %s" % encoded)
              end

              @headers.each { |key, value|
                # DEBUG curl <<  "-H \"%s: %s\"" % [key, value]
                request.add_field(key, value)
              }

              # DEBUG curl << "'%s%s'" % [@base_uri, path]
              # DEBUG puts curl.join(" ")

              raw_response = @http_handler.instance(@base_uri, request.path).execute(request)
              response = raw_response.to_s == "" ? nil : JSON.parse(raw_response)

              if block_given?
                yield response
              else
                response
              end
            end

            private
            def to_query(params={})
              parts = (params || {}).map { |k,v|
                if v.is_a?(Enumerable)
                  v.map { |el| "%s=%s" % [k, CGI.escape(el.to_s)] }
                else
                  "%s=%s" % [k, CGI.escape(v.to_s)]
                end
              }
              parts.empty? ? nil : parts.join("&")
            end

          end

          class ServerError < StandardError

            attr_reader :code, :details, :body, :uri

            def initialize(code, details, incoming={})
              opts = HttpClient::Helper.symbolize_keys(incoming)
              @code = HttpClient::Preconditions.assert_class('code', code, Integer)
              @details = HttpClient::Preconditions.assert_class('details', details, String)
              @body = HttpClient::Preconditions.assert_class_or_nil('body', opts.delete(:body), String)
              @uri = HttpClient::Preconditions.assert_class_or_nil('uri', opts.delete(:uri), String)
              HttpClient::Preconditions.assert_empty_opts(opts)
              super(self.message)
            end

            def message
              m = "%s %s" % [@code, @details]
              if @body
                m << ": %s" % @body
              end
              m
            end

            def body_json
              @body ? JSON.parse(@body) : nil
            end

          end

          class PreconditionException < StandardError

            attr_reader :message

            def initialize(message)
              super(message)
              @message = message
            end

          end

          module Preconditions

            def Preconditions.check_argument(expression, error_message=nil)
              if !expression
                raise PreconditionException.new(error_message || "check_argument failed")
              end
              nil
            end

            def Preconditions.check_state(expression, error_message=nil)
              if !expression
                raise PreconditionException.new(error_message || "check_state failed")
              end
              nil
            end

            def Preconditions.check_not_nil(field_name, reference, error_message=nil)
              if reference.nil?
                raise PreconditionException.new(error_message || "argument for %s cannot be nil" % field_name)
              end
              reference
            end

            def Preconditions.check_not_blank(field_name, reference, error_message=nil)
              if reference.to_s.strip == ""
                raise PreconditionException.new(error_message || "argument for %s cannot be blank" % field_name)
              end
              reference
            end

            # Throws an error if opts is not empty. Useful when parsing
            # arguments to a function
            def Preconditions.assert_empty_opts(opts)
              if !opts.empty?
                raise PreconditionException.new("Invalid opts: #{opts.keys.inspect}\n#{opts.inspect}")
              end
            end

            # Requires that the provided hash has the specified keys.
            # @param fields A list of symbols
            def Preconditions.require_keys(hash, fields, error_prefix=nil)
              missing = fields.select { |f| !hash.has_key?(f) }
              if !missing.empty?
                msg = "Missing required fields: " + missing.join(", ")
                raise PreconditionException.new(error_prefix.empty? ? msg : "#{error_prefix}: #{msg}")
              end
            end

            # Asserts that value is not nill and is_?(klass). Returns
            # value. Common use is
            #
            # amount = Preconditions.assert_class('amount', amount, BigDecimal)
            def Preconditions.assert_class(field_name, value, klass)
              Preconditions.check_not_nil('field_name', field_name)
              Preconditions.check_not_nil('klass', klass)
              Preconditions.check_not_nil('value', value, "Value for %s cannot be nil. Expected an instance of class %s" % [field_name, klass.name])
              Preconditions.check_state(value.is_a?(klass),
                                        "Value for #{field_name} is of type[#{value.class}] - class[#{klass}] is required. value[#{value.inspect.to_s}]")
              value
            end

            def Preconditions.assert_class_or_nil(field_name, value, klass)
              if !value.nil?
                Preconditions.assert_class(field_name, value, klass)
              end
            end

            def Preconditions.assert_boolean(field_name, value)
              Preconditions.check_not_nil('field_name', field_name)
              Preconditions.check_not_nil('value', value, "Value for %s cannot be nil. Expected an instance of TrueClass or FalseClass" % field_name)
              Preconditions.check_state(value.is_a?(TrueClass) || value.is_a?(FalseClass),
                                        "Value for #{field_name} is of type[#{value.class}] - class[TrueClass or FalseClass] is required. value[#{value.inspect.to_s}]")
              value
            end

            def Preconditions.assert_boolean_or_nil(field_name, value)
              if !value.nil?
                Preconditions.assert_boolean(field_name, value)
              end
            end

            def Preconditions.assert_collection_of_class(field_name, values, klass)
              Preconditions.assert_class(field_name, values, Array)
              values.each { |v| Preconditions.assert_class(field_name, v, klass) }
            end

            def Preconditions.assert_hash_of_class(field_name, hash, klass)
              Preconditions.assert_class(field_name, hash, Hash)
              values.each { |k, v| Preconditions.assert_class(field_name, v, klass) }
            end

          end

          class AuthScheme

            attr_reader :name

            def initialize(name)
              @name = HttpClient::Preconditions.check_not_blank('name', name)
            end

            BASIC = AuthScheme.new("basic") unless defined?(BASIC)

          end

          class Authorization

            attr_reader :scheme, :username, :password

            def initialize(scheme, username, opts={})
              @scheme = HttpClient::Preconditions.assert_class('schema', scheme, AuthScheme)
              @username = HttpClient::Preconditions.check_not_blank('username', username, "username is required")
              @password = HttpClient::Preconditions.assert_class_or_nil('password', opts.delete(:password), String)
              HttpClient::Preconditions.assert_empty_opts(opts)
            end

            def Authorization.basic(username, password=nil)
              Authorization.new(AuthScheme::BASIC, username, :password => password)
            end

          end

          module Helper

            def Helper.symbolize_keys(hash)
              Preconditions.assert_class('hash', hash, Hash)
              new_hash = {}
              hash.each { |k, v|
                new_hash[k.to_sym] = v
              }
              new_hash
            end

            def Helper.to_big_decimal(value)
              value ? BigDecimal(value.to_s) : nil
            end

            def Helper.to_object(value)
              value ? (value.is_a?(Hash) ? value : JSON.parse(value)) : nil
            end

            def Helper.to_uuid(value)
              Preconditions.check_state(value.nil? || value.match(/^\w\w\w\w\w\w\w\w\-\w\w\w\w\-\w\w\w\w\-\w\w\w\w\-\w\w\w\w\w\w\w\w\w\w\w\w$/),
                                        "Invalid guid[%s]" % value)
              value
            end

            def Helper.to_date_iso8601(value)
              if value.is_a?(Date)
                value
              elsif value
                Date.parse(value.to_s)
              else
                nil
              end
            end

            def Helper.to_date_time_iso8601(value)
              if value.is_a?(DateTime)
                value
              elsif value
                DateTime.parse(value.to_s)
              else
                nil
              end
            end

            def Helper.date_iso8601_to_string(value)
              value.nil? ? nil : value.strftime('%Y-%m-%d')
            end

            def Helper.date_time_iso8601_to_string(value)
              value.nil? ? nil : value.strftime('%Y-%m-%dT%H:%M:%S%z')
            end

            TRUE_STRINGS = ['t', 'true', 'y', 'yes', 'on', '1', 'trueclass'] unless defined?(TRUE_STRINGS)
            FALSE_STRINGS = ['f', 'false', 'n', 'no', 'off', '0', 'falseclass'] unless defined?(FALSE_STRINGS)

            def Helper.to_boolean(field_name, value)
              string = value.to_s.strip.downcase
              if TRUE_STRINGS.include?(string)
                true
              elsif FALSE_STRINGS.include?(string)
                false
              elsif string != ""
                raise PreconditionException.new("Unsupported boolean value[#{string}]. For true, must be one of: #{TRUE_STRINGS.inspect}. For false, must be one of: #{FALSE_STRINGS.inspect}")
              else
                nil
              end
            end

          end

        end
      end
    end
  end
end