aftership-tracking-sdk 13.0.0 → 15.0.0

data/lib/aftership-tracking-sdk/models/estimated_delivery_date_request_origin_address.rb

@@ -6,7 +6,7 @@ module AftershipAPI::Model
     # country_region: String;
     attr_accessor :country_region
 
-    # State, province, or the equivalent location of the origin address. Use 3 letters of ISO 3166-1 country/region code for countries/regions without state. Either `origin_address.state` or `origin_address.postal_code` is required.
+    # State, province, or the equivalent location of the origin address. Use 3 letters of ISO 3166-1 country/region code for countries/regions without state. </br><span style=color:#ff6b2b;padding:2px>**Either `origin_address.state` or `origin_address.postal_code` is required.**</span>
     # state?: String;
     attr_accessor :state
 
@@ -14,7 +14,7 @@ module AftershipAPI::Model
     # city?: String;
     attr_accessor :city
 
-    # Postal code of the origin address. Use 3 letters of ISO 3166-1 country/region code for countries/regions without postal code. Either `origin_address.state` or `origin_address.postal_code` is required.
+    # Postal code of the origin address. Use 3 letters of ISO 3166-1 country/region code for countries/regions without postal code. </br><span style=color:#ff6b2b;padding:2px>**Either `origin_address.state` or `origin_address.postal_code` is required.**</span>
     # postal_code?: String;
     attr_accessor :postal_code
 

data/lib/aftership-tracking-sdk/models/tracking.rb

@@ -122,6 +122,10 @@ module AftershipAPI::Model
     # shipment_weight?: TrackingShipmentWeight;
     attr_accessor :shipment_weight
 
+    # Physical dimensions of the package (length, width and height).
+    # shipment_dimensions?: TrackingShipmentDimensions;
+    attr_accessor :shipment_dimensions
+
     # Signed by information for delivered shipment.
     # signed_by?: String;
     attr_accessor :signed_by
@@ -150,10 +154,6 @@ module AftershipAPI::Model
     # tracked_count?: Float;
     attr_accessor :tracked_count
 
-    # Indicates if the shipment is trackable till the final destination.Three possible values:- true- false- null
-    # last_mile_tracking_supported?: Boolean;
-    attr_accessor :last_mile_tracking_supported
-
     # The recipient’s language. If you set up AfterShip notifications in different languages, we use this to send the recipient tracking updates in their preferred language.
     # language?: String;
     attr_accessor :language
@@ -178,8 +178,8 @@ module AftershipAPI::Model
     # return_to_sender?: Boolean;
     attr_accessor :return_to_sender
 
-    # The promised delivery date of the order. It uses the formats:- YYYY-MM-DD- YYYY-MM-DDTHH:mm:ss- YYYY-MM-DDTHH:mm:ssZ
-    # order_promised_delivery_date?: String;
+    # The promised delivery date of the order in shipment recipient’s timezone.
+    # order_promised_delivery_date?: TrackingOrderPromisedDeliveryDate;
     attr_accessor :order_promised_delivery_date
 
     # Shipment delivery type- pickup_at_store- pickup_at_courier- door_to_door
@@ -302,6 +302,26 @@ module AftershipAPI::Model
     # customers?: TrackingCustomers[];
     attr_accessor :customers
 
+    # An array of proof of delivery (POD) records, such as a signature or photo captured upon successful delivery.This field returns a value only after the feature is enabled. Please contact your customer success manager if you'd like to know more.
+    # proof_of_delivery?: TrackingProofOfDelivery[];
+    attr_accessor :proof_of_delivery
+
+    # Multi-piece shipment refers to a scenario where a single shipment order is fulfilled by multiple physical packages. Each piece has its own carrier-assigned tracking number, but all pieces belong to the same shipment. This commonly occurs when an order is too large to fit in one box, or when items are packed separately for handling reasons.This field contains multi-piece shipment metadata describing a group of packages that belong to the same shipment.This field returns a value only when your subscription plan includes a multi-piece feature. To enable, go to .
+    # multi_piece_info?: TrackingMultiPieceInfo;
+    attr_accessor :multi_piece_info
+
+    # Indicates the business direction of the shipment in the e-commerce fulfillment lifecycle.Possible values:- `forward`: A forward (outbound-to-customer) shipment created for order fulfillment.- `return`: A return (customer-to-merchant) shipment created for after-sales return or exchange.This field is populated in either of the following cases:1. You explicitly provided it when creating the tracking.2. AfterShip automatically detected a linked forward or return shipment.It also determines which related shipment object (`forward_shipment` or `return_shipment`) may appear in the response.
+    # shipment_direction?: TrackingShipmentDirection;
+    attr_accessor :shipment_direction
+
+    # The associated return shipment linked to the current outbound shipment.This field is only present when `shipment_direction = "forward"` and AfterShip has detected a linked return shipment.
+    # return_shipment?: TrackingReturnShipment;
+    attr_accessor :return_shipment
+
+    # The original outbound shipment linked to this return. Use this to trace a return back to its source delivery.This field is only present when `shipment_direction = "return"` and AfterShip has detected a linked forward shipment.
+    # forward_shipment?: TrackingForwardShipment;
+    attr_accessor :forward_shipment
+
     # Initializes the object
     # @param [Hash] attributes Model attributes in the form of hash
     def initialize(attributes = {})
