newstore-apimatic-sdk 0.0.1

data/lib/new_store_api/models/injected_order_routing_strategy2.rb

@@ -0,0 +1,93 @@
+# new_store_api
+#
+# This file was automatically generated for NewStore by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module NewStoreApi
+  # InjectedOrderRoutingStrategy2 Model.
+  class InjectedOrderRoutingStrategy2 < BaseModel
+    SKIP = Object.new
+    private_constant :SKIP
+
+    # The fulfillment node ID to which the order will be routed. This location
+    # must exist in NewStore, otherwise the order will be canceled.
+    # @return [String]
+    attr_accessor :fulfillment_node_id
+
+    # This routing strategy is used to fulfill a order routed by an external
+    # OMS. If the `external` strategy is used, the `fulfillment_node_id` and the
+    # `service_level` from the `shipping_option` is required.
+    # @return [String]
+    attr_reader :strategy
+
+    # A mapping from model property names to API property names.
+    def self.names
+      @_hash = {} if @_hash.nil?
+      @_hash['fulfillment_node_id'] = 'fulfillment_node_id'
+      @_hash['strategy'] = 'strategy'
+      @_hash
+    end
+
+    # An array for optional fields
+    def self.optionals
+      []
+    end
+
+    # An array for nullable fields
+    def self.nullables
+      []
+    end
+
+    def initialize(fulfillment_node_id = nil)
+      @fulfillment_node_id = fulfillment_node_id
+      @strategy = 'external'
+    end
+
+    # Creates an instance of the object from a hash.
+    def self.from_hash(hash)
+      return nil unless hash
+
+      # Extract variables from the hash.
+      fulfillment_node_id =
+        hash.key?('fulfillment_node_id') ? hash['fulfillment_node_id'] : nil
+
+      # Create object from extracted values.
+      InjectedOrderRoutingStrategy2.new(fulfillment_node_id)
+    end
+
+    # Validates an instance of the object from a given value.
+    # @param [InjectedOrderRoutingStrategy2 | Hash] The value against the validation is performed.
+    def self.validate(value)
+      if value.instance_of? self
+        return (
+          APIHelper.valid_type?(value.fulfillment_node_id,
+                                ->(val) { val.instance_of? String }) and
+            APIHelper.valid_type?(value.strategy,
+                                  ->(val) { val.instance_of? String })
+        )
+      end
+
+      return false unless value.instance_of? Hash
+
+      (
+        APIHelper.valid_type?(value['fulfillment_node_id'],
+                              ->(val) { val.instance_of? String }) and
+          APIHelper.valid_type?(value['strategy'],
+                                ->(val) { val.instance_of? String })
+      )
+    end
+
+    # Provides a human-readable string representation of the object.
+    def to_s
+      class_name = self.class.name.split('::').last
+      "<#{class_name} fulfillment_node_id: #{@fulfillment_node_id}, strategy: #{@strategy}>"
+    end
+
+    # Provides a debugging-friendly string with detailed object information.
+    def inspect
+      class_name = self.class.name.split('::').last
+      "<#{class_name} fulfillment_node_id: #{@fulfillment_node_id.inspect}, strategy:"\
+      " #{@strategy.inspect}>"
+    end
+  end
+end

data/lib/new_store_api/models/injected_order_shipment.rb

