flowcommerce 0.0.12 → 0.0.13

data/lib/clients/flow_common_v0_client.rb

@@ -1,1762 +0,0 @@
-# Generated by apidoc - http://www.apidoc.me
-# Service version: 0.0.36
-# apidoc:0.11.29 http://www.apidoc.me/flow/common/0.0.36/ruby_client
-
-require 'cgi'
-require 'net/http'
-require 'net/https'
-require 'uri'
-require 'base64'
-
-require 'date'
-require 'rubygems'
-require 'json'
-require 'bigdecimal'
-
-# The Flow Commerce REST API provides full access to the global ecommerce
-# platform.
-module Io
-  module Flow
-    module Common
-      module V0
-
-        class Client
-
-          module Constants
-
-            BASE_URL = 'https://api.flow.io' unless defined?(Constants::BASE_URL)
-            NAMESPACE = 'io.flow.common.v0' unless defined?(Constants::NAMESPACE)
-            USER_AGENT = 'apidoc:0.11.29 http://www.apidoc.me/flow/common/0.0.36/ruby_client' unless defined?(Constants::USER_AGENT)
-            VERSION = '0.0.36' 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)
-            @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)
-            HttpClient::Preconditions.assert_empty_opts(opts)
-            HttpClient::Preconditions.check_state(url.match(/http.+/i), "URL[%s] must start with http" % url)
-          end
-
-          # Creates an instance of the client using the base url specified in the API spec.
-          def Client.at_base_url(opts={})
-            Client.new(Constants::BASE_URL, opts)
-          end
-
-          def request(path=nil)
-            HttpClient::Preconditions.assert_class_or_nil('path', path, String)
-            request = HttpClient::Request.new(URI.parse(@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
-
-          def healthchecks
-            @healthchecks ||= ::Io::Flow::Common::V0::Clients::Healthchecks.new(self)
-          end
-        end
-
-        module Clients
-
-          class Healthchecks
-
-            def initialize(client)
-              @client = HttpClient::Preconditions.assert_class('client', client, ::Io::Flow::Common::V0::Client)
-            end
-
-            def get_healthcheck
-              r = @client.request("/_internal_/healthcheck").get
-              ::Io::Flow::Common::V0::Models::Healthcheck.new(r)
-            end
-
-          end
-
-        end
-
-        module Models
-
-          class ExpandableLocation
-
-            module Types
-              LOCATION = 'location' unless defined?(LOCATION)
-              LOCATION_REFERENCE = 'location_reference' unless defined?(LOCATION_REFERENCE)
-            end
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:name], 'ExpandableLocation')
-              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
-            end
-
-            def to_hash
-              subtype_to_hash.merge(:discriminator => @name)
-            end
-
-            def ExpandableLocation.from_json(hash)
-              HttpClient::Preconditions.assert_class('hash', hash, Hash)
-              case HttpClient::Helper.symbolize_keys(hash)[:discriminator]
-                when Types::LOCATION; Location.new(hash)
-                when Types::LOCATION_REFERENCE; LocationReference.new(hash)
-                else ExpandableLocationUndefinedType.new(:name => union_type_name)
-              end
-            end
-
-          end
-
-          class ExpandableLocationUndefinedType < ExpandableLocation
-
-            attr_reader :name
-
-            def initialize(incoming={})
-              super(:name => 'undefined_type')
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), 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 ExpandableOrganization
-
-            module Types
-              ORGANIZATION = 'organization' unless defined?(ORGANIZATION)
-              ORGANIZATION_REFERENCE = 'organization_reference' unless defined?(ORGANIZATION_REFERENCE)
-            end
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:name], 'ExpandableOrganization')
-              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
-            end
-
-            def to_hash
-              subtype_to_hash.merge(:discriminator => @name)
-            end
-
-            def ExpandableOrganization.from_json(hash)
-              HttpClient::Preconditions.assert_class('hash', hash, Hash)
-              case HttpClient::Helper.symbolize_keys(hash)[:discriminator]
-                when Types::ORGANIZATION; Organization.new(hash)
-                when Types::ORGANIZATION_REFERENCE; OrganizationReference.new(hash)
-                else ExpandableOrganizationUndefinedType.new(:name => union_type_name)
-              end
-            end
-
-          end
-
-          class ExpandableOrganizationUndefinedType < ExpandableOrganization
-
-            attr_reader :name
-
-            def initialize(incoming={})
-              super(:name => 'undefined_type')
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), 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 ExpandableUser
-
-            module Types
-              USER = 'user' unless defined?(USER)
-              USER_REFERENCE = 'user_reference' unless defined?(USER_REFERENCE)
-            end
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:name], 'ExpandableUser')
-              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
-            end
-
-            def to_hash
-              subtype_to_hash.merge(:discriminator => @name)
-            end
-
-            def ExpandableUser.from_json(hash)
-              HttpClient::Preconditions.assert_class('hash', hash, Hash)
-              case HttpClient::Helper.symbolize_keys(hash)[:discriminator]
-                when Types::USER; User.new(hash)
-                when Types::USER_REFERENCE; UserReference.new(hash)
-                else ExpandableUserUndefinedType.new(:name => union_type_name)
-              end
-            end
-
-          end
-
-          class ExpandableUserUndefinedType < ExpandableUser
-
-            attr_reader :name
-
-            def initialize(incoming={})
-              super(:name => 'undefined_type')
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), 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 Calendar
-
-            attr_reader :value
-
-            def initialize(value)
-              @value = HttpClient::Preconditions.assert_class('value', value, String)
-            end
-
-            # Returns the instance of Calendar for this value, creating a new instance for an unknown value
-            def Calendar.apply(value)
-              if value.instance_of?(Calendar)
-                value
-              else
-                HttpClient::Preconditions.assert_class_or_nil('value', value, String)
-                value.nil? ? nil : (from_string(value) || Calendar.new(value))
-              end
-            end
-
-            # Returns the instance of Calendar for this value, or nil if not found
-            def Calendar.from_string(value)
-              HttpClient::Preconditions.assert_class('value', value, String)
-              Calendar.ALL.find { |v| v.value == value }
-            end
-
-            def Calendar.ALL
-              @@all ||= [Calendar.weekdays, Calendar.everyday]
-            end
-
-            # Mon - Fri
-            def Calendar.weekdays
-              @@_weekdays ||= Calendar.new('weekdays')
-            end
-
-            # 7 days per week
-            def Calendar.everyday
-              @@_everyday ||= Calendar.new('everyday')
-            end
-
-            def to_hash
-              value
-            end
-
-          end
-
-          class Capability
-
-            attr_reader :value
-
-            def initialize(value)
-              @value = HttpClient::Preconditions.assert_class('value', value, String)
-            end
-
-            # Returns the instance of Capability for this value, creating a new instance for an unknown value
-            def Capability.apply(value)
-              if value.instance_of?(Capability)
-                value
-              else
-                HttpClient::Preconditions.assert_class_or_nil('value', value, String)
-                value.nil? ? nil : (from_string(value) || Capability.new(value))
-              end
-            end
-
-            # Returns the instance of Capability for this value, or nil if not found
-            def Capability.from_string(value)
-              HttpClient::Preconditions.assert_class('value', value, String)
-              Capability.ALL.find { |v| v.value == value }
-            end
-
-            def Capability.ALL
-              @@all ||= [Capability.crossdock]
-            end
-
-            def Capability.crossdock
-              @@_crossdock ||= Capability.new('crossdock')
-            end
-
-            def to_hash
-              value
-            end
-
-          end
-
-          class ChangeType
-
-            attr_reader :value
-
-            def initialize(value)
-              @value = HttpClient::Preconditions.assert_class('value', value, String)
-            end
-
-            # Returns the instance of ChangeType for this value, creating a new instance for an unknown value
-            def ChangeType.apply(value)
-              if value.instance_of?(ChangeType)
-                value
-              else
-                HttpClient::Preconditions.assert_class_or_nil('value', value, String)
-                value.nil? ? nil : (from_string(value) || ChangeType.new(value))
-              end
-            end
-
-            # Returns the instance of ChangeType for this value, or nil if not found
-            def ChangeType.from_string(value)
-              HttpClient::Preconditions.assert_class('value', value, String)
-              ChangeType.ALL.find { |v| v.value == value }
-            end
-
-            def ChangeType.ALL
-              @@all ||= [ChangeType.insert, ChangeType.update, ChangeType.delete]
-            end
-
-            def ChangeType.insert
-              @@_insert ||= ChangeType.new('insert')
-            end
-
-            def ChangeType.update
-              @@_update ||= ChangeType.new('update')
-            end
-
-            def ChangeType.delete
-              @@_delete ||= ChangeType.new('delete')
-            end
-
-            def to_hash
-              value
-            end
-
-          end
-
-          class DimensionType
-
-            attr_reader :value
-
-            def initialize(value)
-              @value = HttpClient::Preconditions.assert_class('value', value, String)
-            end
-
-            # Returns the instance of DimensionType for this value, creating a new instance for an unknown value
-            def DimensionType.apply(value)
-              if value.instance_of?(DimensionType)
-                value
-              else
-                HttpClient::Preconditions.assert_class_or_nil('value', value, String)
-                value.nil? ? nil : (from_string(value) || DimensionType.new(value))
-              end
-            end
-
-            # Returns the instance of DimensionType for this value, or nil if not found
-            def DimensionType.from_string(value)
-              HttpClient::Preconditions.assert_class('value', value, String)
-              DimensionType.ALL.find { |v| v.value == value }
-            end
-
-            def DimensionType.ALL
-              @@all ||= [DimensionType.product, DimensionType.package]
-            end
-
-            # The standalone dimensions of an item.
-            def DimensionType.product
-              @@_product ||= DimensionType.new('product')
-            end
-
-            # The boxed dimensions of an item.
-            def DimensionType.package
-              @@_package ||= DimensionType.new('package')
-            end
-
-            def to_hash
-              value
-            end
-
-          end
-
-          class ExceptionType
-
-            attr_reader :value
-
-            def initialize(value)
-              @value = HttpClient::Preconditions.assert_class('value', value, String)
-            end
-
-            # Returns the instance of ExceptionType for this value, creating a new instance for an unknown value
-            def ExceptionType.apply(value)
-              if value.instance_of?(ExceptionType)
-                value
-              else
-                HttpClient::Preconditions.assert_class_or_nil('value', value, String)
-                value.nil? ? nil : (from_string(value) || ExceptionType.new(value))
-              end
-            end
-
-            # Returns the instance of ExceptionType for this value, or nil if not found
-            def ExceptionType.from_string(value)
-              HttpClient::Preconditions.assert_class('value', value, String)
-              ExceptionType.ALL.find { |v| v.value == value }
-            end
-
-            def ExceptionType.ALL
-              @@all ||= [ExceptionType.open, ExceptionType.closed]
-            end
-
-            def ExceptionType.open
-              @@_open ||= ExceptionType.new('open')
-            end
-
-            def ExceptionType.closed
-              @@_closed ||= ExceptionType.new('closed')
-            end
-
-            def to_hash
-              value
-            end
-
-          end
-
-          class HolidayCalendar
-
-            attr_reader :value
-
-            def initialize(value)
-              @value = HttpClient::Preconditions.assert_class('value', value, String)
-            end
-
-            # Returns the instance of HolidayCalendar for this value, creating a new instance for an unknown value
-            def HolidayCalendar.apply(value)
-              if value.instance_of?(HolidayCalendar)
-                value
-              else
-                HttpClient::Preconditions.assert_class_or_nil('value', value, String)
-                value.nil? ? nil : (from_string(value) || HolidayCalendar.new(value))
-              end
-            end
-
-            # Returns the instance of HolidayCalendar for this value, or nil if not found
-            def HolidayCalendar.from_string(value)
-              HttpClient::Preconditions.assert_class('value', value, String)
-              HolidayCalendar.ALL.find { |v| v.value == value }
-            end
-
-            def HolidayCalendar.ALL
-              @@all ||= [HolidayCalendar.us_bank_holidays, HolidayCalendar.jewish_holidays]
-            end
-
-            def HolidayCalendar.us_bank_holidays
-              @@_us_bank_holidays ||= HolidayCalendar.new('us_bank_holidays')
-            end
-
-            def HolidayCalendar.jewish_holidays
-              @@_jewish_holidays ||= HolidayCalendar.new('jewish_holidays')
-            end
-
-            def to_hash
-              value
-            end
-
-          end
-
-          class ScheduleExceptionStatus
-
-            attr_reader :value
-
-            def initialize(value)
-              @value = HttpClient::Preconditions.assert_class('value', value, String)
-            end
-
-            # Returns the instance of ScheduleExceptionStatus for this value, creating a new instance for an unknown value
-            def ScheduleExceptionStatus.apply(value)
-              if value.instance_of?(ScheduleExceptionStatus)
-                value
-              else
-                HttpClient::Preconditions.assert_class_or_nil('value', value, String)
-                value.nil? ? nil : (from_string(value) || ScheduleExceptionStatus.new(value))
-              end
-            end
-
-            # Returns the instance of ScheduleExceptionStatus for this value, or nil if not found
-            def ScheduleExceptionStatus.from_string(value)
-              HttpClient::Preconditions.assert_class('value', value, String)
-              ScheduleExceptionStatus.ALL.find { |v| v.value == value }
-            end
-
-            def ScheduleExceptionStatus.ALL
-              @@all ||= [ScheduleExceptionStatus.open, ScheduleExceptionStatus.closed]
-            end
-
-            def ScheduleExceptionStatus.open
-              @@_open ||= ScheduleExceptionStatus.new('Open')
-            end
-
-            def ScheduleExceptionStatus.closed
-              @@_closed ||= ScheduleExceptionStatus.new('Closed')
-            end
-
-            def to_hash
-              value
-            end
-
-          end
-
-          class SortDirection
-
-            attr_reader :value
-
-            def initialize(value)
-              @value = HttpClient::Preconditions.assert_class('value', value, String)
-            end
-
-            # Returns the instance of SortDirection for this value, creating a new instance for an unknown value
-            def SortDirection.apply(value)
-              if value.instance_of?(SortDirection)
-                value
-              else
-                HttpClient::Preconditions.assert_class_or_nil('value', value, String)
-                value.nil? ? nil : (from_string(value) || SortDirection.new(value))
-              end
-            end
-
-            # Returns the instance of SortDirection for this value, or nil if not found
-            def SortDirection.from_string(value)
-              HttpClient::Preconditions.assert_class('value', value, String)
-              SortDirection.ALL.find { |v| v.value == value }
-            end
-
-            def SortDirection.ALL
-              @@all ||= [SortDirection.ascending, SortDirection.descending]
-            end
-
-            def SortDirection.ascending
-              @@_ascending ||= SortDirection.new('ascending')
-            end
-
-            def SortDirection.descending
-              @@_descending ||= SortDirection.new('descending')
-            end
-
-            def to_hash
-              value
-            end
-
-          end
-
-          class UnitOfMeasurement
-
-            attr_reader :value
-
-            def initialize(value)
-              @value = HttpClient::Preconditions.assert_class('value', value, String)
-            end
-
-            # Returns the instance of UnitOfMeasurement for this value, creating a new instance for an unknown value
-            def UnitOfMeasurement.apply(value)
-              if value.instance_of?(UnitOfMeasurement)
-                value
-              else
-                HttpClient::Preconditions.assert_class_or_nil('value', value, String)
-                value.nil? ? nil : (from_string(value) || UnitOfMeasurement.new(value))
-              end
-            end
-
-            # Returns the instance of UnitOfMeasurement for this value, or nil if not found
-            def UnitOfMeasurement.from_string(value)
-              HttpClient::Preconditions.assert_class('value', value, String)
-              UnitOfMeasurement.ALL.find { |v| v.value == value }
-            end
-
-            def UnitOfMeasurement.ALL
-              @@all ||= [UnitOfMeasurement.millimeter, UnitOfMeasurement.centimeter, UnitOfMeasurement.inch, UnitOfMeasurement.foot, UnitOfMeasurement.cubic_inch, UnitOfMeasurement.cubic_meter, UnitOfMeasurement.gram, UnitOfMeasurement.kilogram, UnitOfMeasurement.meter, UnitOfMeasurement.ounce, UnitOfMeasurement.pound]
-            end
-
-            # Equivalent to MILLI(METRE).
-            def UnitOfMeasurement.millimeter
-              @@_millimeter ||= UnitOfMeasurement.new('millimeter')
-            end
-
-            # Equivalent to CENTI(METRE).
-            def UnitOfMeasurement.centimeter
-              @@_centimeter ||= UnitOfMeasurement.new('centimeter')
-            end
-
-            # A unit of length equal to 0.01004 m (standard name in).
-            def UnitOfMeasurement.inch
-              @@_inch ||= UnitOfMeasurement.new('inch')
-            end
-
-            # A unit of length equal to 0.3048 m (standard name ft).
-            def UnitOfMeasurement.foot
-              @@_foot ||= UnitOfMeasurement.new('foot')
-            end
-
-            # A unit of volume equal to one cubic inch (in³).
-            def UnitOfMeasurement.cubic_inch
-              @@_cubic_inch ||= UnitOfMeasurement.new('cubic_inch')
-            end
-
-            # The metric unit for volume quantities (m³).
-            def UnitOfMeasurement.cubic_meter
-              @@_cubic_meter ||= UnitOfMeasurement.new('cubic_meter')
-            end
-
-            # A unit of mass equal to 1 / 1000 kilogram (standard name g).
-            def UnitOfMeasurement.gram
-              @@_gram ||= UnitOfMeasurement.new('gram')
-            end
-
-            # The base unit for mass quantities (kg).
-            def UnitOfMeasurement.kilogram
-              @@_kilogram ||= UnitOfMeasurement.new('kilogram')
-            end
-
-            # The base unit for length quantities (m).
-            def UnitOfMeasurement.meter
-              @@_meter ||= UnitOfMeasurement.new('meter')
-            end
-
-            # A unit of mass equal to 1 / 16 POUND (standard name oz).
-            def UnitOfMeasurement.ounce
-              @@_ounce ||= UnitOfMeasurement.new('ounce')
-            end
-
-            # A unit of mass equal to 453.59237 grams (avoirdupois pound, standard name lb).
-            def UnitOfMeasurement.pound
-              @@_pound ||= UnitOfMeasurement.new('pound')
-            end
-
-            def to_hash
-              value
-            end
-
-          end
-
-          class UnitOfTime
-
-            attr_reader :value
-
-            def initialize(value)
-              @value = HttpClient::Preconditions.assert_class('value', value, String)
-            end
-
-            # Returns the instance of UnitOfTime for this value, creating a new instance for an unknown value
-            def UnitOfTime.apply(value)
-              if value.instance_of?(UnitOfTime)
-                value
-              else
-                HttpClient::Preconditions.assert_class_or_nil('value', value, String)
-                value.nil? ? nil : (from_string(value) || UnitOfTime.new(value))
-              end
-            end
-
-            # Returns the instance of UnitOfTime for this value, or nil if not found
-            def UnitOfTime.from_string(value)
-              HttpClient::Preconditions.assert_class('value', value, String)
-              UnitOfTime.ALL.find { |v| v.value == value }
-            end
-
-            def UnitOfTime.ALL
-              @@all ||= [UnitOfTime.day, UnitOfTime.hour, UnitOfTime.minute]
-            end
-
-            def UnitOfTime.day
-              @@_day ||= UnitOfTime.new('day')
-            end
-
-            def UnitOfTime.hour
-              @@_hour ||= UnitOfTime.new('hour')
-            end
-
-            def UnitOfTime.minute
-              @@_minute ||= UnitOfTime.new('minute')
-            end
-
-            def to_hash
-              value
-            end
-
-          end
-
-          class ValueAddedService
-
-            attr_reader :value
-
-            def initialize(value)
-              @value = HttpClient::Preconditions.assert_class('value', value, String)
-            end
-
-            # Returns the instance of ValueAddedService for this value, creating a new instance for an unknown value
-            def ValueAddedService.apply(value)
-              if value.instance_of?(ValueAddedService)
-                value
-              else
-                HttpClient::Preconditions.assert_class_or_nil('value', value, String)
-                value.nil? ? nil : (from_string(value) || ValueAddedService.new(value))
-              end
-            end
-
-            # Returns the instance of ValueAddedService for this value, or nil if not found
-            def ValueAddedService.from_string(value)
-              HttpClient::Preconditions.assert_class('value', value, String)
-              ValueAddedService.ALL.find { |v| v.value == value }
-            end
-
-            def ValueAddedService.ALL
-              @@all ||= [ValueAddedService.hazardous_material]
-            end
-
-            # See https://en.wikipedia.org/wiki/ORM-D
-            def ValueAddedService.hazardous_material
-              @@_hazardous_material ||= ValueAddedService.new('Hazardous Material')
-            end
-
-            def to_hash
-              value
-            end
-
-          end
-
-          class Visibility
-
-            attr_reader :value
-
-            def initialize(value)
-              @value = HttpClient::Preconditions.assert_class('value', value, String)
-            end
-
-            # Returns the instance of Visibility for this value, creating a new instance for an unknown value
-            def Visibility.apply(value)
-              if value.instance_of?(Visibility)
-                value
-              else
-                HttpClient::Preconditions.assert_class_or_nil('value', value, String)
-                value.nil? ? nil : (from_string(value) || Visibility.new(value))
-              end
-            end
-
-            # Returns the instance of Visibility for this value, or nil if not found
-            def Visibility.from_string(value)
-              HttpClient::Preconditions.assert_class('value', value, String)
-              Visibility.ALL.find { |v| v.value == value }
-            end
-
-            def Visibility.ALL
-              @@all ||= [Visibility.public, Visibility.private]
-            end
-
-            def Visibility.public
-              @@_public ||= Visibility.new('public')
-            end
-
-            def Visibility.private
-              @@_private ||= Visibility.new('private')
-            end
-
-            def to_hash
-              value
-            end
-
-          end
-
-          # Defines structured fields for a contact person. Typically used for specifying
-          # contact person for an account, shipment, or organization representative
-          class Contact
-
-            attr_reader :name, :email, :phone
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:name], 'Contact')
-              @name = (x = opts.delete(:name); x.is_a?(::Io::Flow::Common::V0::Models::Name) ? x : ::Io::Flow::Common::V0::Models::Name.new(x))
-              @email = (x = opts.delete(:email); x.nil? ? nil : HttpClient::Preconditions.assert_class('email', x, String))
-              @phone = (x = opts.delete(:phone); x.nil? ? nil : HttpClient::Preconditions.assert_class('phone', 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.to_hash,
-                :email => email,
-                :phone => phone
-              }
-            end
-
-          end
-
-          class DatetimeRange
-
-            attr_reader :from, :to
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:from, :to], 'DatetimeRange')
-              @from = HttpClient::Preconditions.assert_class('from', HttpClient::Helper.to_date_time_iso8601(opts.delete(:from)), DateTime)
-              @to = HttpClient::Preconditions.assert_class('to', HttpClient::Helper.to_date_time_iso8601(opts.delete(:to)), DateTime)
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              DatetimeRange.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :from => from,
-                :to => to
-              }
-            end
-
-          end
-
-          class Dimension
-
-            attr_reader :type, :depth, :length, :weight, :width
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:type], 'Dimension')
-              @type = (x = opts.delete(:type); x.is_a?(::Io::Flow::Common::V0::Models::DimensionType) ? x : ::Io::Flow::Common::V0::Models::DimensionType.apply(x))
-              @depth = (x = opts.delete(:depth); x.nil? ? nil : (x = x; x.is_a?(::Io::Flow::Common::V0::Models::Measurement) ? x : ::Io::Flow::Common::V0::Models::Measurement.new(x)))
-              @length = (x = opts.delete(:length); x.nil? ? nil : (x = x; x.is_a?(::Io::Flow::Common::V0::Models::Measurement) ? x : ::Io::Flow::Common::V0::Models::Measurement.new(x)))
-              @weight = (x = opts.delete(:weight); x.nil? ? nil : (x = x; x.is_a?(::Io::Flow::Common::V0::Models::Measurement) ? x : ::Io::Flow::Common::V0::Models::Measurement.new(x)))
-              @width = (x = opts.delete(:width); x.nil? ? nil : (x = x; x.is_a?(::Io::Flow::Common::V0::Models::Measurement) ? x : ::Io::Flow::Common::V0::Models::Measurement.new(x)))
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              Dimension.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :type => type.value,
-                :depth => depth.nil? ? nil : depth.to_hash,
-                :length => length.nil? ? nil : length.to_hash,
-                :weight => weight.nil? ? nil : weight.to_hash,
-                :width => width.nil? ? nil : width.to_hash
-              }
-            end
-
-          end
-
-          class Error
-
-            attr_reader :code, :message
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:code, :message], 'Error')
-              @code = HttpClient::Preconditions.assert_class('code', opts.delete(:code), String)
-              @message = HttpClient::Preconditions.assert_class('message', opts.delete(:message), String)
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              Error.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :code => code,
-                :message => message
-              }
-            end
-
-          end
-
-          # Represents an exception to the schedule of a location.
-          class Exception
-
-            attr_reader :type, :datetime_range
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:type, :datetime_range], 'Exception')
-              @type = (x = opts.delete(:type); x.is_a?(::Io::Flow::Common::V0::Models::ExceptionType) ? x : ::Io::Flow::Common::V0::Models::ExceptionType.apply(x))
-              @datetime_range = (x = opts.delete(:datetime_range); x.is_a?(::Io::Flow::Common::V0::Models::DatetimeRange) ? x : ::Io::Flow::Common::V0::Models::DatetimeRange.new(x))
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              Exception.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :type => type.value,
-                :datetime_range => datetime_range.to_hash
-              }
-            end
-
-          end
-
-          # Some important fields related to experiences used in various APIs
-          class ExperienceSummary
-
-            attr_reader :id, :key, :name, :currency, :country
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:id, :key, :name], 'ExperienceSummary')
-              @id = HttpClient::Preconditions.assert_class('id', opts.delete(:id), String)
-              @key = HttpClient::Preconditions.assert_class('key', opts.delete(:key), String)
-              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
-              @currency = (x = opts.delete(:currency); x.nil? ? nil : HttpClient::Preconditions.assert_class('currency', x, String))
-              @country = (x = opts.delete(:country); x.nil? ? nil : HttpClient::Preconditions.assert_class('country', x, String))
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              ExperienceSummary.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :id => id,
-                :key => key,
-                :name => name,
-                :currency => currency,
-                :country => country
-              }
-            end
-
-          end
-
-          class Healthcheck
-
-            attr_reader :status
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:status], 'Healthcheck')
-              @status = HttpClient::Preconditions.assert_class('status', opts.delete(:status), String)
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              Healthcheck.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :status => status
-              }
-            end
-
-          end
-
-          # Defines structured fields for address to be used in user/form input. Either
-          # text or the structured input needs to be present.
-          class Location < ExpandableLocation
-
-            attr_reader :text, :streets, :city, :province, :postal, :country, :latitude, :longitude
-
-            def initialize(incoming={})
-              super(:name => ExpandableLocation::Types::LOCATION)
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              @text = (x = opts.delete(:text); x.nil? ? nil : HttpClient::Preconditions.assert_class('text', x, String))
-              @streets = (x = opts.delete(:streets); x.nil? ? nil : HttpClient::Preconditions.assert_class('streets', x, Array).map { |v| HttpClient::Preconditions.assert_class('streets', v, String) })
-              @city = (x = opts.delete(:city); x.nil? ? nil : HttpClient::Preconditions.assert_class('city', x, String))
-              @province = (x = opts.delete(:province); x.nil? ? nil : HttpClient::Preconditions.assert_class('province', x, String))
-              @postal = (x = opts.delete(:postal); x.nil? ? nil : HttpClient::Preconditions.assert_class('postal', x, String))
-              @country = (x = opts.delete(:country); x.nil? ? nil : HttpClient::Preconditions.assert_class('country', x, String))
-              @latitude = (x = opts.delete(:latitude); x.nil? ? nil : HttpClient::Preconditions.assert_class('latitude', x, String))
-              @longitude = (x = opts.delete(:longitude); x.nil? ? nil : HttpClient::Preconditions.assert_class('longitude', x, String))
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              Location.new(subtype_to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def subtype_to_hash
-              {
-                :text => text,
-                :streets => streets.nil? ? nil : streets,
-                :city => city,
-                :province => province,
-                :postal => postal,
-                :country => country,
-                :latitude => latitude,
-                :longitude => longitude
-              }
-            end
-
-          end
-
-          class LocationReference < ExpandableLocation
-
-            attr_reader :text
-
-            def initialize(incoming={})
-              super(:name => ExpandableLocation::Types::LOCATION_REFERENCE)
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              @text = (x = opts.delete(:text); x.nil? ? nil : HttpClient::Preconditions.assert_class('text', x, String))
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              LocationReference.new(subtype_to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def subtype_to_hash
-              {
-                :text => text
-              }
-            end
-
-          end
-
-          class Measurement
-
-            attr_reader :value, :units
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:value, :units], 'Measurement')
-              @value = HttpClient::Preconditions.assert_class('value', opts.delete(:value), String)
-              @units = (x = opts.delete(:units); x.is_a?(::Io::Flow::Common::V0::Models::UnitOfMeasurement) ? x : ::Io::Flow::Common::V0::Models::UnitOfMeasurement.apply(x))
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              Measurement.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :value => value,
-                :units => units.value
-              }
-            end
-
-          end
-
-          class Name
-
-            attr_reader :first, :last
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              @first = (x = opts.delete(:first); x.nil? ? nil : HttpClient::Preconditions.assert_class('first', x, String))
-              @last = (x = opts.delete(:last); x.nil? ? nil : HttpClient::Preconditions.assert_class('last', x, String))
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              Name.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :first => first,
-                :last => last
-              }
-            end
-
-          end
-
-          # Represents a single organization in the system
-          class Organization < ExpandableOrganization
-
-            attr_reader :id, :name
-
-            def initialize(incoming={})
-              super(:name => ExpandableOrganization::Types::ORGANIZATION)
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:id, :name], 'Organization')
-              @id = HttpClient::Preconditions.assert_class('id', opts.delete(:id), String)
-              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              Organization.new(subtype_to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def subtype_to_hash
-              {
-                :id => id,
-                :name => name
-              }
-            end
-
-          end
-
-          class OrganizationReference < ExpandableOrganization
-
-            attr_reader :id
-
-            def initialize(incoming={})
-              super(:name => ExpandableOrganization::Types::ORGANIZATION_REFERENCE)
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:id], 'OrganizationReference')
-              @id = HttpClient::Preconditions.assert_class('id', opts.delete(:id), String)
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              OrganizationReference.new(subtype_to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def subtype_to_hash
-              {
-                :id => id
-              }
-            end
-
-          end
-
-          class OrganizationSummary
-
-            attr_reader :id, :name
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:id, :name], 'OrganizationSummary')
-              @id = HttpClient::Preconditions.assert_class('id', opts.delete(:id), String)
-              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              OrganizationSummary.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :id => id,
-                :name => name
-              }
-            end
-
-          end
-
-          # Represents operating calendar and holidays of a location
-          class Schedule
-
-            attr_reader :calendar, :holiday, :exception, :cutoff
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:holiday, :exception], 'Schedule')
-              @calendar = (x = opts.delete(:calendar); x.nil? ? nil : (x = x; x.is_a?(::Io::Flow::Common::V0::Models::Calendar) ? x : ::Io::Flow::Common::V0::Models::Calendar.apply(x)))
-              @holiday = (x = opts.delete(:holiday); x.is_a?(::Io::Flow::Common::V0::Models::HolidayCalendar) ? x : ::Io::Flow::Common::V0::Models::HolidayCalendar.apply(x))
-              @exception = HttpClient::Preconditions.assert_class('exception', opts.delete(:exception), Array).map { |v| (x = v; x.is_a?(::Io::Flow::Common::V0::Models::Exception) ? x : ::Io::Flow::Common::V0::Models::Exception.new(x)) }
-              @cutoff = (x = opts.delete(:cutoff); x.nil? ? nil : HttpClient::Preconditions.assert_class('cutoff', x, String))
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              Schedule.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :calendar => calendar.nil? ? nil : calendar.value,
-                :holiday => holiday.value,
-                :exception => exception.map { |o| o.to_hash },
-                :cutoff => cutoff
-              }
-            end
-
-          end
-
-          # Represents a single user in the system
-          class User < ExpandableUser
-
-            attr_reader :id, :email, :name
-
-            def initialize(incoming={})
-              super(:name => ExpandableUser::Types::USER)
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:id, :name], 'User')
-              @id = HttpClient::Preconditions.assert_class('id', opts.delete(:id), String)
-              @email = (x = opts.delete(:email); x.nil? ? nil : HttpClient::Preconditions.assert_class('email', x, String))
-              @name = (x = opts.delete(:name); x.is_a?(::Io::Flow::Common::V0::Models::Name) ? x : ::Io::Flow::Common::V0::Models::Name.new(x))
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              User.new(subtype_to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def subtype_to_hash
-              {
-                :id => id,
-                :email => email,
-                :name => name.to_hash
-              }
-            end
-
-          end
-
-          class UserReference < ExpandableUser
-
-            attr_reader :id
-
-            def initialize(incoming={})
-              super(:name => ExpandableUser::Types::USER_REFERENCE)
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:id], 'UserReference')
-              @id = HttpClient::Preconditions.assert_class('id', opts.delete(:id), String)
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              UserReference.new(subtype_to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def subtype_to_hash
-              {
-                :id => id
-              }
-            end
-
-          end
-
-          class UserSummary
-
-            attr_reader :id, :email, :name
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:id, :name], 'UserSummary')
-              @id = HttpClient::Preconditions.assert_class('id', opts.delete(:id), String)
-              @email = (x = opts.delete(:email); x.nil? ? nil : HttpClient::Preconditions.assert_class('email', x, String))
-              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              UserSummary.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :id => id,
-                :email => email,
-                :name => name
-              }
-            end
-
-          end
-
-        end
-
-        # ===== END OF SERVICE DEFINITION =====
-        module HttpClient
-
-          class Request
-
-            def initialize(uri)
-              @uri = Preconditions.assert_class('uri', uri, URI)
-              @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
-
-            # Creates a new Net:HTTP client. The client returned should be
-            # fully configured to make a request.
-            def new_http_client
-              client = Net::HTTP.new(@uri.host, @uri.port)
-              if @uri.scheme == "https"
-                configure_ssl(client)
-              end
-              client
-            end
-
-            # If HTTPS is required, this method accepts an HTTP Client and configures SSL
-            def configure_ssl(http)
-              Preconditions.assert_class('http', http, Net::HTTP)
-              http.use_ssl = true
-              http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-              http.cert_store = OpenSSL::X509::Store.new
-              http.cert_store.set_default_paths
-            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 = @uri.to_s
-              if q = to_query(@params)
-                uri += "?%s" % q
-              end
-
-              request = klass.send(:new, uri)
-
-              curl = ['curl']
-              if klass != Net::HTTP::Get
-                curl << "-X%s" % klass.name.split("::").last.upcase
-              end
-
-              if @body
-                # DEBUG path = "/tmp/rest_client.tmp"
-                # DEBUG File.open(path, "w") { |os| os << @body.to_s }
-                # DEBUG curl << "-d@%s" % path
-                request.body = @body
-              end
-
-              if @auth
-                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|
-                curl <<  "-H \"%s: %s\"" % [key, value]
-                request.add_field(key, value)
-              }
-
-              curl << "'%s'" % uri
-              # DEBUG puts curl.join(" ")
-
-              raw_response = http_request(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.respond_to?(:each)
-                  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
-
-            def http_request(request)
-              response = begin
-                           new_http_client.request(request)
-                         rescue SocketError => e
-                           raise Exception.new("Error accessing uri[#{@uri}]: #{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 => @uri.to_s)
-              end
-            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
-              JSON.parse(@body)
-            end
-
-          end
-
-          class PreconditionException < Exception
-
-            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.new(value.to_s) : nil
-            end
-
-            def Helper.to_object(value)
-              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