@@ -433,6 +453,10 @@ module AftershipAPI::Model
         self.shipment_weight = attributes[:'shipment_weight']
       end
 
+      if attributes.key?(:'shipment_dimensions')
+        self.shipment_dimensions = attributes[:'shipment_dimensions']
+      end
+
       if attributes.key?(:'signed_by')
         self.signed_by = attributes[:'signed_by']
       end
@@ -461,10 +485,6 @@ module AftershipAPI::Model
         self.tracked_count = attributes[:'tracked_count']
       end
 
-      if attributes.key?(:'last_mile_tracking_supported')
-        self.last_mile_tracking_supported = attributes[:'last_mile_tracking_supported']
-      end
-
       if attributes.key?(:'language')
         self.language = attributes[:'language']
       end
@@ -612,6 +632,26 @@ module AftershipAPI::Model
       if attributes.key?(:'customers')
         self.customers = attributes[:'customers']
       end
+
+      if attributes.key?(:'proof_of_delivery')
+        self.proof_of_delivery = attributes[:'proof_of_delivery']
+      end
+
+      if attributes.key?(:'multi_piece_info')
+        self.multi_piece_info = attributes[:'multi_piece_info']
+      end
+
+      if attributes.key?(:'shipment_direction')
+        self.shipment_direction = attributes[:'shipment_direction']
+      end
+
+      if attributes.key?(:'return_shipment')
+        self.return_shipment = attributes[:'return_shipment']
+      end
+
+      if attributes.key?(:'forward_shipment')
+        self.forward_shipment = attributes[:'forward_shipment']
+      end
     end
 
     # Attribute type mapping.
@@ -647,6 +687,7 @@ module AftershipAPI::Model
         :'shipment_delivery_date' => :'String',
         :'shipment_type' => :'String',
         :'shipment_weight' => :'TrackingShipmentWeight',
+        :'shipment_dimensions' => :'TrackingShipmentDimensions',
         :'signed_by' => :'String',
         :'source' => :'String',
         :'tag' => :'Tag',
@@ -654,14 +695,13 @@ module AftershipAPI::Model
         :'subtag_message' => :'String',
         :'title' => :'String',
         :'tracked_count' => :'Float',
-        :'last_mile_tracking_supported' => :'Boolean',
         :'language' => :'String',
         :'unique_token' => :'String',
         :'checkpoints' => :'Array<Checkpoint>',
         :'subscribed_smses' => :'Array<String>',
         :'subscribed_emails' => :'Array<String>',
         :'return_to_sender' => :'Boolean',
-        :'order_promised_delivery_date' => :'String',
+        :'order_promised_delivery_date' => :'TrackingOrderPromisedDeliveryDate',
         :'delivery_type' => :'String',
         :'pickup_location' => :'String',
         :'pickup_note' => :'String',
@@ -692,6 +732,11 @@ module AftershipAPI::Model
         :'first_mile' => :'TrackingFirstMile',
         :'last_mile' => :'TrackingLastMile',
         :'customers' => :'Array<TrackingCustomers>',
+        :'proof_of_delivery' => :'Array<TrackingProofOfDelivery>',
+        :'multi_piece_info' => :'TrackingMultiPieceInfo',
+        :'shipment_direction' => :'TrackingShipmentDirection',
+        :'return_shipment' => :'TrackingReturnShipment',
+        :'forward_shipment' => :'TrackingForwardShipment',
       }
     end
 
@@ -728,6 +773,7 @@ module AftershipAPI::Model
         :'shipment_delivery_date' => :'shipment_delivery_date',
         :'shipment_type' => :'shipment_type',
         :'shipment_weight' => :'shipment_weight',
+        :'shipment_dimensions' => :'shipment_dimensions',
         :'signed_by' => :'signed_by',
         :'source' => :'source',
         :'tag' => :'tag',
@@ -735,7 +781,6 @@ module AftershipAPI::Model
         :'subtag_message' => :'subtag_message',
         :'title' => :'title',
         :'tracked_count' => :'tracked_count',
-        :'last_mile_tracking_supported' => :'last_mile_tracking_supported',
         :'language' => :'language',
         :'unique_token' => :'unique_token',
         :'checkpoints' => :'checkpoints',