@@ -0,0 +1,105 @@
+# new_store_api
+#
+# This file was automatically generated for NewStore by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module NewStoreApi
+  # A shipment sent from a fulfillment location.
+  class InjectedOrderShipment < BaseModel
+    SKIP = Object.new
+    private_constant :SKIP
+
+    # TODO: Write general description for this method
+    # @return [Array[InjectedOrderShipmentItem]]
+    attr_accessor :items
+
+    # TODO: Write general description for this method
+    # @return [Object]
+    attr_accessor :shipping_option
+
+    # A mapping from model property names to API property names.
+    def self.names
+      @_hash = {} if @_hash.nil?
+      @_hash['items'] = 'items'
+      @_hash['shipping_option'] = 'shipping_option'
+      @_hash
+    end
+
+    # An array for optional fields
+    def self.optionals
+      []
+    end
+
+    # An array for nullable fields
+    def self.nullables
+      []
+    end
+
+    def initialize(items = nil, shipping_option = nil)
+      @items = items
+      @shipping_option = shipping_option
+    end
+
+    # Creates an instance of the object from a hash.
+    def self.from_hash(hash)
+      return nil unless hash
+
+      # Extract variables from the hash.
+      # Parameter is an array, so we need to iterate through it
+      items = nil
+      unless hash['items'].nil?
+        items = []
+        hash['items'].each do |structure|
+          items << (InjectedOrderShipmentItem.from_hash(structure) if structure)
+        end
+      end
+
+      items = nil unless hash.key?('items')
+      shipping_option = hash.key?('shipping_option') ? APIHelper.deserialize_union_type(
+        UnionTypeLookUp.get(:InjectedOrderShippingOption2), hash['shipping_option']
+      ) : nil
+
+      # Create object from extracted values.
+      InjectedOrderShipment.new(items,
+                                shipping_option)
+    end
+
+    # Validates an instance of the object from a given value.
+    # @param [InjectedOrderShipment | Hash] The value against the validation is performed.
+    def self.validate(value)
+      if value.instance_of? self
+        return (
+          APIHelper.valid_type?(value.items,
+                                ->(val) { InjectedOrderShipmentItem.validate(val) },
+                                is_model_hash: true,
+                                is_inner_model_hash: true) and
+            UnionTypeLookUp.get(:InjectedOrderShippingOption2)
+                           .validate(value.shipping_option)
+        )
+      end
+
+      return false unless value.instance_of? Hash
+
+      (
+        APIHelper.valid_type?(value['items'],
+                              ->(val) { InjectedOrderShipmentItem.validate(val) },
+                              is_model_hash: true,
+                              is_inner_model_hash: true) and
+          UnionTypeLookUp.get(:InjectedOrderShippingOption2)
+                         .validate(value['shipping_option'])
+      )
+    end
+
+    # Provides a human-readable string representation of the object.
+    def to_s
+      class_name = self.class.name.split('::').last
+      "<#{class_name} items: #{@items}, shipping_option: #{@shipping_option}>"
+    end
+
+    # Provides a debugging-friendly string with detailed object information.
+    def inspect
+      class_name = self.class.name.split('::').last
+      "<#{class_name} items: #{@items.inspect}, shipping_option: #{@shipping_option.inspect}>"
+    end
+  end
+end

data/lib/new_store_api/models/injected_order_shipment_item.rb

