flowcommerce-reference 0.4.4 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3b7afea601c5fd3bd938184ccff581a338aa50c8
-  data.tar.gz: b161bf9a3bb216d10b220e98878f8250851a8e1d
+  metadata.gz: 18c62371e895a8df90b0f555aa4f9d2324f1fb29
+  data.tar.gz: f939135fc4c2296f11625accd8b7ad30dc4b13e7
 SHA512:
-  metadata.gz: e17157852afaafe7f3c5cfb3ccdeb64a147d0acfd28b9cfb1aa19053c87ed966ae279198fd03a5b3bb2292c8e14d9ac7325883f8e7fad7ff27a6d1f50ae8ba6c
-  data.tar.gz: 1dda0942bf4d6f8d35ab84a95aaf01fd9143eb613942d49774764cf3dd92bc8440101cd69c1ed92faea05fce3c666cddf685eb37eb71c54d2055c0beb172d510
+  metadata.gz: 792929ad1e77c4d75e83aab6fe8a1318c89011bdb27f3f0797fd9659eb52ecccf0d729a0f11fcc14a3810cadc1bbb3ed26255f5b3c86d80dc869ff3cf99404c1
+  data.tar.gz: e44f452a3467184dd1ac1f8aa8656cda7e88099719d2678aba8aa664d45578d3051025abbb33d1b73013884e8e9c11485ddc2c35995185ebb9c235d9be0205f0

data/lib/flowcommerce-reference.rb

@@ -1,4 +1,4 @@
-require_relative 'io_flow_reference_v0'
+require_relative 'flow_reference_v0_client'
 require_relative 'version'
 require_relative 'generated/currencies'
 require_relative 'generated/countries'

data/lib/version.rb

@@ -1,7 +1,7 @@
-# Automatically generated at 2018-07-12 09:31:51 +0100
+# Automatically generated at 2018-07-12 09:34:26 +0100
 
 module FlowCommerce
   module Reference
-    VERSION = '0.4.4'
+    VERSION = '0.4.5'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flowcommerce-reference
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.4.5
 platform: ruby
 authors:
 - Michael Bryzek
@@ -25,7 +25,6 @@ files:
 - "./lib/generated/currencies.rb"
 - "./lib/generated/languages.rb"
 - "./lib/generated/payment_methods.rb"
-- "./lib/io_flow_reference_v0.rb"
 - "./lib/version.rb"
 homepage: https://www.flow.io
 licenses:

data/lib/io_flow_reference_v0.rb

