peddler 5.0.0.pre.2 → 5.0.0.pre.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20b378be071f3a0cade83e11f4c9970aa5d00ad4077097fd4ac22d709b20bf3d
-  data.tar.gz: 86420f4e6823a302e9785c2f795714f3769dce647e7880dcdee0bf5cdfd6b94b
+  metadata.gz: 5a92ebec97b53b45e1eff33494b844fe2eb578ba62b93cf20eaa7b062085f0f1
+  data.tar.gz: c2bc809cda80a7dd1d315fbf64d8416b66797ef3fffdb6579e2b4aedcd6ca5a2
 SHA512:
-  metadata.gz: 6cd309742cd1cc9594c570171553137ab43966cb3060f1af36a6da17a8c15f56cb4f93cd60f06bb06425a05e2d97108209f4e164890c5d574fabe0ac237e62c5
-  data.tar.gz: c5762d1e6b36d83dd7cbc0348d3ae6500bc983015e5efdd6c772d56d853aa8155f92a485e8292f2d4acc2501c333437685dd41fde8871d13f247b6db812ae518
+  metadata.gz: ee97d6201c41796488f74d21909d5a604c5aa6ea7d3557193cc3d4278255e0912904fc37932685dc92bbcf2464b54963e09f736461f1d2a28d87071cfe6b5e87
+  data.tar.gz: 56897e80705274a926c4954e92a2c81db8f958d6e71d6e46e14b76b493faa98029259e7676beb668e517428a4539a81f326b8a9188f74e320a73da9cd3544d88

data/README.md

