flowcommerce 0.0.12 → 0.0.13

data/lib/clients/flow_experience_v0_client.rb

@@ -1,1044 +0,0 @@
-# Generated by apidoc - http://www.apidoc.me
-# Service version: 0.0.36
-# apidoc:0.11.29 http://www.apidoc.me/flow/experience/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'
-
-# An experience defines all of the configuration and settings that are relevant
-# to a particular country
-module Io
-  module Flow
-    module Experience
-      module V0
-
-        class Client
-
-          module Constants
-
-            BASE_URL = 'https://experience.api.flow.io' unless defined?(Constants::BASE_URL)
-            NAMESPACE = 'io.flow.experience.v0' unless defined?(Constants::NAMESPACE)
-            USER_AGENT = 'apidoc:0.11.29 http://www.apidoc.me/flow/experience/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 displays
-            @displays ||= ::Io::Flow::Experience::V0::Clients::Displays.new(self)
-          end
-
-          def experiences
-            @experiences ||= ::Io::Flow::Experience::V0::Clients::Experiences.new(self)
-          end
-        end
-
-        module Clients
-
-          class Displays
-
-            def initialize(client)
-              @client = HttpClient::Preconditions.assert_class('client', client, ::Io::Flow::Experience::V0::Client)
-            end
-
-            # Provides visibility into recent changes of each object, including deletion
-            def get_versions(organization, incoming={})
-              HttpClient::Preconditions.assert_class('organization', organization, String)
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              query = {
-                :id => (x = opts.delete(:id); x.nil? ? nil : HttpClient::Preconditions.assert_class('id', x, Array).map { |v| HttpClient::Preconditions.assert_class('id', v, String) }),
-                :key => (x = opts.delete(:key); x.nil? ? nil : HttpClient::Preconditions.assert_class('key', x, Array).map { |v| HttpClient::Preconditions.assert_class('key', v, String) }),
-                :name => (x = opts.delete(:name); x.nil? ? nil : HttpClient::Preconditions.assert_class('name', x, Array).map { |v| HttpClient::Preconditions.assert_class('name', v, String) }),
-                :limit => HttpClient::Preconditions.assert_class('limit', (x = opts.delete(:limit); x.nil? ? 25 : x), Integer),
-                :offset => HttpClient::Preconditions.assert_class('offset', (x = opts.delete(:offset); x.nil? ? 0 : x), Integer),
-                :sort => HttpClient::Preconditions.assert_class('sort', (x = opts.delete(:sort); x.nil? ? "journal_timestamp" : x), String)
-              }.delete_if { |k, v| v.nil? }
-              r = @client.request("/#{CGI.escape(organization)}/displays/versions").with_query(query).get
-              r.map { |x| ::Io::Flow::Experience::V0::Models::DisplayVersion.new(x) }
-            end
-
-            # Search displays. Always paginated.
-            def get(organization, incoming={})
-              HttpClient::Preconditions.assert_class('organization', organization, String)
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              query = {
-                :id => (x = opts.delete(:id); x.nil? ? nil : HttpClient::Preconditions.assert_class('id', x, Array).map { |v| HttpClient::Preconditions.assert_class('id', v, String) }),
-                :key => (x = opts.delete(:key); x.nil? ? nil : HttpClient::Preconditions.assert_class('key', x, Array).map { |v| HttpClient::Preconditions.assert_class('key', v, String) }),
-                :name => (x = opts.delete(:name); x.nil? ? nil : HttpClient::Preconditions.assert_class('name', x, Array).map { |v| HttpClient::Preconditions.assert_class('name', v, String) }),
-                :limit => HttpClient::Preconditions.assert_class('limit', (x = opts.delete(:limit); x.nil? ? 25 : x), Integer),
-                :offset => HttpClient::Preconditions.assert_class('offset', (x = opts.delete(:offset); x.nil? ? 0 : x), Integer),
-                :sort => HttpClient::Preconditions.assert_class('sort', (x = opts.delete(:sort); x.nil? ? "name" : x), String)
-              }.delete_if { |k, v| v.nil? }
-              r = @client.request("/#{CGI.escape(organization)}/displays").with_query(query).get
-              r.map { |x| ::Io::Flow::Experience::V0::Models::Display.new(x) }
-            end
-
-            # Returns information about a specific display.
-            def get_by_key(organization, key)
-              HttpClient::Preconditions.assert_class('organization', organization, String)
-              HttpClient::Preconditions.assert_class('key', key, String)
-              r = @client.request("/#{CGI.escape(organization)}/displays/#{CGI.escape(key)}").get
-              ::Io::Flow::Experience::V0::Models::Display.new(r)
-            end
-
-            # Add display
-            def post(organization, display_form)
-              HttpClient::Preconditions.assert_class('organization', organization, String)
-              HttpClient::Preconditions.assert_class('display_form', display_form, ::Io::Flow::Experience::V0::Models::DisplayForm)
-              r = @client.request("/#{CGI.escape(organization)}/displays").with_json(display_form.to_json).post
-              ::Io::Flow::Experience::V0::Models::Display.new(r)
-            end
-
-            # Update display with the specified key, creating if it does not exist.
-            def put_by_key(organization, key, display_form)
-              HttpClient::Preconditions.assert_class('organization', organization, String)
-              HttpClient::Preconditions.assert_class('key', key, String)
-              HttpClient::Preconditions.assert_class('display_form', display_form, ::Io::Flow::Experience::V0::Models::DisplayForm)
-              r = @client.request("/#{CGI.escape(organization)}/displays/#{CGI.escape(key)}").with_json(display_form.to_json).put
-              ::Io::Flow::Experience::V0::Models::Display.new(r)
-            end
-
-            # Delete the display with this key
-            def delete_by_key(organization, key)
-              HttpClient::Preconditions.assert_class('organization', organization, String)
-              HttpClient::Preconditions.assert_class('key', key, String)
-              r = @client.request("/#{CGI.escape(organization)}/displays/#{CGI.escape(key)}").delete
-              nil
-            end
-
-          end
-
-          class Experiences
-
-            def initialize(client)
-              @client = HttpClient::Preconditions.assert_class('client', client, ::Io::Flow::Experience::V0::Client)
-            end
-
-            # Provides visibility into recent changes of each object, including deletion
-            def get_versions(organization, incoming={})
-              HttpClient::Preconditions.assert_class('organization', organization, String)
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              query = {
-                :id => (x = opts.delete(:id); x.nil? ? nil : HttpClient::Preconditions.assert_class('id', x, Array).map { |v| HttpClient::Preconditions.assert_class('id', v, String) }),
-                :key => (x = opts.delete(:key); x.nil? ? nil : HttpClient::Preconditions.assert_class('key', x, Array).map { |v| HttpClient::Preconditions.assert_class('key', v, String) }),
-                :name => (x = opts.delete(:name); x.nil? ? nil : HttpClient::Preconditions.assert_class('name', x, Array).map { |v| HttpClient::Preconditions.assert_class('name', v, String) }),
-                :limit => HttpClient::Preconditions.assert_class('limit', (x = opts.delete(:limit); x.nil? ? 25 : x), Integer),
-                :offset => HttpClient::Preconditions.assert_class('offset', (x = opts.delete(:offset); x.nil? ? 0 : x), Integer),
-                :sort => HttpClient::Preconditions.assert_class('sort', (x = opts.delete(:sort); x.nil? ? "journal_timestamp" : x), String)
-              }.delete_if { |k, v| v.nil? }
-              r = @client.request("/#{CGI.escape(organization)}/experiences/versions").with_query(query).get
-              r.map { |x| ::Io::Flow::Experience::V0::Models::ExperienceVersion.new(x) }
-            end
-
-            # Search experiences. Always paginated.
-            def get(organization, incoming={})
-              HttpClient::Preconditions.assert_class('organization', organization, String)
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              query = {
-                :id => (x = opts.delete(:id); x.nil? ? nil : HttpClient::Preconditions.assert_class('id', x, Array).map { |v| HttpClient::Preconditions.assert_class('id', v, String) }),
-                :country => (x = opts.delete(:country); x.nil? ? nil : HttpClient::Preconditions.assert_class('country', x, Array).map { |v| HttpClient::Preconditions.assert_class('country', v, String) }),
-                :currency => (x = opts.delete(:currency); x.nil? ? nil : HttpClient::Preconditions.assert_class('currency', x, Array).map { |v| HttpClient::Preconditions.assert_class('currency', v, String) }),
-                :display => (x = opts.delete(:display); x.nil? ? nil : HttpClient::Preconditions.assert_class('display', x, Array).map { |v| HttpClient::Preconditions.assert_class('display', v, String) }),
-                :key => (x = opts.delete(:key); x.nil? ? nil : HttpClient::Preconditions.assert_class('key', x, Array).map { |v| HttpClient::Preconditions.assert_class('key', v, String) }),
-                :name => (x = opts.delete(:name); x.nil? ? nil : HttpClient::Preconditions.assert_class('name', x, Array).map { |v| HttpClient::Preconditions.assert_class('name', v, String) }),
-                :subcatalog => (x = opts.delete(:subcatalog); x.nil? ? nil : HttpClient::Preconditions.assert_class('subcatalog', x, Array).map { |v| HttpClient::Preconditions.assert_class('subcatalog', v, String) }),
-                :limit => HttpClient::Preconditions.assert_class('limit', (x = opts.delete(:limit); x.nil? ? 25 : x), Integer),
-                :offset => HttpClient::Preconditions.assert_class('offset', (x = opts.delete(:offset); x.nil? ? 0 : x), Integer),
-                :sort => HttpClient::Preconditions.assert_class('sort', (x = opts.delete(:sort); x.nil? ? "name" : x), String)
-              }.delete_if { |k, v| v.nil? }
-              r = @client.request("/#{CGI.escape(organization)}/experiences").with_query(query).get
-              r.map { |x| ::Io::Flow::Experience::V0::Models::Experience.new(x) }
-            end
-
-            # Compose items and prices. Always paginated.
-            def get_items(organization, incoming={})
-              HttpClient::Preconditions.assert_class('organization', organization, String)
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              query = {
-                :number => (x = opts.delete(:number); x.nil? ? nil : HttpClient::Preconditions.assert_class('number', x, Array).map { |v| HttpClient::Preconditions.assert_class('number', v, String) }),
-                :destination => (x = opts.delete(:destination); x.nil? ? nil : HttpClient::Preconditions.assert_class('destination', x, String)),
-                :from_country => (x = opts.delete(:from_country); x.nil? ? nil : HttpClient::Preconditions.assert_class('from_country', x, String)),
-                :ip => (x = opts.delete(:ip); x.nil? ? nil : HttpClient::Preconditions.assert_class('ip', x, String)),
-                :context => (x = opts.delete(:context); x.nil? ? nil : HttpClient::Preconditions.assert_class('context', x, String)),
-                :currency => (x = opts.delete(:currency); x.nil? ? nil : HttpClient::Preconditions.assert_class('currency', x, String)),
-                :language => (x = opts.delete(:language); x.nil? ? nil : HttpClient::Preconditions.assert_class('language', x, String)),
-                :limit => HttpClient::Preconditions.assert_class('limit', (x = opts.delete(:limit); x.nil? ? 25 : x), Integer),
-                :offset => HttpClient::Preconditions.assert_class('offset', (x = opts.delete(:offset); x.nil? ? 0 : x), Integer),
-                :sort => HttpClient::Preconditions.assert_class('sort', (x = opts.delete(:sort); x.nil? ? "-created_at" : x), String)
-              }.delete_if { |k, v| v.nil? }
-              r = @client.request("/#{CGI.escape(organization)}/experiences/items").with_query(query).get
-              r.map { |x| ::Io::Flow::Catalog::V0::Models::Item.new(x) }
-            end
-
-            # Checkout, aggregate items and prices.
-            def post_checkout(organization, checkout_form)
-              HttpClient::Preconditions.assert_class('organization', organization, String)
-              HttpClient::Preconditions.assert_class('checkout_form', checkout_form, ::Io::Flow::Experience::V0::Models::CheckoutForm)
-              r = @client.request("/#{CGI.escape(organization)}/experiences/checkout").with_json(checkout_form.to_json).post
-              ::Io::Flow::Experience::V0::Models::Checkout.new(r)
-            end
-
-            # Returns information about a specific experience.
-            def get_by_key(organization, key)
-              HttpClient::Preconditions.assert_class('organization', organization, String)
-              HttpClient::Preconditions.assert_class('key', key, String)
-              r = @client.request("/#{CGI.escape(organization)}/experiences/#{CGI.escape(key)}").get
-              ::Io::Flow::Experience::V0::Models::Experience.new(r)
-            end
-
-            # Add experience
-            def post(organization, experience_form)
-              HttpClient::Preconditions.assert_class('organization', organization, String)
-              HttpClient::Preconditions.assert_class('experience_form', experience_form, ::Io::Flow::Experience::V0::Models::ExperienceForm)
-              r = @client.request("/#{CGI.escape(organization)}/experiences").with_json(experience_form.to_json).post
-              ::Io::Flow::Experience::V0::Models::Experience.new(r)
-            end
-
-            # Update experience with the specified key, creating if it does not exist.
-            def put_by_key(organization, key, experience_form)
-              HttpClient::Preconditions.assert_class('organization', organization, String)
-              HttpClient::Preconditions.assert_class('key', key, String)
-              HttpClient::Preconditions.assert_class('experience_form', experience_form, ::Io::Flow::Experience::V0::Models::ExperienceForm)
-              r = @client.request("/#{CGI.escape(organization)}/experiences/#{CGI.escape(key)}").with_json(experience_form.to_json).put
-              ::Io::Flow::Experience::V0::Models::Experience.new(r)
-            end
-
-            # Remove the experience display with this key
-            def put_displays_by_key_and_display_key(organization, key, display_key, hash)
-              HttpClient::Preconditions.assert_class('organization', organization, String)
-              HttpClient::Preconditions.assert_class('key', key, String)
-              HttpClient::Preconditions.assert_class('display_key', display_key, String)
-              HttpClient::Preconditions.assert_class('hash', hash, Hash)
-              r = @client.request("/#{CGI.escape(organization)}/experiences/#{CGI.escape(key)}/displays/#{CGI.escape(display_key)}").with_json(hash.to_json).put
-              ::Io::Flow::Experience::V0::Models::Experience.new(r)
-            end
-
-            # Delete the experience with this key
-            def delete_by_key(organization, key)
-              HttpClient::Preconditions.assert_class('organization', organization, String)
-              HttpClient::Preconditions.assert_class('key', key, String)
-              r = @client.request("/#{CGI.escape(organization)}/experiences/#{CGI.escape(key)}").delete
-              nil
-            end
-
-          end
-
-        end
-
-        module Models
-
-          # Representation of information indicating landed cost and how it was derived
-          class Checkout
-
-            attr_reader :id, :deliveries, :prices, :total
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:id, :deliveries, :prices, :total], 'Checkout')
-              @id = HttpClient::Preconditions.assert_class('id', opts.delete(:id), String)
-              @deliveries = HttpClient::Preconditions.assert_class('deliveries', opts.delete(:deliveries), Array).map { |v| (x = v; x.is_a?(::Io::Flow::Fulfillment::V0::Models::Delivery) ? x : ::Io::Flow::Fulfillment::V0::Models::Delivery.new(x)) }
-              @prices = HttpClient::Preconditions.assert_class('prices', opts.delete(:prices), Array).map { |v| (x = v; x.is_a?(::Io::Flow::Catalog::V0::Models::LocalizedPrice) ? x : ::Io::Flow::Catalog::V0::Models::LocalizedPrice.new(x)) }
-              @total = (x = opts.delete(:total); x.is_a?(::Io::Flow::Catalog::V0::Models::LocalizedPrice) ? x : ::Io::Flow::Catalog::V0::Models::LocalizedPrice.new(x))
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              Checkout.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :id => id,
-                :deliveries => deliveries.map { |o| o.to_hash },
-                :prices => prices.map { |o| o.to_hash },
-                :total => total.to_hash
-              }
-            end
-
-          end
-
-          class CheckoutForm
-
-            attr_reader :destination, :items
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:destination, :items], 'CheckoutForm')
-              @destination = (x = opts.delete(:destination); x.is_a?(::Io::Flow::Common::V0::Models::Location) ? x : ::Io::Flow::Common::V0::Models::Location.new(x))
-              @items = HttpClient::Preconditions.assert_class('items', opts.delete(:items), Array).map { |v| (x = v; x.is_a?(::Io::Flow::Experience::V0::Models::Line) ? x : ::Io::Flow::Experience::V0::Models::Line.new(x)) }
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              CheckoutForm.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :destination => destination.to_hash,
-                :items => items.map { |o| o.to_hash }
-              }
-            end
-
-          end
-
-          class Component
-
-            attr_reader :adjustments, :levies
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:adjustments, :levies], 'Component')
-              @adjustments = HttpClient::Preconditions.assert_class('adjustments', opts.delete(:adjustments), Array).map { |v| (x = v; x.is_a?(::Io::Flow::Catalog::V0::Models::AdjustmentType) ? x : ::Io::Flow::Catalog::V0::Models::AdjustmentType.apply(x)) }
-              @levies = HttpClient::Preconditions.assert_class('levies', opts.delete(:levies), Array).map { |v| (x = v; x.is_a?(::Io::Flow::Catalog::V0::Models::Levy) ? x : ::Io::Flow::Catalog::V0::Models::Levy.apply(x)) }
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              Component.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :adjustments => adjustments.map { |o| o.value },
-                :levies => levies.map { |o| o.value }
-              }
-            end
-
-          end
-
-          # Defines elements of a localized cost available for display (e.g on a localized
-          # product page or checkout)
-          class Display
-
-            attr_reader :id, :key, :name, :context, :component
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:id, :key, :name, :context, :component], 'Display')
-              @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)
-              @context = HttpClient::Preconditions.assert_class('context', opts.delete(:context), Array).map { |v| HttpClient::Preconditions.assert_class('context', v, String) }
-              @component = (x = opts.delete(:component); x.is_a?(::Io::Flow::Experience::V0::Models::Component) ? x : ::Io::Flow::Experience::V0::Models::Component.new(x))
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              Display.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :id => id,
-                :key => key,
-                :name => name,
-                :context => context,
-                :component => component.to_hash
-              }
-            end
-
-          end
-
-          class DisplayForm
-
-            attr_reader :name, :component, :context
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:name, :component], 'DisplayForm')
-              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
-              @component = (x = opts.delete(:component); x.is_a?(::Io::Flow::Experience::V0::Models::Component) ? x : ::Io::Flow::Experience::V0::Models::Component.new(x))
-              @context = (x = opts.delete(:context); x.nil? ? nil : HttpClient::Preconditions.assert_class('context', x, Array).map { |v| HttpClient::Preconditions.assert_class('context', v, String) })
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              DisplayForm.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :name => name,
-                :component => component.to_hash,
-                :context => context.nil? ? nil : context
-              }
-            end
-
-          end
-
-          class DisplaySummary
-
-            attr_reader :id, :key
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:id, :key], 'DisplaySummary')
-              @id = HttpClient::Preconditions.assert_class('id', opts.delete(:id), String)
-              @key = HttpClient::Preconditions.assert_class('key', opts.delete(:key), String)
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              DisplaySummary.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :id => id,
-                :key => key
-              }
-            end
-
-          end
-
-          class DisplayVersion
-
-            attr_reader :id, :timestamp, :type, :display
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:id, :timestamp, :type, :display], 'DisplayVersion')
-              @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))
-              @display = (x = opts.delete(:display); x.is_a?(::Io::Flow::Experience::V0::Models::Display) ? x : ::Io::Flow::Experience::V0::Models::Display.new(x))
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              DisplayVersion.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :id => id,
-                :timestamp => timestamp,
-                :type => type.value,
-                :display => display.to_hash
-              }
-            end
-
-          end
-
-          # Properties that define a customized local experience for a given country
-          class Experience
-
-            attr_reader :id, :key, :country, :currency, :displays, :language, :measurement_system, :name, :subcatalog_id
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:id, :key, :country, :currency, :displays, :language, :measurement_system, :name, :subcatalog_id], 'Experience')
-              @id = HttpClient::Preconditions.assert_class('id', opts.delete(:id), String)
-              @key = HttpClient::Preconditions.assert_class('key', opts.delete(:key), String)
-              @country = HttpClient::Preconditions.assert_class('country', opts.delete(:country), String)
-              @currency = HttpClient::Preconditions.assert_class('currency', opts.delete(:currency), String)
-              @displays = HttpClient::Preconditions.assert_class('displays', opts.delete(:displays), Array).map { |v| (x = v; x.is_a?(::Io::Flow::Experience::V0::Models::DisplaySummary) ? x : ::Io::Flow::Experience::V0::Models::DisplaySummary.new(x)) }
-              @language = HttpClient::Preconditions.assert_class('language', opts.delete(:language), String)
-              @measurement_system = HttpClient::Preconditions.assert_class('measurement_system', opts.delete(:measurement_system), String)
-              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
-              @subcatalog_id = HttpClient::Preconditions.assert_class('subcatalog_id', opts.delete(:subcatalog_id), String)
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              Experience.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :id => id,
-                :key => key,
-                :country => country,
-                :currency => currency,
-                :displays => displays.map { |o| o.to_hash },
-                :language => language,
-                :measurement_system => measurement_system,
-                :name => name,
-                :subcatalog_id => subcatalog_id
-              }
-            end
-
-          end
-
-          class ExperienceForm
-
-            attr_reader :country, :name, :currency, :display_key, :language, :measurement_system, :subcatalog_id
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:country, :name], 'ExperienceForm')
-              @country = HttpClient::Preconditions.assert_class('country', opts.delete(:country), 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))
-              @display_key = (x = opts.delete(:display_key); x.nil? ? nil : HttpClient::Preconditions.assert_class('display_key', x, Array).map { |v| HttpClient::Preconditions.assert_class('display_key', v, String) })
-              @language = (x = opts.delete(:language); x.nil? ? nil : HttpClient::Preconditions.assert_class('language', x, String))
-              @measurement_system = (x = opts.delete(:measurement_system); x.nil? ? nil : HttpClient::Preconditions.assert_class('measurement_system', x, String))
-              @subcatalog_id = (x = opts.delete(:subcatalog_id); x.nil? ? nil : HttpClient::Preconditions.assert_class('subcatalog_id', x, String))
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              ExperienceForm.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :country => country,
-                :name => name,
-                :currency => currency,
-                :display_key => display_key.nil? ? nil : display_key,
-                :language => language,
-                :measurement_system => measurement_system,
-                :subcatalog_id => subcatalog_id
-              }
-            end
-
-          end
-
-          class ExperienceVersion
-
-            attr_reader :id, :timestamp, :type, :experience
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:id, :timestamp, :type, :experience], 'ExperienceVersion')
-              @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))
-              @experience = (x = opts.delete(:experience); x.is_a?(::Io::Flow::Experience::V0::Models::Experience) ? x : ::Io::Flow::Experience::V0::Models::Experience.new(x))
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              ExperienceVersion.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :id => id,
-                :timestamp => timestamp,
-                :type => type.value,
-                :experience => experience.to_hash
-              }
-            end
-
-          end
-
-          # Represents an order line for checkout
-          class Line
-
-            attr_reader :number, :quantity
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:number, :quantity], 'Line')
-              @number = HttpClient::Preconditions.assert_class('number', opts.delete(:number), String)
-              @quantity = HttpClient::Preconditions.assert_class('quantity', opts.delete(:quantity), Integer)
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              Line.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :number => number,
-                :quantity => quantity
-              }
-            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