flowcommerce 0.0.2

data/lib/clients/flow_common_v0_client.rb

@@ -0,0 +1,1449 @@
+# Generated by apidoc - http://www.apidoc.me
+# Service version: 0.0.11
+# apidoc:0.11.17 http://www.apidoc.me/flow/common/0.0.11/ruby_client
+
+require 'cgi'
+require 'net/http'
+require 'net/https'
+require 'uri'
+require 'base64'
+
+require 'date'
+require 'rubygems'
+require 'json'
+require 'bigdecimal'
+
+module Io
+  module Flow
+    module Common
+      module V0
+
+        class Client
+
+          module Constants
+
+            NAMESPACE = 'io.flow.common.v0' unless defined?(Constants::NAMESPACE)
+            USER_AGENT = 'apidoc:0.11.17 http://www.apidoc.me/flow/common/0.0.11/ruby_client' unless defined?(Constants::USER_AGENT)
+            VERSION = '0.0.11' 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
+
+          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
+
+
+        end
+
+        module Clients
+
+
+
+        end
+
+        module Models
+
+          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, Calendar.unknown]
+            end
+
+            # Mon - Fri
+            def Calendar.weekdays
+              @@_weekdays ||= Calendar.new('Weekdays')
+            end
+
+            # 7 days per week
+            def Calendar.everyday
+              @@_everyday ||= Calendar.new('Everyday')
+            end
+
+            # We do not yet know the calendar
+            def Calendar.unknown
+              @@_unknown ||= Calendar.new('Unknown')
+            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 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 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 address to be used in user/form input. Either
+          # text or the structured input needs to be present.
+          class Address
+
+            attr_reader :text, :streets, :city, :province, :postal_code, :country
+
+            def initialize(incoming={})
+              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_code = (x = opts.delete(:postal_code); x.nil? ? nil : HttpClient::Preconditions.assert_class('postal_code', 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={})
+              Address.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
+            end
+
+            def to_hash
+              {
+                :text => text,
+                :streets => streets.nil? ? nil : streets,
+                :city => city,
+                :province => province,
+                :postal_code => postal_code,
+                :country => country
+              }
+            end
+
+          end
+
+          class ChangeHeader
+
+            attr_reader :id, :timestamp, :type
+
+            def initialize(incoming={})
+              opts = HttpClient::Helper.symbolize_keys(incoming)
+              HttpClient::Preconditions.require_keys(opts, [:id, :timestamp, :type], 'ChangeHeader')
+              @id = HttpClient::Preconditions.assert_class('id', opts.delete(:id), String)
+              @timestamp = HttpClient::Preconditions.assert_class('timestamp', HttpClient::Helper.to_date_time_iso8601(opts.delete(:timestamp)), DateTime)
+              @type = (x = opts.delete(:type); x.is_a?(::Io::Flow::Common::V0::Models::ChangeType) ? x : ::Io::Flow::Common::V0::Models::ChangeType.apply(x))
+            end
+
+            def to_json
+              JSON.dump(to_hash)
+            end
+
+            def copy(incoming={})
+              ChangeHeader.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
+            end
+
+            def to_hash
+              {
+                :id => id,
+                :timestamp => timestamp,
+                :type => type.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 :value, :units
+
+            def initialize(incoming={})
+              opts = HttpClient::Helper.symbolize_keys(incoming)
+              HttpClient::Preconditions.require_keys(opts, [:value, :units], 'Dimension')
+              @value = HttpClient::Preconditions.assert_class('value', opts.delete(:value), Float)
+              @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={})
+              Dimension.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
+            end
+
+            def to_hash
+              {
+                :value => value,
+                :units => units.value
+              }
+            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
+
+          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
+
+          # We capture the location as a string; over time we anticipate storing structued
+          # data by parsing the location (e.g. the country) to enable things like
+          # reporting, filtering in bulk
+          class Location
+
+            attr_reader :value
+
+            def initialize(incoming={})
+              opts = HttpClient::Helper.symbolize_keys(incoming)
+              HttpClient::Preconditions.require_keys(opts, [:value], 'Location')
+              @value = HttpClient::Preconditions.assert_class('value', opts.delete(:value), String)
+            end
+
+            def to_json
+              JSON.dump(to_hash)
+            end
+
+            def copy(incoming={})
+              Location.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
+            end
+
+            def to_hash
+              {
+                :value => 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
+
+          class Price
+
+            attr_reader :amount, :currency
+
+            def initialize(incoming={})
+              opts = HttpClient::Helper.symbolize_keys(incoming)
+              HttpClient::Preconditions.require_keys(opts, [:amount, :currency], 'Price')
+              @amount = HttpClient::Preconditions.assert_class('amount', opts.delete(:amount), String)
+              @currency = HttpClient::Preconditions.assert_class('currency', opts.delete(:currency), String)
+            end
+
+            def to_json
+              JSON.dump(to_hash)
+            end
+
+            def copy(incoming={})
+              Price.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
+            end
+
+            def to_hash
+              {
+                :amount => amount,
+                :currency => currency
+              }
+            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 HTTP is required, this method accepts an HTTP Client and configures SSL
+            def configure_ssl(client)
+              Preconditions.assert_class('client', client, Net::HTTP)
+              client.use_ssl = true
+              client.verify_mode = OpenSSL::SSL::VERIFY_PEER
+              client.cert_store = OpenSSL::X509::Store.new
+              client.cert_store.set_default_paths
+            end
+
+            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