@@ -0,0 +1,169 @@
+# new_store_api
+#
+# This file was automatically generated for NewStore by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module NewStoreApi
+  # A single product. The quantity of the item is always assumed to be 1 because
+  # products are flat, and each variant of a product is considered a separate
+  # item. The item is identified by `external_item_id` in the external system.
+  # In the response, an internal NewStore item ID is returned for each
+  # `external_item_id`. An item can be declared as an addon of another item via
+  # `addon_parent_external_item_id`.
+  class InjectedOrderShipmentItem < BaseModel
+    SKIP = Object.new
+    private_constant :SKIP
+
+    # The `external_item_id` of the item that this item is an addon of. The
+    # parent must belong to the same shipment as this addon. When set, this item
+    # becomes an addon line item linked to that parent.
+    # @return [String]
+    attr_accessor :addon_parent_external_item_id
+
+    # The `external_item_id` of the item that this item is an addon of. The
+    # parent must belong to the same shipment as this addon. When set, this item
+    # becomes an addon line item linked to that parent.
+    # @return [Array[InjectedOrderExtendedAttribute]]
+    attr_accessor :extended_attributes
+
+    # The `external_item_id` of the item that this item is an addon of. The
+    # parent must belong to the same shipment as this addon. When set, this item
+    # becomes an addon line item linked to that parent.
+    # @return [String]
+    attr_accessor :external_item_id
+
+    # Indicates if gift wrapping option was selected for the order. Only
+    # information from the first item (message and price) will be taken into
+    # account.
+    # @return [GiftWrapping1]
+    attr_accessor :gift_wrapping
+
+    # Indicates if gift wrapping option was selected for the order. Only
+    # information from the first item (message and price) will be taken into
+    # account.
+    # @return [InjectedOrderShipmentItemPrice]
+    attr_accessor :price
+
+    # The identifier of the product as it was fetched from the catalog.
+    # @return [String]
+    attr_accessor :product_id
+
+    # A mapping from model property names to API property names.
+    def self.names
+      @_hash = {} if @_hash.nil?
+      @_hash['addon_parent_external_item_id'] =
+        'addon_parent_external_item_id'
+      @_hash['extended_attributes'] = 'extended_attributes'
+      @_hash['external_item_id'] = 'external_item_id'
+      @_hash['gift_wrapping'] = 'gift_wrapping'
+      @_hash['price'] = 'price'
+      @_hash['product_id'] = 'product_id'
+      @_hash
+    end
+
+    # An array for optional fields
+    def self.optionals
+      %w[
+        addon_parent_external_item_id
+        extended_attributes
+        gift_wrapping
+      ]
+    end
+
+    # An array for nullable fields
+    def self.nullables
+      []
+    end
+
+    def initialize(external_item_id = nil, price = nil, product_id = nil,
+                   addon_parent_external_item_id = SKIP,
+                   extended_attributes = SKIP, gift_wrapping = SKIP)
+      unless addon_parent_external_item_id == SKIP
+        @addon_parent_external_item_id =
+          addon_parent_external_item_id
+      end
+      @extended_attributes = extended_attributes unless extended_attributes == SKIP
+      @external_item_id = external_item_id
+      @gift_wrapping = gift_wrapping unless gift_wrapping == SKIP
+      @price = price
+      @product_id = product_id
+    end
+
+    # Creates an instance of the object from a hash.
+    def self.from_hash(hash)
+      return nil unless hash
+
+      # Extract variables from the hash.
+      external_item_id =
+        hash.key?('external_item_id') ? hash['external_item_id'] : nil
+      price = InjectedOrderShipmentItemPrice.from_hash(hash['price']) if hash['price']
+      product_id = hash.key?('product_id') ? hash['product_id'] : nil
+      addon_parent_external_item_id =
+        hash.key?('addon_parent_external_item_id') ? hash['addon_parent_external_item_id'] : SKIP
+      # Parameter is an array, so we need to iterate through it
+      extended_attributes = nil
+      unless hash['extended_attributes'].nil?
+        extended_attributes = []
+        hash['extended_attributes'].each do |structure|
+          extended_attributes << (InjectedOrderExtendedAttribute.from_hash(structure) if structure)
+        end
+      end
+
+      extended_attributes = SKIP unless hash.key?('extended_attributes')
+      gift_wrapping = GiftWrapping1.from_hash(hash['gift_wrapping']) if hash['gift_wrapping']
+
+      # Create object from extracted values.
+      InjectedOrderShipmentItem.new(external_item_id,
+                                    price,
+                                    product_id,
+                                    addon_parent_external_item_id,
+                                    extended_attributes,
+                                    gift_wrapping)
+    end
+
+    # Validates an instance of the object from a given value.
+    # @param [InjectedOrderShipmentItem | Hash] The value against the validation is performed.
+    def self.validate(value)
+      if value.instance_of? self
+        return (
+          APIHelper.valid_type?(value.external_item_id,
+                                ->(val) { val.instance_of? String }) and
+            APIHelper.valid_type?(value.price,
+                                  ->(val) { InjectedOrderShipmentItemPrice.validate(val) },
+                                  is_model_hash: true) and
+            APIHelper.valid_type?(value.product_id,
+                                  ->(val) { val.instance_of? String })
+        )
+      end
+
+      return false unless value.instance_of? Hash
+
+      (
+        APIHelper.valid_type?(value['external_item_id'],
+                              ->(val) { val.instance_of? String }) and
+          APIHelper.valid_type?(value['price'],
+                                ->(val) { InjectedOrderShipmentItemPrice.validate(val) },
+                                is_model_hash: true) and
+          APIHelper.valid_type?(value['product_id'],
+                                ->(val) { val.instance_of? String })
+      )
+    end
+
+    # Provides a human-readable string representation of the object.
+    def to_s
+      class_name = self.class.name.split('::').last
+      "<#{class_name} addon_parent_external_item_id: #{@addon_parent_external_item_id},"\
+      " extended_attributes: #{@extended_attributes}, external_item_id: #{@external_item_id},"\
+      " gift_wrapping: #{@gift_wrapping}, price: #{@price}, product_id: #{@product_id}>"
+    end
+
+    # Provides a debugging-friendly string with detailed object information.
+    def inspect
+      class_name = self.class.name.split('::').last
+      "<#{class_name} addon_parent_external_item_id: #{@addon_parent_external_item_id.inspect},"\
+      " extended_attributes: #{@extended_attributes.inspect}, external_item_id:"\
+      " #{@external_item_id.inspect}, gift_wrapping: #{@gift_wrapping.inspect}, price:"\
+      " #{@price.inspect}, product_id: #{@product_id.inspect}>"
+    end
+  end
+end

