RubyGems - flowcommerce - Versions diffs - 0.0.12 → 0.0.13 - Mend

flowcommerce 0.0.12 → 0.0.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

checksums.yaml +4 -4
data/lib/flow_commerce/client.rb +6 -37
data/lib/flow_commerce/flow_api_v0_client.rb +12379 -0
data/lib/flowcommerce.rb +1 -4
metadata +3 -5
data/lib/clients/flow_catalog_v0_client.rb +0 -2264
data/lib/clients/flow_common_v0_client.rb +0 -1762
data/lib/clients/flow_experience_v0_client.rb +0 -1044

data/lib/clients/flow_common_v0_client.rb DELETED

@@ -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