@@ -773,6 +818,11 @@ module AftershipAPI::Model
         :'first_mile' => :'first_mile',
         :'last_mile' => :'last_mile',
         :'customers' => :'customers',
+        :'proof_of_delivery' => :'proof_of_delivery',
+        :'multi_piece_info' => :'multi_piece_info',
+        :'shipment_direction' => :'shipment_direction',
+        :'return_shipment' => :'return_shipment',
+        :'forward_shipment' => :'forward_shipment',
       }
     end
 

data/lib/aftership-tracking-sdk/models/tracking_customers.rb

@@ -22,6 +22,10 @@ module AftershipAPI::Model
     # language?: String;
     attr_accessor :language
 
+    # The customer's identifier on the merchant or platform (for example, Shopify) side.
+    # id?: String;
+    attr_accessor :id
+
     # Initializes the object
     # @param [Hash] attributes Model attributes in the form of hash
     def initialize(attributes = {})
@@ -52,6 +56,10 @@ module AftershipAPI::Model
       if attributes.key?(:'language')
         self.language = attributes[:'language']
       end
+
+      if attributes.key?(:'id')
+        self.id = attributes[:'id']
+      end
     end
 
     # Attribute type mapping.
@@ -62,6 +70,7 @@ module AftershipAPI::Model
         :'phone_number' => :'String',
         :'email' => :'String',
         :'language' => :'String',
+        :'id' => :'String',
       }
     end
 
@@ -73,6 +82,7 @@ module AftershipAPI::Model
         :'phone_number' => :'phone_number',
         :'email' => :'email',
         :'language' => :'language',
+        :'id' => :'id',
       }
     end
 

data/lib/aftership-tracking-sdk/models/tracking_forward_shipment.rb

@@ -0,0 +1,151 @@
+# This code was auto generated by AfterShip SDK Generator.
+# Do not edit the class manually.
+module AftershipAPI::Model
+  class TrackingForwardShipment
+    # AfterShip system-assigned unique identifier of the linked outbound shipment.
+    # id?: String;
+    attr_accessor :id
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `AftershipAPI::TrackingForwardShipment` initialize method"
+      end
+
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'id')
+        self.id = attributes[:'id']
+      end
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'id' => :'String',
+      }
+    end
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'id' => :'id',
+      }
+    end
+
+    # Builds the object from hash
+    # @param attributes [Hash] Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(key) && attributes[key].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[key].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[key].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[key].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[key])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Deserializes the data based on type
+    # @param type [String] Data type
+    # @param value [String] Value to be deserialized
+    # @return [Object] Deserialized data
+    def self._deserialize(type, value)
+      case type.to_sym
+      when :Time
+        Time.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :Boolean
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        klass = AftershipAPI::Model.const_get(type)
+        klass.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param value [Object] Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+    def to_json(*a)
+      to_hash.to_json(*a)
+    end
+  end
+end

data/lib/aftership-tracking-sdk/models/tracking_multi_piece_info.rb

@@ -0,0 +1,161 @@
+# This code was auto generated by AfterShip SDK Generator.
+# Do not edit the class manually.
+module AftershipAPI::Model
+  class TrackingMultiPieceInfo
+    # Indicates the role of the current tracking object within the multi-piece shipment.Possible values:- `master`: The main tracking number representing the entire shipment. It may not always exist.- `child`: A sub-tracking number belonging to one of the pieces in the shipment.
+    # type?: TrackingMultiPieceInfoType;
+    attr_accessor :type
+
+    # List of all pieces in the MPS, including the master and all child pieces.
+    # pieces?: TrackingMultiPieceInfoPieces[];
+    attr_accessor :pieces
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `AftershipAPI::TrackingMultiPieceInfo` initialize method"
+      end
+
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'type')
+        self.type = attributes[:'type']
+      end
+
+      if attributes.key?(:'pieces')
+        self.pieces = attributes[:'pieces']
+      end
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'type' => :'TrackingMultiPieceInfoType',
+        :'pieces' => :'Array<TrackingMultiPieceInfoPieces>',
+      }
+    end
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'type' => :'type',
+        :'pieces' => :'pieces',
+      }
+    end
+
+    # Builds the object from hash
+    # @param attributes [Hash] Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(key) && attributes[key].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[key].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[key].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[key].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[key])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Deserializes the data based on type
+    # @param type [String] Data type
+    # @param value [String] Value to be deserialized
+    # @return [Object] Deserialized data
+    def self._deserialize(type, value)
+      case type.to_sym
+      when :Time
+        Time.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :Boolean
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        klass = AftershipAPI::Model.const_get(type)
+        klass.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param value [Object] Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+    def to_json(*a)
+      to_hash.to_json(*a)
+    end
+  end
+end