data/lib/new_store_api/models/injected_order_shipment_item_price.rb

@@ -0,0 +1,169 @@
+# new_store_api
+#
+# This file was automatically generated for NewStore by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module NewStoreApi
+  # InjectedOrderShipmentItemPrice Model.
+  class InjectedOrderShipmentItemPrice < BaseModel
+    SKIP = Object.new
+    private_constant :SKIP
+
+    # A reference to a group (bundle) if group pricing was used for the item.
+    # @return [String]
+    attr_accessor :group_ref
+
+    # Information about item-level discounts applied to the items.
+    # @return [Array[Object]]
+    attr_accessor :item_discount_info
+
+    # Price from the default pricebook.
+    # @return [Float]
+    attr_accessor :item_list_price
+
+    # Information about order-level discounts applied to the item. An order
+    # level discount is prorated for all the items across all shipments.
+    # @return [Array[Object]]
+    attr_accessor :item_order_discount_info
+
+    # Price of the item, including taxes or not, depending on the value of the
+    # `price_method` property. Can be affected by pricebooks and bundle pricing.
+    # @return [Float]
+    attr_accessor :item_price
+
+    # Describes the taxes applied to the item.
+    # @return [Array[InjectedOrderItemTaxLine]]
+    attr_accessor :item_tax_lines
+
+    # A reference to the pricebook used to calculate the catalog price.
+    # @return [String]
+    attr_accessor :pricebook
+
+    # A mapping from model property names to API property names.
+    def self.names
+      @_hash = {} if @_hash.nil?
+      @_hash['group_ref'] = 'group_ref'
+      @_hash['item_discount_info'] = 'item_discount_info'
+      @_hash['item_list_price'] = 'item_list_price'
+      @_hash['item_order_discount_info'] = 'item_order_discount_info'
+      @_hash['item_price'] = 'item_price'
+      @_hash['item_tax_lines'] = 'item_tax_lines'
+      @_hash['pricebook'] = 'pricebook'
+      @_hash
+    end
+
+    # An array for optional fields
+    def self.optionals
+      %w[
+        group_ref
+        item_discount_info
+        item_order_discount_info
+        pricebook
+      ]
+    end
+
+    # An array for nullable fields
+    def self.nullables
+      []
+    end
+
+    def initialize(item_list_price = nil, item_price = nil,
+                   item_tax_lines = nil, group_ref = SKIP,
+                   item_discount_info = SKIP, item_order_discount_info = SKIP,
+                   pricebook = 'default')
+      @group_ref = group_ref unless group_ref == SKIP
+      @item_discount_info = item_discount_info unless item_discount_info == SKIP
+      @item_list_price = item_list_price
+      @item_order_discount_info = item_order_discount_info unless item_order_discount_info == SKIP
+      @item_price = item_price
+      @item_tax_lines = item_tax_lines
+      @pricebook = pricebook unless pricebook == SKIP
+    end
+
+    # Creates an instance of the object from a hash.
+    def self.from_hash(hash)
+      return nil unless hash
+
+      # Extract variables from the hash.
+      item_list_price =
+        hash.key?('item_list_price') ? hash['item_list_price'] : nil
+      item_price = hash.key?('item_price') ? hash['item_price'] : nil
+      # Parameter is an array, so we need to iterate through it
+      item_tax_lines = nil
+      unless hash['item_tax_lines'].nil?
+        item_tax_lines = []
+        hash['item_tax_lines'].each do |structure|
+          item_tax_lines << (InjectedOrderItemTaxLine.from_hash(structure) if structure)
+        end
+      end
+
+      item_tax_lines = nil unless hash.key?('item_tax_lines')
+      group_ref = hash.key?('group_ref') ? hash['group_ref'] : SKIP
+      item_discount_info = hash.key?('item_discount_info') ? APIHelper.deserialize_union_type(
+        UnionTypeLookUp.get(:InjectedOrderDiscountInfo2), hash['item_discount_info']
+      ) : SKIP
+      item_order_discount_info = hash.key?('item_order_discount_info') ? APIHelper.deserialize_union_type(
+        UnionTypeLookUp.get(:InjectedOrderDiscountInfo2), hash['item_order_discount_info']
+      ) : SKIP
+      pricebook = hash['pricebook'] ||= 'default'
+
+      # Create object from extracted values.
+      InjectedOrderShipmentItemPrice.new(item_list_price,
+                                         item_price,
+                                         item_tax_lines,
+                                         group_ref,
+                                         item_discount_info,
+                                         item_order_discount_info,
+                                         pricebook)
+    end
+
+    # Validates an instance of the object from a given value.
+    # @param [InjectedOrderShipmentItemPrice | Hash] The value against the validation is performed.
+    def self.validate(value)
+      if value.instance_of? self
+        return (
+          APIHelper.valid_type?(value.item_list_price,
+                                ->(val) { val.instance_of? Float }) and
+            APIHelper.valid_type?(value.item_price,
+                                  ->(val) { val.instance_of? Float }) and
+            APIHelper.valid_type?(value.item_tax_lines,
+                                  ->(val) { InjectedOrderItemTaxLine.validate(val) },
+                                  is_model_hash: true,
+                                  is_inner_model_hash: true)
+        )
+      end
+
+      return false unless value.instance_of? Hash
+
+      (
+        APIHelper.valid_type?(value['item_list_price'],
+                              ->(val) { val.instance_of? Float }) and
+          APIHelper.valid_type?(value['item_price'],
+                                ->(val) { val.instance_of? Float }) and
+          APIHelper.valid_type?(value['item_tax_lines'],
+                                ->(val) { InjectedOrderItemTaxLine.validate(val) },
+                                is_model_hash: true,
+                                is_inner_model_hash: true)
+      )
+    end
+
+    # Provides a human-readable string representation of the object.
+    def to_s
+      class_name = self.class.name.split('::').last
+      "<#{class_name} group_ref: #{@group_ref}, item_discount_info: #{@item_discount_info},"\
+      " item_list_price: #{@item_list_price}, item_order_discount_info:"\
+      " #{@item_order_discount_info}, item_price: #{@item_price}, item_tax_lines:"\
+      " #{@item_tax_lines}, pricebook: #{@pricebook}>"
+    end
+
+    # Provides a debugging-friendly string with detailed object information.
+    def inspect
+      class_name = self.class.name.split('::').last
+      "<#{class_name} group_ref: #{@group_ref.inspect}, item_discount_info:"\
+      " #{@item_discount_info.inspect}, item_list_price: #{@item_list_price.inspect},"\
+      " item_order_discount_info: #{@item_order_discount_info.inspect}, item_price:"\
+      " #{@item_price.inspect}, item_tax_lines: #{@item_tax_lines.inspect}, pricebook:"\
+      " #{@pricebook.inspect}>"
+    end
+  end
+end