@@ -1,1104 +0,0 @@
-# Generated by apidoc - http://www.apidoc.me
-# Service version: 0.2.83
-# apidoc:0.11.76 http://www.apidoc.me/flow/reference/0.2.83/ruby_client
-
-require 'cgi'
-require 'net/http'
-require 'net/https'
-require 'uri'
-require 'base64'
-
-require 'date'
-require 'rubygems'
-require 'json'
-require 'bigdecimal'
-
-# Reference data that changes infrequently including countries, currencies,
-# languages, etc.
-module Io
-  module FlowCommerce
-    module Reference
-      module V0
-
-        class Client
-
-          module Constants
-
-            BASE_URL = 'https://api.flow.io/reference' unless defined?(Constants::BASE_URL)
-            NAMESPACE = 'io.flow.reference.v0' unless defined?(Constants::NAMESPACE)
-            USER_AGENT = 'apidoc:0.11.76 http://www.apidoc.me/flow/reference/0.2.83/ruby_client' unless defined?(Constants::USER_AGENT)
-            VERSION = '0.2.87' unless defined?(Constants::VERSION)
-            VERSION_MAJOR = 0 unless defined?(VERSION_MAJOR)
-
-          end
-
-          attr_reader :url
-
-          def initialize(url, opts={})
-            @url = HttpClient::Preconditions.assert_class('url', url, String)
-            @base_url = URI(url)
-            @authorization = HttpClient::Preconditions.assert_class_or_nil('authorization', opts.delete(:authorization), HttpClient::Authorization)
-            @default_headers = HttpClient::Preconditions.assert_class('default_headers', opts.delete(:default_headers) || {}, Hash)
-            @http_handler = opts.delete(:http_handler) || HttpClient::DefaultHttpHandler.new
-
-            HttpClient::Preconditions.assert_empty_opts(opts)
-            HttpClient::Preconditions.check_state(url.match(/http.+/i), "URL[%s] must start with http" % url)
-          end
-
-          # 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(@http_handler, @base_url, path.to_s).with_header('User-Agent', Constants::USER_AGENT).with_header('X-Apidoc-Version', Constants::VERSION).with_header('X-Apidoc-Version-Major', Constants::VERSION_MAJOR)
-
-            @default_headers.each do |key, value|
-              request = request.with_header(key, value)
-            end
-
-            if @authorization
-              request = request.with_auth(@authorization)
-            end
-
-            request
-          end
-
-          def countries
-            @countries ||= ::Io::FlowCommerce::Reference::V0::Clients::Countries.new(self)
-          end
-
-          def currencies
-            @currencies ||= ::Io::FlowCommerce::Reference::V0::Clients::Currencies.new(self)
-          end
-
-          def languages
-            @languages ||= ::Io::FlowCommerce::Reference::V0::Clients::Languages.new(self)
-          end
-
-          def locales
-            @locales ||= ::Io::FlowCommerce::Reference::V0::Clients::Locales.new(self)
-          end
-
-          def regions
-            @regions ||= ::Io::FlowCommerce::Reference::V0::Clients::Regions.new(self)
-          end
-
-          def timezones
-            @timezones ||= ::Io::FlowCommerce::Reference::V0::Clients::Timezones.new(self)
-          end
-        end
-
-        module Clients
-
-          class Countries
-
-            def initialize(client)
-              @client = HttpClient::Preconditions.assert_class('client', client, ::Io::FlowCommerce::Reference::V0::Client)
-            end
-
-            # Returns a list of countries.
-            def get(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              query = {
-                :q => (x = opts.delete(:q); x.nil? ? nil : HttpClient::Preconditions.assert_class('q', x, String))
-              }.delete_if { |k, v| v.nil? }
-              r = @client.request("/reference/countries").with_query(query).get
-              r.map { |x| ::Io::FlowCommerce::Reference::V0::Models::Country.new(x) }
-            end
-
-          end
-
-          class Currencies
-
-            def initialize(client)
-              @client = HttpClient::Preconditions.assert_class('client', client, ::Io::FlowCommerce::Reference::V0::Client)
-            end
-
-            # Returns a list of currencies.
-            def get(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              query = {
-                :q => (x = opts.delete(:q); x.nil? ? nil : HttpClient::Preconditions.assert_class('q', x, String))
-              }.delete_if { |k, v| v.nil? }
-              r = @client.request("/reference/currencies").with_query(query).get
-              r.map { |x| ::Io::FlowCommerce::Reference::V0::Models::Currency.new(x) }
-            end
-
-          end
-
-          class Languages
-
-            def initialize(client)
-              @client = HttpClient::Preconditions.assert_class('client', client, ::Io::FlowCommerce::Reference::V0::Client)
-            end
-
-            # Returns a list of languages.
-            def get(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              query = {
-                :q => (x = opts.delete(:q); x.nil? ? nil : HttpClient::Preconditions.assert_class('q', x, String))
-              }.delete_if { |k, v| v.nil? }
-              r = @client.request("/reference/languages").with_query(query).get
-              r.map { |x| ::Io::FlowCommerce::Reference::V0::Models::Language.new(x) }
-            end
-
-          end
-
-          class Locales
-
-            def initialize(client)
-              @client = HttpClient::Preconditions.assert_class('client', client, ::Io::FlowCommerce::Reference::V0::Client)
-            end
-
-            # Returns a list of locales.
-            def get(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              query = {
-                :q => (x = opts.delete(:q); x.nil? ? nil : HttpClient::Preconditions.assert_class('q', x, String))
-              }.delete_if { |k, v| v.nil? }
-              r = @client.request("/reference/locales").with_query(query).get
-              r.map { |x| ::Io::FlowCommerce::Reference::V0::Models::Locale.new(x) }
-            end
-
-            # Returns the locale with the specifed id.
-            def get_by_id(id)
-              HttpClient::Preconditions.assert_class('id', id, String)
-              r = @client.request("/reference/locales/#{CGI.escape(id)}").get
-              ::Io::FlowCommerce::Reference::V0::Models::Locale.new(r)
-            end
-
-          end
-
-          class Regions
-
-            def initialize(client)
-              @client = HttpClient::Preconditions.assert_class('client', client, ::Io::FlowCommerce::Reference::V0::Client)
-            end
-
-            # Returns a list of regions.
-            def get(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              query = {
-                :q => (x = opts.delete(:q); x.nil? ? nil : HttpClient::Preconditions.assert_class('q', x, String))
-              }.delete_if { |k, v| v.nil? }
-              r = @client.request("/reference/regions").with_query(query).get
-              r.map { |x| ::Io::FlowCommerce::Reference::V0::Models::Region.new(x) }
-            end
-
-            # Returns the region with the specifed id.
-            def get_by_id(id)
-              HttpClient::Preconditions.assert_class('id', id, String)
-              r = @client.request("/reference/regions/#{CGI.escape(id)}").get
-              ::Io::FlowCommerce::Reference::V0::Models::Region.new(r)
-            end
-
-          end
-
-          class Timezones
-
-            def initialize(client)
-              @client = HttpClient::Preconditions.assert_class('client', client, ::Io::FlowCommerce::Reference::V0::Client)
-            end
-
-            # Returns a list of timezones.
-            def get(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              query = {
-                :q => (x = opts.delete(:q); x.nil? ? nil : HttpClient::Preconditions.assert_class('q', x, String))
-              }.delete_if { |k, v| v.nil? }
-              r = @client.request("/reference/timezones").with_query(query).get
-              r.map { |x| ::Io::FlowCommerce::Reference::V0::Models::Timezone.new(x) }
-            end
-
-          end
-
-        end
-
-        module Models
-
-          class PaymentMethodType
-
-            attr_reader :value
-
-            def initialize(value)
-              @value = HttpClient::Preconditions.assert_class('value', value, String)
-            end
-
-            # Returns the instance of PaymentMethodType for this value, creating a new instance for an unknown value
-            def PaymentMethodType.apply(value)
-              if value.instance_of?(PaymentMethodType)
-                value
-              else
-                HttpClient::Preconditions.assert_class_or_nil('value', value, String)
-                value.nil? ? nil : (from_string(value) || PaymentMethodType.new(value))
-              end
-            end
-
-            # Returns the instance of PaymentMethodType for this value, or nil if not found
-            def PaymentMethodType.from_string(value)
-              HttpClient::Preconditions.assert_class('value', value, String)
-              PaymentMethodType.ALL.find { |v| v.value == value }
-            end
-
-            def PaymentMethodType.ALL
-              @@all ||= [PaymentMethodType.card, PaymentMethodType.online, PaymentMethodType.offline]
-            end
-
-            # Represents all form of card payment (e.g. credit, debit, etc.)
-            def PaymentMethodType.card
-              @@_card ||= PaymentMethodType.new('card')
-            end
-
-            # Represents the most common form of alternative payment methods which require
-            # some degree of integration online (e.g. a redirect) to complete payment.
-            def PaymentMethodType.online
-              @@_online ||= PaymentMethodType.new('online')
-            end
-
-            # Offline payment method types represent payments like Cash On Delivery which
-            # require offline collection
-            def PaymentMethodType.offline
-              @@_offline ||= PaymentMethodType.new('offline')
-            end
-
-            def to_hash
-              value
-            end
-
-          end
-
-          # ISO 3166 country codes. Note Flow APIs will accept either the 2 or 3 character
-          # country code, but internally we normalize data and store as the 3 character,
-          # upper case ISO code. See https://api.flow.io/reference/countries
-          class Country
-
-            attr_reader :name, :iso_3166_2, :iso_3166_3, :languages, :measurement_system, :default_currency, :timezones, :default_delivered_duty
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:name, :iso_3166_2, :iso_3166_3, :languages, :measurement_system, :timezones], 'Country')
-              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
-              @iso_3166_2 = HttpClient::Preconditions.assert_class('iso_3166_2', opts.delete(:iso_3166_2), String)
-              @iso_3166_3 = HttpClient::Preconditions.assert_class('iso_3166_3', opts.delete(:iso_3166_3), String)
-              @languages = HttpClient::Preconditions.assert_class('languages', opts.delete(:languages), Array).map { |v| HttpClient::Preconditions.assert_class('languages', v, String) }
-              @measurement_system = HttpClient::Preconditions.assert_class('measurement_system', opts.delete(:measurement_system), String)
-              @default_currency = (x = opts.delete(:default_currency); x.nil? ? nil : HttpClient::Preconditions.assert_class('default_currency', x, String))
-              @timezones = HttpClient::Preconditions.assert_class('timezones', opts.delete(:timezones), Array).map { |v| HttpClient::Preconditions.assert_class('timezones', v, String) }
-              @default_delivered_duty = (x = opts.delete(:default_delivered_duty); x.nil? ? nil : HttpClient::Preconditions.assert_class('default_delivered_duty', x, String))
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              Country.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :name => name,
-                :iso_3166_2 => iso_3166_2,
-                :iso_3166_3 => iso_3166_3,
-                :languages => languages,
-                :measurement_system => measurement_system,
-                :default_currency => default_currency,
-                :timezones => timezones,
-                :default_delivered_duty => default_delivered_duty
-              }
-            end
-
-          end
-
-          # ISO 4217 3-character currency code. See
-          # https://api.flow.io/reference/currencies
-          class Currency
-
-            attr_reader :name, :iso_4217_3, :number_decimals, :symbols, :default_locale
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:name, :iso_4217_3, :number_decimals], 'Currency')
-              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
-              @iso_4217_3 = HttpClient::Preconditions.assert_class('iso_4217_3', opts.delete(:iso_4217_3), String)
-              @number_decimals = HttpClient::Preconditions.assert_class('number_decimals', opts.delete(:number_decimals), Integer)
-              @symbols = (x = opts.delete(:symbols); x.nil? ? nil : (x = x; x.is_a?(::Io::FlowCommerce::Reference::V0::Models::CurrencySymbols) ? x : ::Io::FlowCommerce::Reference::V0::Models::CurrencySymbols.new(x)))
-              @default_locale = (x = opts.delete(:default_locale); x.nil? ? nil : HttpClient::Preconditions.assert_class('default_locale', x, String))
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              Currency.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :name => name,
-                :iso_4217_3 => iso_4217_3,
-                :number_decimals => number_decimals,
-                :symbols => symbols.nil? ? nil : symbols.to_hash,
-                :default_locale => default_locale
-              }
-            end
-
-          end
-
-          # Defines one or more symbols representing this currency
-          class CurrencySymbols
-
-            attr_reader :primary, :narrow
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:primary], 'CurrencySymbols')
-              @primary = HttpClient::Preconditions.assert_class('primary', opts.delete(:primary), String)
-              @narrow = (x = opts.delete(:narrow); x.nil? ? nil : HttpClient::Preconditions.assert_class('narrow', x, String))
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              CurrencySymbols.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :primary => primary,
-                :narrow => narrow
-              }
-            end
-
-          end
-
-          # ISO 639 2-character language code. See https://api.flow.io/reference/languages
-          class Language
-
-            attr_reader :name, :iso_639_2
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:name, :iso_639_2], 'Language')
-              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
-              @iso_639_2 = HttpClient::Preconditions.assert_class('iso_639_2', opts.delete(:iso_639_2), String)
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              Language.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :name => name,
-                :iso_639_2 => iso_639_2
-              }
-            end
-
-          end
-
-          # Locales defines standard conventions for presentation of content. See
-          # https://api.flow.io/reference/locales
-          class Locale
-
-            attr_reader :id, :name, :country, :language, :numbers
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:id, :name, :country, :language, :numbers], 'Locale')
-              @id = HttpClient::Preconditions.assert_class('id', opts.delete(:id), String)
-              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
-              @country = HttpClient::Preconditions.assert_class('country', opts.delete(:country), String)
-              @language = HttpClient::Preconditions.assert_class('language', opts.delete(:language), String)
-              @numbers = (x = opts.delete(:numbers); x.is_a?(::Io::FlowCommerce::Reference::V0::Models::LocaleNumbers) ? x : ::Io::FlowCommerce::Reference::V0::Models::LocaleNumbers.new(x))
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              Locale.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :id => id,
-                :name => name,
-                :country => country,
-                :language => language,
-                :numbers => numbers.to_hash
-              }
-            end
-
-          end
-
-          # Number formats defined for a given locale
-          class LocaleNumbers
-
-            attr_reader :decimal, :group
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:decimal, :group], 'LocaleNumbers')
-              @decimal = HttpClient::Preconditions.assert_class('decimal', opts.delete(:decimal), String)
-              @group = HttpClient::Preconditions.assert_class('group', opts.delete(:group), String)
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              LocaleNumbers.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :decimal => decimal,
-                :group => group
-              }
-            end
-
-          end
-
-          # Represents a single payment method - e.g VISA or Paypal - and any associated
-          # metadata required for processing
-          class PaymentMethod
-
-            attr_reader :id, :type, :name, :images, :regions
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:id, :type, :name, :images, :regions], 'PaymentMethod')
-              @id = HttpClient::Preconditions.assert_class('id', opts.delete(:id), String)
-              @type = (x = opts.delete(:type); x.is_a?(::Io::FlowCommerce::Reference::V0::Models::PaymentMethodType) ? x : ::Io::FlowCommerce::Reference::V0::Models::PaymentMethodType.apply(x))
-              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
-              @images = (x = opts.delete(:images); x.is_a?(::Io::FlowCommerce::Reference::V0::Models::PaymentMethodImages) ? x : ::Io::FlowCommerce::Reference::V0::Models::PaymentMethodImages.new(x))
-              @regions = HttpClient::Preconditions.assert_class('regions', opts.delete(:regions), Array).map { |v| HttpClient::Preconditions.assert_class('regions', v, String) }
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              PaymentMethod.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :id => id,
-                :type => type.value,
-                :name => name,
-                :images => images.to_hash,
-                :regions => regions
-              }
-            end
-
-          end
-
-          class PaymentMethodImage
-
-            attr_reader :url, :width, :height
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:url, :width, :height], 'PaymentMethodImage')
-              @url = HttpClient::Preconditions.assert_class('url', opts.delete(:url), String)
-              @width = HttpClient::Preconditions.assert_class('width', opts.delete(:width), Integer)
-              @height = HttpClient::Preconditions.assert_class('height', opts.delete(:height), Integer)
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              PaymentMethodImage.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :url => url,
-                :width => width,
-                :height => height
-              }
-            end
-
-          end
-
-          class PaymentMethodImages
-
-            attr_reader :small, :medium, :large
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:small, :medium, :large], 'PaymentMethodImages')
-              @small = (x = opts.delete(:small); x.is_a?(::Io::FlowCommerce::Reference::V0::Models::PaymentMethodImage) ? x : ::Io::FlowCommerce::Reference::V0::Models::PaymentMethodImage.new(x))
-              @medium = (x = opts.delete(:medium); x.is_a?(::Io::FlowCommerce::Reference::V0::Models::PaymentMethodImage) ? x : ::Io::FlowCommerce::Reference::V0::Models::PaymentMethodImage.new(x))
-              @large = (x = opts.delete(:large); x.is_a?(::Io::FlowCommerce::Reference::V0::Models::PaymentMethodImage) ? x : ::Io::FlowCommerce::Reference::V0::Models::PaymentMethodImage.new(x))
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              PaymentMethodImages.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :small => small.to_hash,
-                :medium => medium.to_hash,
-                :large => large.to_hash
-              }
-            end
-
-          end
-
-          # A region represents a geographic area of the world. Regions can be countries,
-          # continents or other political areas (like the Eurozone). See
-          # https://api.flow.io/reference/regions
-          class Region
-
-            attr_reader :id, :name, :countries, :currencies, :languages, :measurement_systems, :timezones
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:id, :name, :countries, :currencies, :languages, :measurement_systems, :timezones], 'Region')
-              @id = HttpClient::Preconditions.assert_class('id', opts.delete(:id), String)
-              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
-              @countries = HttpClient::Preconditions.assert_class('countries', opts.delete(:countries), Array).map { |v| HttpClient::Preconditions.assert_class('countries', v, String) }
-              @currencies = HttpClient::Preconditions.assert_class('currencies', opts.delete(:currencies), Array).map { |v| HttpClient::Preconditions.assert_class('currencies', v, String) }
-              @languages = HttpClient::Preconditions.assert_class('languages', opts.delete(:languages), Array).map { |v| HttpClient::Preconditions.assert_class('languages', v, String) }
-              @measurement_systems = HttpClient::Preconditions.assert_class('measurement_systems', opts.delete(:measurement_systems), Array).map { |v| HttpClient::Preconditions.assert_class('measurement_systems', v, String) }
-              @timezones = HttpClient::Preconditions.assert_class('timezones', opts.delete(:timezones), Array).map { |v| HttpClient::Preconditions.assert_class('timezones', v, String) }
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              Region.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :id => id,
-                :name => name,
-                :countries => countries,
-                :currencies => currencies,
-                :languages => languages,
-                :measurement_systems => measurement_systems,
-                :timezones => timezones
-              }
-            end
-
-          end
-
-          # Time zone data is provided by the public IANA time zone database. See
-          # http://www.iana.org/time-zones
-          class Timezone
-
-            attr_reader :name, :description, :offset
-
-            def initialize(incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              HttpClient::Preconditions.require_keys(opts, [:name, :description, :offset], 'Timezone')
-              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
-              @description = HttpClient::Preconditions.assert_class('description', opts.delete(:description), String)
-              @offset = HttpClient::Preconditions.assert_class('offset', opts.delete(:offset), Integer)
-            end
-
-            def to_json
-              JSON.dump(to_hash)
-            end
-
-            def copy(incoming={})
-              Timezone.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
-            end
-
-            def to_hash
-              {
-                :name => name,
-                :description => description,
-                :offset => offset
-              }
-            end
-
-          end
-
-        end
-
-        # ===== END OF SERVICE DEFINITION =====
-        module HttpClient
-
-          class HttpHandler
-
-            # Returns a client instance to use
-            #
-            # @param base_uri The base URI for this API
-            # @param path the Requested full http path (including any query strings)
-            def instance(base_uri, path)
-              raise "Override in subclass"
-            end
-
-          end
-
-          class HttpHandlerInstance
-
-            # Executes a request. The provided request object will be an
-            # instance of Net::HTTP (e.g. Net::HTTP::Get)
-            def execute(request)
-              raise "Override in subclass"
-            end
-
-          end
-
-          class DefaultHttpHandler < HttpHandler
-
-            def instance(base_uri, path)
-              DefaultHttpHandlerInstance.new(base_uri)
-            end
-
-          end
-
-          class DefaultHttpHandlerInstance < HttpHandlerInstance
-
-            attr_reader :client
-
-            def initialize(base_uri)
-              @base_uri = Preconditions.assert_class('base_uri', base_uri, URI)
-              @client = Net::HTTP.new(@base_uri.host, @base_uri.port)
-              if @base_uri.scheme == "https"
-                configure_ssl
-              end
-            end
-
-            def execute(request)
-              response = begin
-                           @client.request(request)
-                         rescue SocketError => e
-                           raise Exception.new("Error accessing uri[#{full_uri(request.path)}]: #{e}")
-                         end
-
-              case response
-              when Net::HTTPSuccess
-                response.body
-              else
-                body = response.body rescue nil
-                raise HttpClient::ServerError.new(response.code.to_i, response.message, :body => body, :uri => full_uri(request.path).to_s)
-              end
-            end
-
-            def full_uri(path)
-              File.join(@base_uri.to_s, path)
-            end
-
-            # Called to configure SSL if the base uri requires it
-            def configure_ssl
-              @client.use_ssl = true
-              @client.verify_mode = OpenSSL::SSL::VERIFY_PEER
-              @client.cert_store = OpenSSL::X509::Store.new
-              @client.cert_store.set_default_paths
-            end
-
-          end
-
-          class Request
-
-            attr_reader :path
-
-            def initialize(http_handler, base_uri, path)
-              @http_handler = http_handler
-              @base_uri = Preconditions.assert_class('base_uri', base_uri, URI)
-              @path = Preconditions.assert_class('path', path, String)
-              @params = nil
-              @body = nil
-              @auth = nil
-              @headers = {}
-              @header_keys_lower_case = []
-            end
-
-            def with_header(name, value)
-              Preconditions.check_not_blank('name', name, "Header name is required")
-              Preconditions.check_not_blank('value', value, "Header value is required")
-              Preconditions.check_state(!@headers.has_key?(name),
-                                        "Duplicate header named[%s]" % name)
-              @headers[name] = value
-              @header_keys_lower_case << name.downcase
-              self
-            end
-
-            def with_auth(auth)
-              Preconditions.assert_class('auth', auth, HttpClient::Authorization)
-              Preconditions.check_state(@auth.nil?, "auth previously set")
-
-              if auth.scheme.name == AuthScheme::BASIC.name
-                @auth = auth
-              else
-                raise "Auth Scheme[#{auth.scheme.name}] not supported"
-              end
-              self
-            end
-
-            def with_query(params)
-              Preconditions.assert_class('params', params, Hash)
-              Preconditions.check_state(@params.nil?, "Already have query parameters")
-              @params = params
-              self
-            end
-
-            # Wrapper to set Content-Type header to application/json and set
-            # the provided json document as the body
-            def with_json(json)
-              @headers['Content-Type'] ||= 'application/json; charset=UTF-8'
-              with_body(json)
-            end
-
-            def with_body(body)
-              Preconditions.check_not_blank('body', body)
-              @body = body
-              self
-            end
-
-            def get(&block)
-              do_request(Net::HTTP::Get, &block)
-            end
-
-            def delete(&block)
-              do_request(Net::HTTP::Delete, &block)
-            end
-
-            def options(&block)
-              do_request(Net::HTTP::Options, &block)
-            end
-
-            def post(&block)
-              do_request(Net::HTTP::Post, &block)
-            end
-
-            def put(&block)
-              do_request(Net::HTTP::Put, &block)
-            end
-
-            class PATCH < Net::HTTP::Put
-              METHOD = "PATCH"
-            end
-
-            def patch(&block)
-              do_request(PATCH, &block)
-            end
-
-            def do_request(klass)
-              Preconditions.assert_class('klass', klass, Class)
-
-              uri = path.dup
-              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%s'" % [@base_uri, path]
-              # DEBUG puts curl.join(" ")
-
-              raw_response = @http_handler.instance(@base_uri, request.path).execute(request)
-              response = raw_response.to_s == "" ? nil : JSON.parse(raw_response)
-
-              if block_given?
-                yield response
-              else
-                response
-              end
-            end
-
-            private
-            def to_query(params={})
-              parts = (params || {}).map { |k,v|
-                if v.is_a?(Enumerable)
-                  v.map { |el| "%s=%s" % [k, CGI.escape(el.to_s)] }
-                else
-                  "%s=%s" % [k, CGI.escape(v.to_s)]
-                end
-              }
-              parts.empty? ? nil : parts.join("&")
-            end
-
-          end
-
-          class ServerError < StandardError
-
-            attr_reader :code, :details, :body, :uri
-
-            def initialize(code, details, incoming={})
-              opts = HttpClient::Helper.symbolize_keys(incoming)
-              @code = HttpClient::Preconditions.assert_class('code', code, Integer)
-              @details = HttpClient::Preconditions.assert_class('details', details, String)
-              @body = HttpClient::Preconditions.assert_class_or_nil('body', opts.delete(:body), String)
-              @uri = HttpClient::Preconditions.assert_class_or_nil('uri', opts.delete(:uri), String)
-              HttpClient::Preconditions.assert_empty_opts(opts)
-              super(self.message)
-            end
-
-            def message
-              m = "%s %s" % [@code, @details]
-              if @body
-                m << ": %s" % @body
-              end
-              m
-            end
-
-            def body_json
-              @body ? JSON.parse(@body) : nil
-            end
-
-          end
-
-          class PreconditionException < 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 ? (value.is_a?(Hash) ? value : JSON.parse(value)) : nil
-            end
-
-            def Helper.to_uuid(value)
-              Preconditions.check_state(value.nil? || value.match(/^\w\w\w\w\w\w\w\w\-\w\w\w\w\-\w\w\w\w\-\w\w\w\w\-\w\w\w\w\w\w\w\w\w\w\w\w$/),
-                                        "Invalid guid[%s]" % value)
-              value
-            end
-
-            def Helper.to_date_iso8601(value)
-              if value.is_a?(Date)
-                value
-              elsif value
-                Date.parse(value.to_s)
-              else
-                nil
-              end
-            end
-
-            def Helper.to_date_time_iso8601(value)
-              if value.is_a?(DateTime)
-                value
-              elsif value
-                DateTime.parse(value.to_s)
-              else
-                nil
-              end
-            end
-
-            def Helper.date_iso8601_to_string(value)
-              value.nil? ? nil : value.strftime('%Y-%m-%d')
-            end
-
-            def Helper.date_time_iso8601_to_string(value)
-              value.nil? ? nil : value.strftime('%Y-%m-%dT%H:%M:%S%z')
-            end
-
-            TRUE_STRINGS = ['t', 'true', 'y', 'yes', 'on', '1', 'trueclass'] unless defined?(TRUE_STRINGS)
-            FALSE_STRINGS = ['f', 'false', 'n', 'no', 'off', '0', 'falseclass'] unless defined?(FALSE_STRINGS)
-
-            def Helper.to_boolean(field_name, value)
-              string = value.to_s.strip.downcase
-              if TRUE_STRINGS.include?(string)
-                true
-              elsif FALSE_STRINGS.include?(string)
-                false
-              elsif string != ""
-                raise PreconditionException.new("Unsupported boolean value[#{string}]. For true, must be one of: #{TRUE_STRINGS.inspect}. For false, must be one of: #{FALSE_STRINGS.inspect}")
-              else
-                nil
-              end
-            end
-
-          end
-
-        end
-      end
-    end
-  end
-end