@@ -2,15 +2,16 @@
 
 [![Build](https://github.com/lineofflight/peddler/actions/workflows/ci.yml/badge.svg)][build]
 
-> **IMPORTANT:** This README is for the v5.0.0.pre.1 pre-release. For the latest stable version, see the [v4.9.0 README](https://github.com/hakanensari/peddler/blob/v4.9.0/README.md).
+> **IMPORTANT:** This README is for the v5 pre-release. For the latest stable version, see the [v4.9.0 README](https://github.com/hakanensari/peddler/blob/v4.9.0/README.md).
 
-**Peddler** is a Ruby interface to the [Amazon Selling Partner API (SP-API)][docs-overview]. The SP-API enables Amazon sellers and vendors to programmatically access their data on orders, shipments, payments, and more.
+**Peddler** is a Ruby interface to the [Amazon Selling Partner API (SP-API)][api-docs]. The SP-API enables Amazon sellers and vendors to programmatically access their data on orders, shipments, payments, and more.
 
 Peddler is automatically generated from the latest Open API models provided by Amazon.
 
 To begin using the Amazon SP-API, you must [register as a developer][register-as-developer] and [register your application][register-application]. Once registered, [obtain your Login with Amazon (LWA) credentials][view-credentials] to access your own or other selling partners' data.
 
-- [API models][api-models]
+- [API docs][api-docs]
+- [Swagger models][swagger-models]
 - [API samples][api-samples]
 
 <img src="https://github.com/hakanensari/peddler/blob/main/images/peddler.jpg?raw=true" alt="Peddler" style="max-width: 830px" />
@@ -20,7 +21,7 @@ To begin using the Amazon SP-API, you must [register as a developer][register-as
 Add this line to your Gemfile.
 
 ```ruby
-gem "peddler", "~> 5.0.0.pre.1"
+gem "peddler", "~> 5.0.0.pre.4"
 ```
 
 And then execute:
@@ -44,46 +45,44 @@ Require the library.
 require "peddler"
 ```
 
-You can also require individual API libraries to reduce load time:
-
-```ruby
-require "peddler/apis/orders_v0"
-```
-
 ### Authorization
 
 A seller or vendor [provides you a refresh token][authorization] to access their data on Amazon.
 
 ```ruby
-refresh_token = Peddler::LWA.request(
+response = Peddler::LWA.request(
   code: "<AUTHORIZATION_CODE>"
-).parse.refresh_token
+)
+refresh_token = response.parse.refresh_token
 ```
 
 You use this to generate a temporary access token to authenticate individual API requests.
 
 ```ruby
-access_token = Peddler::LWA.request(
+response = Peddler::LWA.request(
   refresh_token: "<REFRESH_TOKEN>",
-).parse.access_token
+)
+access_token = response.parse.access_token
 ```
 
 Similarly, you can request a token for grantless operations.
 
 ```ruby
-access_token = Peddler::LWA.request(
+response = Peddler::LWA.request(
   scope: "sellingpartnerapi::notifications",
-).parse.access_token
+)
+access_token = response.parse.access_token
 ```
 
 If you haven't set your LWA credentials as environment variables, pass them directly when requesting the token.
 
 ```ruby
-access_token = Peddler::LWA.request(
+response = Peddler::LWA.request(
   client_id: "<YOUR_CLIENT_ID>",
   client_secret: "<YOUR_CLIENT_SECRET>",
   refresh_token: "<REFRESH_TOKEN>",
-).parse.access_token
+)
+access_token = response.parse.access_token
 ```
 
 Access tokens are valid for one hour. To optimize performance, cache the token and reuse across calls.
@@ -92,13 +91,11 @@ In Rails, if you're storing a refresh token in a model representing a selling pa
 
 ```ruby
 class Seller
-  "..."
+  attr_reader :refresh_token
 
   def access_token
     Rails.cache.fetch("#{cache_key}/access_key", expires_in: 1.hour) do
-      Peddler::LWA.request(
-        refresh_token:,
-      ).parse.access_token
+      Peddler::LWA.request(refresh_token:).parse.access_token
     end
   end
 end
@@ -207,19 +204,14 @@ response = api.get_orders(
   marketplaceIds: ["ATVPDKIKX0DER"],
   createdAfter: "2023-01-01T00:00:00Z"
 )
+orders = response.parse.payload.orders
+order_id = orders.first.amazon_order_id
 
-# Use the `dig` method to safely navigate through nested response data
-# This returns nil instead of raising an error if any key in the path doesn't exist
+# Or use .to_h or .dig to parse response as a hash
 orders = response.dig("payload", "orders")
-
-# You can chain multiple keys to access deeply nested data
-first_order_id = response.dig("payload", "orders", 0, "amazonOrderId")
-
-# This is safer than using chain indexing which would raise an error if any part is missing:
-# response.parse["payload"]["orders"][0]["amazonOrderId"]  # Error prone!
+order_id = response.dig("payload", "orders", 0, "amazonOrderId")
 
 # For sandbox testing
-api = Peddler.orders.new(aws_region, access_token)
 api.sandbox.get_orders(
   marketplaceIds: ["ATVPDKIKX0DER"],
   createdAfter: "TEST_CASE_200"
@@ -242,7 +234,7 @@ response = api.get_catalog_item(
   marketplaceIds: ["ATVPDKIKX0DER"],
   asin: "B08N5WRWNW"
 )
-item_details = response.dig("payload")
+response.parse.payload.asin # => "B08N5WRWNW"
 
 # Search catalog items by identifier
 response = api.search_catalog_items(
@@ -300,7 +292,7 @@ api.create_fulfillment_order(
 - **Feeds API (2021-06-30)**: Upload data to Amazon to update listings, prices, inventory, and more
 - **Reports API (2021-06-30)**: Request and download reports about orders, inventory, fulfillment, and more
 - **Uploads API (2020-11-01)**: Upload files for various SP-API operations
-- **Data Kiosk API (2023-11-15)**: Access and manage analytical data
+- **Data Kiosk API (2023-11-15, 2024-03-15, 2024-04-24, 2024-09-30)**: Access and manage analytical data with GraphQL queries
 
 ```ruby
 api = Peddler.feeds.new(aws_region, access_token)
@@ -399,6 +391,222 @@ json_feed_content = JSON.generate({
 api.upload_feed_document(json_document.dig("url"), json_feed_content, "application/json; charset=UTF-8")
 ```
 
+**Parsing Feed Results:**
+
+After feed processing completes, parse the result document with type-safe data classes:
+
+```ruby
+# Get feed processing result document
+result_document = api.get_feed_document(result_feed_document_id)
+result_content = HTTP.get(result_document.dig("url")).to_s
+
+# Handle compression if needed
+if result_document.dig("compressionAlgorithm") == "GZIP"
+  require "zlib"
+  result_content = Zlib::GzipReader.new(StringIO.new(result_content)).read
+end
+
+# Parse with type safety
+result_json = JSON.parse(result_content)
+report = Peddler::Feeds::ListingsFeedProcessingReportSchema.parse(result_json)
+
+# Access structured processing results
+puts "Messages Processed: #{report.summary.messages_processed}"
+puts "Messages Accepted: #{report.summary.messages_accepted}"
+puts "Messages with Errors: #{report.summary.messages_with_error}"
+puts "Messages with Warnings: #{report.summary.messages_with_warning}"
+
+# Iterate through issues with type-safe access
+report.issues.each do |issue|
+  puts "\nIssue in message #{issue.message_id}:"
+  puts "  Severity: #{issue.severity}"
+  puts "  Code: #{issue.code}"
+  puts "  Message: #{issue.message}"
+  puts "  SKU: #{issue.sku}" if issue.sku
+end
+```
+
+#### Data Kiosk API
+
+The Data Kiosk API provides access to Amazon's analytical data through GraphQL queries. Peddler supports four Data Kiosk schema versions, each with type-safe Structure classes for parsing responses.
+
+**Available Schemas:**
+
+- **SalesAndTraffic20231115**: Sales and traffic metrics by ASIN and date
+- **SalesAndTraffic20240424**: Enhanced sales and traffic data (2024)
+- **Economics20240315**: Economics and profitability data
+- **VendorAnalytics20240930**: Vendor-specific analytics and forecasting data
+
+**Basic Example:**
+
+```ruby
+api = Peddler.data_kiosk.new(aws_region, access_token)
+
+# Create a Data Kiosk query request
+response = api.create_query({
+  query: """
+    query {
+      salesAndTrafficByDate(
+        startDate: "2024-01-01",
+        endDate: "2024-01-31",
+        marketplaceIds: ["ATVPDKIKX0DER"]
+      ) {
+        data {
+          date
+          orderItems
+          sales
+          pageViews
+          sessions
+        }
+      }
+    }
+  """
+})
+
+# Get the query ID
+query_id = response.dig("payload", "queryId")
+
+# Poll for query completion
+loop do
+  status = api.get_query(query_id)
+  processing_status = status.dig("payload", "processingStatus")
+  break if ["DONE", "FATAL"].include?(processing_status)
+  sleep 2
+end
+
+# Download the report document
+result_document_id = status.dig("payload", "reportDocumentId")
+document = api.get_report_document(result_document_id)
+report_url = document.dig("url")
+
+# Parse the response
+require "net/http"
+http_response = HTTP.get(report_url)
+parsed_data = JSON.parse(http_response.to_s)
+
+# Use type-safe parsing with Peddler's Structure classes
+sales_data = Peddler::DataKiosk::SalesAndTraffic20231115.parse(parsed_data)
+```
+
+**Query Document Management (Optional):**
+
+Peddler provides a helper method for downloading query documents. Enable this by adding the graphql gem to your Gemfile (optional, only needed for schema validation):
+
+```ruby
+gem "graphql", "~> 2.0"
+```
+
+Then use the helper method:
+
+```ruby
+api = Peddler.data_kiosk.new(aws_region, access_token)
+
+# Download a query document by ID (v2023-11-15 schemas)
+document = api.download_query_document("amzn1.tortuga.3.abc123...")
+
+# Or pass a full URL
+document = api.download_query_document("https://...")
+```
+
+**Type-Safe Response Parsing:**
+
+Each Data Kiosk schema version includes type-safe Structure classes that match the GraphQL response structure:
+
+```ruby
+# Parse economics data
+response_data = JSON.parse(query_response_body)
+analytics = Peddler::DataKiosk::Economics20240315.parse(response_data)
+
+# Access typed attributes
+analytics.analytics_economics_2024_03_15.each do |record|
+  puts "Sales: #{record.sales}"
+  puts "Fees: #{record.fees}"
+  puts "Net Proceeds: #{record.net_proceeds}"
+  puts "Date Range: #{record.start_date} to #{record.end_date}"
+end
+```
+
+**Query Examples by Schema:**
+
+```ruby
+# Sales and Traffic by ASIN (2023-11-15)
+query_sales_asin = """
+  query {
+    salesAndTrafficByAsin(
+      startDate: "2024-01-01",
+      endDate: "2024-01-31",
+      marketplaceIds: ["ATVPDKIKX0DER"]
+    ) {
+      data {
+        startDate
+        endDate
+        parentAsin
+        childAsin
+        sku
+        sales {
+          orderedProductSales
+          totalOrderItems
+          unitsOrdered
+        }
+        traffic {
+          pageViews
+          pageViewsPercentage
+          sessions
+          sessionPercentage
+          unitSessionPercentage
+        }
+      }
+    }
+  }
+"""
+
+# Economics data (2024-03-15)
+query_economics = """
+  query {
+    analytics {
+      economics {
+        data {
+          endDate
+          startDate
+          parentAsin
+          sales {
+            orderedProductSales
+            netProductSales
+          }
+          fees {
+            feeType
+            chargeAmount
+          }
+          netProceeds {
+            total
+            perUnit
+          }
+        }
+      }
+    }
+  }
+"""
+
+# Vendor analytics (2024-09-30)
+query_vendor = """
+  query {
+    analytics {
+      vendoranalytics {
+        manufacturingView {
+          startDate
+          endDate
+          metrics {
+            costs
+            traffic
+            orders
+          }
+        }
+      }
+    }
+  }
+"""
+```
+
 #### Communication and Customer Management APIs
 
 - **Customer Feedback API (2024-06-01)**: Analyze customer reviews and returns data at item and browse node levels
@@ -458,6 +666,28 @@ destinations = sandbox_api.get_destinations
 subscription = sandbox_api.get_subscription("LISTINGS_ITEM_ISSUES_CHANGE")
 ```
 
+**Parsing Notifications:**
+
+Once you receive notifications (via SQS or EventBridge), parse them with type-safe data classes:
+
+```ruby
+# Parse notification from SQS message
+notification_json = JSON.parse(sqs_message.body)
+notification = Peddler::Notifications::AnyOfferChanged.parse(notification_json)
+
+# Type-safe access to notification data
+notification.notification_version  # => "1.0"
+notification.notification_type     # => "ANY_OFFER_CHANGED"
+
+# Access payload with autocomplete
+notification.payload.offers.each do |offer|
+  puts "Seller: #{offer.seller_id}"
+  puts "Price: #{offer.listing_price.amount} #{offer.listing_price.currency_code}"
+  puts "Condition: #{offer.item_condition}"
+  puts "Prime: #{offer.is_prime?}" if offer.respond_to?(:is_prime?)
+end
+```
+
 #### Vendor APIs
 
 APIs for vendors selling to Amazon:
@@ -654,6 +884,94 @@ response = api.download_report_document("DOCUMENT_ID")
 # Process the downloaded report content from response.body...
 ```
 
+#### Understanding Report Types
+
+SP-API provides two different types of reports with different formats and APIs:
+
+**1. Modern JSON-Based Reports** (Recommended)
+
+These are structured analytics reports that return JSON data with defined schemas. Peddler provides type-safe data classes for these reports using the Structure gem.
+
+Examples:
+- Vendor Real-Time Inventory Report
+- Seller Sales and Traffic Report
+- Account Health Report
+- Vendor Forecasting Report
+- Customer Feedback Reports
+
+Location in Peddler: `lib/peddler/reports/` with generated Structure-based classes
+
+```ruby
+# Example: Request and parse a vendor real-time inventory report
+api = Peddler.reports.new(aws_region, access_token)
+
+# Create report request
+report_response = api.create_report({
+  "reportType" => "GET_VENDOR_REAL_TIME_INVENTORY_REPORT",
+  "marketplaceIds" => [Marketplace.id("US")],
+  "reportOptions" => {
+    "reportPeriod" => "WEEK",
+    "distributorView" => "MANUFACTURING",
+    "sellingProgram" => "RETAIL",
+    "startDate" => "2024-01-01",
+    "endDate" => "2024-01-07"
+  }
+})
+
+# Wait for report to be ready, then download
+report_id = report_response.dig("reportId")
+# ... check status until DONE ...
+document_id = api.get_report(report_id).dig("reportDocumentId")
+
+# Download and parse JSON report
+document = api.get_report_document(document_id)
+report_json = HTTP.get(document.dig("url")).parse(:json)
+
+# Use typed data classes
+report = Peddler::Reports::VendorRealTimeInventory::Report.new(report_json)
+report.report_data.each do |data|
+  puts "ASIN: #{data.asin}, Inventory: #{data.highly_available_inventory}"
+end
+```
+
+**2. Legacy Flat-File Reports** (Tab-Delimited)
+
+These are older reports that return tab-delimited text files (TSV format), often GZIP compressed. These require manual CSV parsing and do NOT have Structure-based data classes.
+
+Examples:
+- `GET_MERCHANT_LISTINGS_ALL_DATA`
+- `GET_FBA_MYI_UNSUPPRESSED_INVENTORY_DATA`
+- `GET_FLAT_FILE_ALL_ORDERS_DATA_BY_LAST_UPDATE_GENERAL`
+
+These must be parsed manually using Ruby's CSV library:
+
+```ruby
+# Download flat-file report
+document = api.get_report_document(document_id)
+response = HTTP.get(document.dig("url"))
+
+# Handle GZIP compression if needed
+body = if document.dig("compressionAlgorithm") == "GZIP"
+         Zlib::GzipReader.new(StringIO.new(response.body.to_s)).read
+       else
+         response.body.to_s
+       end
+
+# Parse tab-delimited data
+csv_options = {
+  col_sep: "\t",
+  headers: true,
+  quote_char: "\x00",
+  encoding: "UTF-8"
+}
+CSV.parse(body, **csv_options) do |row|
+  # Process each row as a hash
+  puts "SKU: #{row['sku']}, ASIN: #{row['asin']}, Quantity: #{row['quantity']}"
+end
+```
+
+For a complete list of report types and their formats, see the [Report Type Values documentation](https://developer-docs.amazon.com/sp-api/docs/report-type-values).
+
 #### Sellers API
 
 ```ruby
@@ -663,7 +981,7 @@ api = Peddler.sellers.new(aws_region, access_token)
 participations = api.get_marketplace_participations
 ```
 
-For a complete list of available APIs and their detailed documentation, refer to the [API models repository](https://github.com/amzn/selling-partner-api-models).
+For a complete list of available APIs and their detailed documentation, refer to the [API models repository][swagger-models].
 
 ## Development
 
@@ -679,17 +997,17 @@ bundle exec rake
 bundle exec rake test
 
 # Regenerate API classes from latest Amazon OpenAPI specs
-bin/generate-code
+bundle exec rake generate
 
 # Type check with Steep
 bundle exec steep check --severity-level=hint
 ```
 
 [build]: https://github.com/lineofflight/peddler/actions
-[docs-overview]: https://developer.amazonservices.com/sp-api-docs/overview
+[api-docs]: https://developer.amazonservices.com/sp-api-docs/overview
 [register-as-developer]: https://developer-docs.amazon.com/sp-api/docs/registering-as-a-developer
 [register-application]: https://developer-docs.amazon.com/sp-api/docs/registering-your-application
-[api-models]: https://github.com/amzn/selling-partner-api-models
+[swagger-models]: https://github.com/amzn/selling-partner-api-models
 [api-samples]: https://github.com/amzn/selling-partner-api-samples
 [view-credentials]: https://developer-docs.amazon.com/sp-api/docs/viewing-your-application-information-and-credentials
 [authorization]: https://developer-docs.amazon.com/sp-api/docs/authorizing-selling-partner-api-applications

data/lib/peddler/acronyms.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Peddler
+  # Handles acronym transformations for Amazon SP-API terminology
+  module Acronyms
+    extend self
+
+    # Mapping of camelized forms to their uppercase acronym equivalents
+    MAP = {
+      "Api" => "API",
+      "Asin" => "ASIN",
+      "B2b" => "B2B",
+      "Cgst" => "CGST",
+      "Cod" => "COD",
+      "Fba" => "FBA",
+      "Igst" => "IGST",
+      "Lwa" => "LWA",
+      "Safet" => "SAFET",
+      "Sgst" => "SGST",
+      "Sku" => "SKU",
+      "Tds" => "TDS",
+      "Url" => "URL",
+    }.freeze
+
+    # Transforms acronyms in camelized words to uppercase equivalents. Uses lookahead to prevent partial matches
+    # within words (e.g., "Cod" won't match inside "Code"). Handles singular and plural forms (e.g., "Apis" to "APIs").
+    #
+    # @param word [String]
+    # @return [String]
+    def apply(word)
+      MAP.reduce(word) { |w, (from, to)| w.gsub(/#{from}(s?)(?=[A-Z]|$)/) { "#{to}#{::Regexp.last_match(1)}" } }
+    end
+
+    # @return [Array<String>] Array of uppercase acronyms
+    def values
+      MAP.values
+    end
+  end
+end

data/lib/peddler/api.rb

@@ -3,12 +3,6 @@
 require "http"
 require "uri"
 
-require "peddler/endpoint"
-require "peddler/error"
-require "peddler/marketplace"
-require "peddler/response"
-require "peddler/version"
-
 module Peddler
   # Wraps an Amazon Selling Partner API (SP-API)
   class API

data/lib/peddler/apis/amazon_warehousing_and_distribution_2024_05_09/address.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# This file is generated. Do not edit.
+
+require "structure"
+
+module Peddler
+  module APIs
+    class AmazonWarehousingAndDistribution20240509
+      # Shipping address that represents the origin or destination location.
+      Address = Structure.new do
+        # @return [String] First line of the address text.
+        attribute(:address_line1, String, from: "addressLine1")
+
+        # @return [String] Two-digit, ISO 3166-1 alpha-2 formatted country code where this address is located.
+        attribute(:country_code, String, from: "countryCode")
+
+        # @return [String] Name of the person, business, or institution at this address.
+        attribute(:name, String)
+
+        # @return [String] State or region where this address is located. Note that this is contextual to the specified
+        #   country code.
+        attribute(:state_or_region, String, from: "stateOrRegion")
+
+        # @return [String] Optional second line of the address text.
+        attribute?(:address_line2, String, from: "addressLine2")
+
+        # @return [String] Optional third line of the address text.
+        attribute?(:address_line3, String, from: "addressLine3")
+
+        # @return [String] Optional city where this address is located.
+        attribute?(:city, String)
+
+        # @return [String] Optional county where this address is located.
+        attribute?(:county, String)
+
+        # @return [String] Optional district where this address is located.
+        attribute?(:district, String)
+
+        # @return [String] Optional E.164-formatted phone number for an available contact at this address.
+        attribute?(:phone_number, String, from: "phoneNumber")
+
+        # @return [String] Optional postal code where this address is located.
+        attribute?(:postal_code, String, from: "postalCode")
+      end
+    end
+  end
+end

data/lib/peddler/apis/amazon_warehousing_and_distribution_2024_05_09/carrier_code.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# This file is generated. Do not edit.
+
+require "structure"
+
+module Peddler
+  module APIs
+    class AmazonWarehousingAndDistribution20240509
+      # Identifies the carrier that will deliver the shipment.
+      CarrierCode = Structure.new do
+        # @return [String] Denotes the carrier type.
+        attribute?(:carrier_code_type, String, from: "carrierCodeType")
+
+        # @return [String] Value of the carrier code.
+        attribute?(:carrier_code_value, String, from: "carrierCodeValue")
+      end
+    end
+  end
+end

data/lib/peddler/apis/amazon_warehousing_and_distribution_2024_05_09/destination_details.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# This file is generated. Do not edit.
+
+require "structure"
+
+module Peddler
+  module APIs
+    class AmazonWarehousingAndDistribution20240509
+      # Destination details of an inbound order based on the assigned region and DC for the order.
+      DestinationDetails = Structure.new do
+        # @return [Address] Destination address of the AWD facility where the shipment will be shipped to
+        attribute?(:destination_address, Address, from: "destinationAddress")
+
+        # @return [String] Assigned region where the order will be shipped. This can differ from what was passed as
+        #   preference. AWD currently supports following region IDs: [us-west, us-east, us-southcentral, us-southeast]
+        attribute?(:destination_region, String, from: "destinationRegion")
+
+        # @return [String] Unique ID of the confirmed shipment being shipped to the assigned destination. This will be
+        #   available only after an inbound order is confirmed and can be used to track the shipment.
+        attribute?(:shipment_id, String, from: "shipmentId")
+      end
+    end
+  end
+end