data/lib/new_store_api/models/injected_order_shipping_option.rb

@@ -0,0 +1,139 @@
+# new_store_api
+#
+# This file was automatically generated for NewStore by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module NewStoreApi
+  # InjectedOrderShippingOption Model.
+  class InjectedOrderShippingOption < BaseModel
+    SKIP = Object.new
+    private_constant :SKIP
+
+    # Information about shipping discounts applied to the shipment.
+    # @return [Array[Object]]
+    attr_accessor :discount_info
+
+    # The price of the shipping option before discounts. It might include taxes
+    # depending on the tax method and the `price_method` property.
+    # @return [Float]
+    attr_accessor :price
+
+    # The strategy used to route the order. If no value is specified, the
+    # default strategy is used and the order is routed to the best location
+    # based on the fulfillment configuration.
+    # @return [Object]
+    attr_accessor :routing_strategy
+
+    # Service level identifier of the shipping option. Set it to
+    # IN_STORE_HANDOVER in case of injecting an in-store purchase order. The
+    # order will be soft-routed on injection unless config
+    # order_injection/skip_soft_routing_on_injection is enabled. Note that this
+    # option will NOT work if there are multiple shipments. In which case, use
+    # the other payload that requires a shipping option token.
+    # @return [String]
+    attr_accessor :service_level_identifier
+
+    # The tax applied to the shipping option.
+    # @return [Float]
+    attr_accessor :tax
+
+    # A mapping from model property names to API property names.
+    def self.names
+      @_hash = {} if @_hash.nil?
+      @_hash['discount_info'] = 'discount_info'
+      @_hash['price'] = 'price'
+      @_hash['routing_strategy'] = 'routing_strategy'
+      @_hash['service_level_identifier'] = 'service_level_identifier'
+      @_hash['tax'] = 'tax'
+      @_hash
+    end
+
+    # An array for optional fields
+    def self.optionals
+      %w[
+        discount_info
+        routing_strategy
+      ]
+    end
+
+    # An array for nullable fields
+    def self.nullables
+      []
+    end
+
+    def initialize(price = nil, service_level_identifier = nil, tax = nil,
+                   discount_info = SKIP, routing_strategy = SKIP)
+      @discount_info = discount_info unless discount_info == SKIP
+      @price = price
+      @routing_strategy = routing_strategy unless routing_strategy == SKIP
+      @service_level_identifier = service_level_identifier
+      @tax = tax
+    end
+
+    # Creates an instance of the object from a hash.
+    def self.from_hash(hash)
+      return nil unless hash
+
+      # Extract variables from the hash.
+      price = hash.key?('price') ? hash['price'] : nil
+      service_level_identifier =
+        hash.key?('service_level_identifier') ? hash['service_level_identifier'] : nil
+      tax = hash.key?('tax') ? hash['tax'] : nil
+      discount_info = hash.key?('discount_info') ? APIHelper.deserialize_union_type(
+        UnionTypeLookUp.get(:InjectedOrderDiscountInfo2), hash['discount_info']
+      ) : SKIP
+      routing_strategy = hash.key?('routing_strategy') ? APIHelper.deserialize_union_type(
+        UnionTypeLookUp.get(:InjectedOrderRoutingStrategy3), hash['routing_strategy']
+      ) : SKIP
+
+      # Create object from extracted values.
+      InjectedOrderShippingOption.new(price,
+                                      service_level_identifier,
+                                      tax,
+                                      discount_info,
+                                      routing_strategy)
+    end
+
+    # Validates an instance of the object from a given value.
+    # @param [InjectedOrderShippingOption | Hash] The value against the validation is performed.
+    def self.validate(value)
+      if value.instance_of? self
+        return (
+          APIHelper.valid_type?(value.price,
+                                ->(val) { val.instance_of? Float }) and
+            APIHelper.valid_type?(value.service_level_identifier,
+                                  ->(val) { val.instance_of? String }) and
+            APIHelper.valid_type?(value.tax,
+                                  ->(val) { val.instance_of? Float })
+        )
+      end
+
+      return false unless value.instance_of? Hash
+
+      (
+        APIHelper.valid_type?(value['price'],
+                              ->(val) { val.instance_of? Float }) and
+          APIHelper.valid_type?(value['service_level_identifier'],
+                                ->(val) { val.instance_of? String }) and
+          APIHelper.valid_type?(value['tax'],
+                                ->(val) { val.instance_of? Float })
+      )
+    end
+
+    # Provides a human-readable string representation of the object.
+    def to_s
+      class_name = self.class.name.split('::').last
+      "<#{class_name} discount_info: #{@discount_info}, price: #{@price}, routing_strategy:"\
+      " #{@routing_strategy}, service_level_identifier: #{@service_level_identifier}, tax:"\
+      " #{@tax}>"
+    end
+
+    # Provides a debugging-friendly string with detailed object information.
+    def inspect
+      class_name = self.class.name.split('::').last
+      "<#{class_name} discount_info: #{@discount_info.inspect}, price: #{@price.inspect},"\
+      " routing_strategy: #{@routing_strategy.inspect}, service_level_identifier:"\
+      " #{@service_level_identifier.inspect}, tax: #{@tax.inspect}>"
+    end
+  end
+end