@amazon-sp-api-release/amazon-sp-api-sdk-js 1.5.0 → 1.6.0

package/helper/DefaultRateLimitMap.mjs

@@ -302,6 +302,19 @@ export const defaultRateLimitMap = {
   "CustomerFeedbackApi-getItemReviewTrends": [1, 10],
   "CustomerFeedbackApi-getBrowseNodeReviewTrends": [1, 10],
   "CustomerFeedbackApi-getBrowseNodeReturnTopics": [1, 10],
-  "CustomerFeedbackApi-getBrowseNodeReturnTrends": [1, 10]
+  "CustomerFeedbackApi-getBrowseNodeReturnTrends": [1, 10],
+  "BatchInventoryApi-batchInventory": [50, 50],
+  "ReturnRetrievalApi-listReturns": [1, 1],
+  "ReturnRetrievalApi-getReturn": [1, 1],
+  "ShipmentRetrievalApi-getShipments": [1, 1],
+  "ShipmentRetrievalApi-getShipment": [1, 1],
+  "ShipmentProcessingApi-generateShipLabels": [1, 1],
+  "ShipmentProcessingApi-createPackages": [1, 1],
+  "ShipmentProcessingApi-updatePackage": [1, 1],
+  "ShipmentProcessingApi-updatePackageStatus": [1, 1],
+  "ShipmentProcessingApi-retrieveShippingOptions": [1, 1],
+  "ShipmentProcessingApi-generateInvoice": [1, 1],
+  "ShipmentProcessingApi-retrieveInvoice": [1, 1],
+  "ShipmentProcessingApi-processShipment": [1, 1]
 }
 

package/index.js

@@ -6,6 +6,9 @@ export * as CatalogitemsSpApi from './src/catalogitems_v2022_04_01/index.js';
 export * as CustomerFeedback20240601SpApi from './src/customerFeedback_2024_06_01/index.js';
 export * as DatakioskSpApi from './src/datakiosk_v2023_11_15/index.js';
 export * as EasyshipSpApi from './src/easyship_v2022_03_23/index.js';
+export * as ExternalfulfillmentinventorySpApi from './src/externalfulfillmentinventory_v2024_09_11/index.js';
+export * as ExternalfulfillmentreturnsSpApi from './src/externalfulfillmentreturns_v2024_09_11/index.js';
+export * as ExternalfulfillmentshipmentsSpApi from './src/externalfulfillmentshipments_v2024_09_11/index.js';
 export * as FbaeligibilitySpApi from './src/fbaeligibility_v1/index.js';
 export * as FbainventorySpApi from './src/fbainventory_v1/index.js';
 export * as FeedsSpApi from './src/feeds_v2021_06_30/index.js';

package/package.json

@@ -56,5 +56,5 @@
   "engines": {
     "node": ">=14.18.0"
   },
-  "version": "1.5.0"
+  "version": "1.6.0"
 }

package/src/catalogitems_v2022_04_01/model/ErrorList.d.ts

@@ -17,7 +17,7 @@ export class ErrorList {
      * A list of error responses returned when a request is unsuccessful.
      * @alias module:catalogitems_v2022_04_01/model/ErrorList
      * @class
-     * @param errors {[Error]}
+     * @param errors {[Error]} A list of error responses returned when a request is unsuccessful.
      */
     constructor(errors: [Error]);
     errors: [Error];

package/src/catalogitems_v2022_04_01/model/ErrorList.js

@@ -25,7 +25,7 @@ export class ErrorList {
    * A list of error responses returned when a request is unsuccessful.
    * @alias module:catalogitems_v2022_04_01/model/ErrorList
    * @class
-   * @param errors {[Error]}
+   * @param errors {[Error]} A list of error responses returned when a request is unsuccessful.
    */
   constructor (errors) {
     this.errors = errors
@@ -59,6 +59,7 @@ export class ErrorList {
 }
 
 /**
+ * A list of error responses returned when a request is unsuccessful.
  * @member {[Error]} errors
  * @type {[Error]}
  */

package/src/catalogitems_v2022_04_01/model/ItemSearchResults.d.ts

@@ -18,17 +18,23 @@ export class ItemSearchResults {
      * @alias module:catalogitems_v2022_04_01/model/ItemSearchResults
      * @class
      * @param numberOfResults {Number} For searches that are based on `identifiers`, `numberOfResults` is the total number of Amazon catalog items found. For searches that are based on `keywords`, `numberOfResults` is the estimated total number of Amazon catalog items that are matched by the search query. Only results up to the page count limit are returned per request regardless of the number found.  **Note:** The maximum number of items (ASINs) that can be returned and paged through is 1,000.
-     * @param pagination {Pagination}
-     * @param refinements {Refinements}
      * @param items {[Item]} A list of items from the Amazon catalog.
      */
-    constructor(numberOfResults: number, pagination: Pagination, refinements: Refinements, items: [Item]);
+    constructor(numberOfResults: number, items: [Item]);
     numberOfResults: number;
+    items: [Item];
+    /**
+     * @member {Pagination} pagination
+     * @type {Pagination}
+     */
     pagination: Pagination;
+    /**
+     * @member {Refinements} refinements
+     * @type {Refinements}
+     */
     refinements: Refinements;
-    items: [Item];
 }
+import { Item } from './Item.js';
 import { Pagination } from './Pagination.js';
 import { Refinements } from './Refinements.js';
-import { Item } from './Item.js';
 //# sourceMappingURL=ItemSearchResults.d.ts.map

package/src/catalogitems_v2022_04_01/model/ItemSearchResults.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ItemSearchResults.d.ts","sourceRoot":"","sources":["ItemSearchResults.js"],"names":[],"mappings":"AAkBA;;;;GAIG;AACH;IAkBE;;;;;;OAMG;IACH,2CAHW,iBAAiB,GAChB,iBAAiB,CAsB5B;IA5CD;;;;;;;;;OASG;IACH,iDAJsB,UAAU,eACT,WAAW,SACjB,CAAC,IAAI,CAAC,EAOtB;IAJC,wBAAsC;IACtC,uBAA4B;IAC5B,yBAA8B;IAC9B,cAAkB;CA+BrB;2BAtD0B,iBAAiB;4BAChB,kBAAkB;qBAFzB,WAAW"}
+{"version":3,"file":"ItemSearchResults.d.ts","sourceRoot":"","sources":["ItemSearchResults.js"],"names":[],"mappings":"AAkBA;;;;GAIG;AACH;IAcE;;;;;;OAMG;IACH,2CAHW,iBAAiB,GAChB,iBAAiB,CAsB5B;IAxCD;;;;;;;OAOG;IACH,4CAFiB,CAAC,IAAI,CAAC,EAKtB;IAFC,wBAAsC;IACtC,cAAkB;IAwCtB;;;OAGG;IACH,YAFU,UAAU,CAEkB;IAEtC;;;OAGG;IACH,aAFU,WAAW,CAEkB;CAnBtC;qBAnDoB,WAAW;2BACL,iBAAiB;4BAChB,kBAAkB"}

package/src/catalogitems_v2022_04_01/model/ItemSearchResults.js

@@ -28,14 +28,10 @@ export class ItemSearchResults {
    * @alias module:catalogitems_v2022_04_01/model/ItemSearchResults
    * @class
    * @param numberOfResults {Number} For searches that are based on `identifiers`, `numberOfResults` is the total number of Amazon catalog items found. For searches that are based on `keywords`, `numberOfResults` is the estimated total number of Amazon catalog items that are matched by the search query. Only results up to the page count limit are returned per request regardless of the number found.  **Note:** The maximum number of items (ASINs) that can be returned and paged through is 1,000.
-   * @param pagination {Pagination}
-   * @param refinements {Refinements}
    * @param items {[Item]} A list of items from the Amazon catalog.
    */
-  constructor (numberOfResults, pagination, refinements, items) {
+  constructor (numberOfResults, items) {
     this.numberOfResults = numberOfResults
-    this.pagination = pagination
-    this.refinements = refinements
     this.items = items
   }
 

package/src/easyship_v2022_03_23/api/EasyShipApi.d.ts

@@ -35,13 +35,13 @@ export class EasyShipApi {
        */
     createScheduledPackage(createScheduledPackageRequest: CreateScheduledPackageRequest): Promise<Package>;
     /**
-       * This operation automatically schedules a time slot for all the &#x60;amazonOrderId&#x60;s given as input, generating the associated shipping labels, along with other compliance documents according to the marketplace (refer to the [marketplace document support table](doc:easyship-api-v2022-03-23-use-case-guide#marketplace-support-table)).  Developers calling this operation may optionally assign a &#x60;packageDetails&#x60; object, allowing them to input a preferred time slot for each order in their request. In this case, Amazon will try to schedule the respective packages using their optional settings. On the other hand, *i.e.*, if the time slot is not provided, Amazon will then pick the earliest time slot possible.   Regarding the shipping label&#39;s file format, external developers are able to choose between PDF or ZPL, and Amazon will create the label accordingly.  This operation returns an array composed of the scheduled packages, and a short-lived URL pointing to a zip file containing the generated shipping labels and the other documents enabled for your marketplace. If at least an order couldn&#39;t be scheduled, then Amazon adds the &#x60;rejectedOrders&#x60; list into the response, which contains an entry for each order we couldn&#39;t process. Each entry is composed of an error message describing the reason of the failure, so that sellers can take action.  The table below displays the supported request and burst maximum rates:  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 5 |  The &#x60;x-amzn-RateLimit-Limit&#x60; response header returns the usage plan rate limits that were applied to the requested operation, when available. The table above indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may see higher rate and burst values than those shown here. For more information, see [Usage Plans and Rate Limits in the Selling Partner API](doc:usage-plans-and-rate-limits-in-the-sp-api).
+       * This operation automatically schedules a time slot for all the &#x60;amazonOrderId&#x60;s given as input, generating the associated shipping labels, along with other compliance documents according to the marketplace (refer to the [marketplace document support table](doc:easyship-api-v2022-03-23-use-case-guide#marketplace-support-table)).  Developers calling this operation may optionally assign a &#x60;packageDetails&#x60; object, allowing them to input a preferred time slot for each order in ther request. In this case, Amazon will try to schedule the respective packages using their optional settings. On the other hand, *i.e.*, if the time slot is not provided, Amazon will then pick the earliest time slot possible.   Regarding the shipping label&#39;s file format, external developers are able to choose between PDF or ZPL, and Amazon will create the label accordingly.  This operation returns an array composed of the scheduled packages, and a short-lived URL pointing to a zip file containing the generated shipping labels and the other documents enabled for your marketplace. If at least an order couldn&#39;t be scheduled, then Amazon adds the &#x60;rejectedOrders&#x60; list into the response, which contains an entry for each order we couldn&#39;t process. Each entry is composed of an error message describing the reason of the failure, so that sellers can take action.  The table below displays the supported request and burst maximum rates:  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 5 |  The &#x60;x-amzn-RateLimit-Limit&#x60; response header returns the usage plan rate limits that were applied to the requested operation, when available. The table above indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may see higher rate and burst values than those shown here. For more information, see [Usage Plans and Rate Limits in the Selling Partner API](doc:usage-plans-and-rate-limits-in-the-sp-api).
        * @param {CreateScheduledPackagesRequest} createScheduledPackagesRequest The request schema for the &#x60;createScheduledPackageBulk&#x60; operation.
        * @return {Promise<CreateScheduledPackagesResponse>}
        */
     createScheduledPackageBulkWithHttpInfo(createScheduledPackagesRequest: CreateScheduledPackagesRequest): Promise<CreateScheduledPackagesResponse>;
     /**
-       * This operation automatically schedules a time slot for all the &#x60;amazonOrderId&#x60;s given as input, generating the associated shipping labels, along with other compliance documents according to the marketplace (refer to the [marketplace document support table](doc:easyship-api-v2022-03-23-use-case-guide#marketplace-support-table)).  Developers calling this operation may optionally assign a &#x60;packageDetails&#x60; object, allowing them to input a preferred time slot for each order in their request. In this case, Amazon will try to schedule the respective packages using their optional settings. On the other hand, *i.e.*, if the time slot is not provided, Amazon will then pick the earliest time slot possible.   Regarding the shipping label&#39;s file format, external developers are able to choose between PDF or ZPL, and Amazon will create the label accordingly.  This operation returns an array composed of the scheduled packages, and a short-lived URL pointing to a zip file containing the generated shipping labels and the other documents enabled for your marketplace. If at least an order couldn&#39;t be scheduled, then Amazon adds the &#x60;rejectedOrders&#x60; list into the response, which contains an entry for each order we couldn&#39;t process. Each entry is composed of an error message describing the reason of the failure, so that sellers can take action.  The table below displays the supported request and burst maximum rates:  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 5 |  The &#x60;x-amzn-RateLimit-Limit&#x60; response header returns the usage plan rate limits that were applied to the requested operation, when available. The table above indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may see higher rate and burst values than those shown here. For more information, see [Usage Plans and Rate Limits in the Selling Partner API](doc:usage-plans-and-rate-limits-in-the-sp-api).
+       * This operation automatically schedules a time slot for all the &#x60;amazonOrderId&#x60;s given as input, generating the associated shipping labels, along with other compliance documents according to the marketplace (refer to the [marketplace document support table](doc:easyship-api-v2022-03-23-use-case-guide#marketplace-support-table)).  Developers calling this operation may optionally assign a &#x60;packageDetails&#x60; object, allowing them to input a preferred time slot for each order in ther request. In this case, Amazon will try to schedule the respective packages using their optional settings. On the other hand, *i.e.*, if the time slot is not provided, Amazon will then pick the earliest time slot possible.   Regarding the shipping label&#39;s file format, external developers are able to choose between PDF or ZPL, and Amazon will create the label accordingly.  This operation returns an array composed of the scheduled packages, and a short-lived URL pointing to a zip file containing the generated shipping labels and the other documents enabled for your marketplace. If at least an order couldn&#39;t be scheduled, then Amazon adds the &#x60;rejectedOrders&#x60; list into the response, which contains an entry for each order we couldn&#39;t process. Each entry is composed of an error message describing the reason of the failure, so that sellers can take action.  The table below displays the supported request and burst maximum rates:  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 5 |  The &#x60;x-amzn-RateLimit-Limit&#x60; response header returns the usage plan rate limits that were applied to the requested operation, when available. The table above indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may see higher rate and burst values than those shown here. For more information, see [Usage Plans and Rate Limits in the Selling Partner API](doc:usage-plans-and-rate-limits-in-the-sp-api).
        * @param {CreateScheduledPackagesRequest} createScheduledPackagesRequest The request schema for the &#x60;createScheduledPackageBulk&#x60; operation.
        * @return {Promise<CreateScheduledPackagesResponse>}
        */

package/src/easyship_v2022_03_23/api/EasyShipApi.js

@@ -119,7 +119,7 @@ export class EasyShipApi {
   }
 
   /**
-     * This operation automatically schedules a time slot for all the `amazonOrderId`s given as input, generating the associated shipping labels, along with other compliance documents according to the marketplace (refer to the [marketplace document support table](doc:easyship-api-v2022-03-23-use-case-guide#marketplace-support-table)).  Developers calling this operation may optionally assign a `packageDetails` object, allowing them to input a preferred time slot for each order in their request. In this case, Amazon will try to schedule the respective packages using their optional settings. On the other hand, *i.e.*, if the time slot is not provided, Amazon will then pick the earliest time slot possible.   Regarding the shipping label's file format, external developers are able to choose between PDF or ZPL, and Amazon will create the label accordingly.  This operation returns an array composed of the scheduled packages, and a short-lived URL pointing to a zip file containing the generated shipping labels and the other documents enabled for your marketplace. If at least an order couldn't be scheduled, then Amazon adds the `rejectedOrders` list into the response, which contains an entry for each order we couldn't process. Each entry is composed of an error message describing the reason of the failure, so that sellers can take action.  The table below displays the supported request and burst maximum rates:  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 5 |  The `x-amzn-RateLimit-Limit` response header returns the usage plan rate limits that were applied to the requested operation, when available. The table above indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may see higher rate and burst values than those shown here. For more information, see [Usage Plans and Rate Limits in the Selling Partner API](doc:usage-plans-and-rate-limits-in-the-sp-api).
+     * This operation automatically schedules a time slot for all the `amazonOrderId`s given as input, generating the associated shipping labels, along with other compliance documents according to the marketplace (refer to the [marketplace document support table](doc:easyship-api-v2022-03-23-use-case-guide#marketplace-support-table)).  Developers calling this operation may optionally assign a `packageDetails` object, allowing them to input a preferred time slot for each order in ther request. In this case, Amazon will try to schedule the respective packages using their optional settings. On the other hand, *i.e.*, if the time slot is not provided, Amazon will then pick the earliest time slot possible.   Regarding the shipping label's file format, external developers are able to choose between PDF or ZPL, and Amazon will create the label accordingly.  This operation returns an array composed of the scheduled packages, and a short-lived URL pointing to a zip file containing the generated shipping labels and the other documents enabled for your marketplace. If at least an order couldn't be scheduled, then Amazon adds the `rejectedOrders` list into the response, which contains an entry for each order we couldn't process. Each entry is composed of an error message describing the reason of the failure, so that sellers can take action.  The table below displays the supported request and burst maximum rates:  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 5 |  The `x-amzn-RateLimit-Limit` response header returns the usage plan rate limits that were applied to the requested operation, when available. The table above indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may see higher rate and burst values than those shown here. For more information, see [Usage Plans and Rate Limits in the Selling Partner API](doc:usage-plans-and-rate-limits-in-the-sp-api).
      * @param {CreateScheduledPackagesRequest} createScheduledPackagesRequest The request schema for the `createScheduledPackageBulk` operation.
      * @return {Promise<CreateScheduledPackagesResponse>}
      */
@@ -152,7 +152,7 @@ export class EasyShipApi {
   }
 
   /**
-     * This operation automatically schedules a time slot for all the &#x60;amazonOrderId&#x60;s given as input, generating the associated shipping labels, along with other compliance documents according to the marketplace (refer to the [marketplace document support table](doc:easyship-api-v2022-03-23-use-case-guide#marketplace-support-table)).  Developers calling this operation may optionally assign a &#x60;packageDetails&#x60; object, allowing them to input a preferred time slot for each order in their request. In this case, Amazon will try to schedule the respective packages using their optional settings. On the other hand, *i.e.*, if the time slot is not provided, Amazon will then pick the earliest time slot possible.   Regarding the shipping label&#39;s file format, external developers are able to choose between PDF or ZPL, and Amazon will create the label accordingly.  This operation returns an array composed of the scheduled packages, and a short-lived URL pointing to a zip file containing the generated shipping labels and the other documents enabled for your marketplace. If at least an order couldn&#39;t be scheduled, then Amazon adds the &#x60;rejectedOrders&#x60; list into the response, which contains an entry for each order we couldn&#39;t process. Each entry is composed of an error message describing the reason of the failure, so that sellers can take action.  The table below displays the supported request and burst maximum rates:  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 5 |  The &#x60;x-amzn-RateLimit-Limit&#x60; response header returns the usage plan rate limits that were applied to the requested operation, when available. The table above indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may see higher rate and burst values than those shown here. For more information, see [Usage Plans and Rate Limits in the Selling Partner API](doc:usage-plans-and-rate-limits-in-the-sp-api).
+     * This operation automatically schedules a time slot for all the &#x60;amazonOrderId&#x60;s given as input, generating the associated shipping labels, along with other compliance documents according to the marketplace (refer to the [marketplace document support table](doc:easyship-api-v2022-03-23-use-case-guide#marketplace-support-table)).  Developers calling this operation may optionally assign a &#x60;packageDetails&#x60; object, allowing them to input a preferred time slot for each order in ther request. In this case, Amazon will try to schedule the respective packages using their optional settings. On the other hand, *i.e.*, if the time slot is not provided, Amazon will then pick the earliest time slot possible.   Regarding the shipping label&#39;s file format, external developers are able to choose between PDF or ZPL, and Amazon will create the label accordingly.  This operation returns an array composed of the scheduled packages, and a short-lived URL pointing to a zip file containing the generated shipping labels and the other documents enabled for your marketplace. If at least an order couldn&#39;t be scheduled, then Amazon adds the &#x60;rejectedOrders&#x60; list into the response, which contains an entry for each order we couldn&#39;t process. Each entry is composed of an error message describing the reason of the failure, so that sellers can take action.  The table below displays the supported request and burst maximum rates:  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 5 |  The &#x60;x-amzn-RateLimit-Limit&#x60; response header returns the usage plan rate limits that were applied to the requested operation, when available. The table above indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may see higher rate and burst values than those shown here. For more information, see [Usage Plans and Rate Limits in the Selling Partner API](doc:usage-plans-and-rate-limits-in-the-sp-api).
      * @param {CreateScheduledPackagesRequest} createScheduledPackagesRequest The request schema for the &#x60;createScheduledPackageBulk&#x60; operation.
      * @return {Promise<CreateScheduledPackagesResponse>}
      */

package/src/easyship_v2022_03_23/model/HandoverMethod.d.ts

@@ -11,14 +11,14 @@ export class HandoverMethod {
       */
     static constructFromObject(object: any): HandoverMethod;
     /**
-           * value: "Pickup"
+           * value: "PICKUP"
            * @const
            */
-    Pickup: string;
+    PICKUP: string;
     /**
-           * value: "Dropoff"
+           * value: "DROPOFF"
            * @const
            */
-    Dropoff: string;
+    DROPOFF: string;
 }
 //# sourceMappingURL=HandoverMethod.d.ts.map

package/src/easyship_v2022_03_23/model/HandoverMethod.js

@@ -20,16 +20,16 @@ import { ApiClient } from '../ApiClient.js'
 */
 export class HandoverMethod {
   /**
-         * value: "Pickup"
+         * value: "PICKUP"
          * @const
          */
-  'Pickup' = 'Pickup'
+  'PICKUP' = 'PICKUP'
 
   /**
-         * value: "Dropoff"
+         * value: "DROPOFF"
          * @const
          */
-  'Dropoff' = 'Dropoff'
+  'DROPOFF' = 'DROPOFF'
 
   /**
     * Returns a <code>HandoverMethod</code> enum value from a Javascript object name.

package/src/easyship_v2022_03_23/model/UnitOfLength.d.ts

@@ -11,9 +11,9 @@ export class UnitOfLength {
       */
     static constructFromObject(object: any): UnitOfLength;
     /**
-           * value: "Cm"
+           * value: "cm"
            * @const
            */
-    Cm: string;
+    cm: string;
 }
 //# sourceMappingURL=UnitOfLength.d.ts.map

package/src/easyship_v2022_03_23/model/UnitOfLength.js

@@ -20,10 +20,10 @@ import { ApiClient } from '../ApiClient.js'
 */
 export class UnitOfLength {
   /**
-         * value: "Cm"
+         * value: "cm"
          * @const
          */
-  'Cm' = 'Cm'
+  'cm' = 'cm'
 
   /**
     * Returns a <code>UnitOfLength</code> enum value from a Javascript object name.

package/src/easyship_v2022_03_23/model/UnitOfWeight.d.ts

@@ -11,14 +11,14 @@ export class UnitOfWeight {
       */
     static constructFromObject(object: any): UnitOfWeight;
     /**
-           * value: "Grams"
+           * value: "grams"
            * @const
            */
-    Grams: string;
+    grams: string;
     /**
-           * value: "G"
+           * value: "g"
            * @const
            */
-    G: string;
+    g: string;
 }
 //# sourceMappingURL=UnitOfWeight.d.ts.map

package/src/easyship_v2022_03_23/model/UnitOfWeight.js

@@ -20,16 +20,16 @@ import { ApiClient } from '../ApiClient.js'
 */
 export class UnitOfWeight {
   /**
-         * value: "Grams"
+         * value: "grams"
          * @const
          */
-  'Grams' = 'Grams'
+  'grams' = 'grams'
 
   /**
-         * value: "G"
+         * value: "g"
          * @const
          */
-  'G' = 'G'
+  'g' = 'g'
 
   /**
     * Returns a <code>UnitOfWeight</code> enum value from a Javascript object name.

package/src/externalfulfillmentinventory_v2024_09_11/ApiClient.d.ts

@@ -0,0 +1,260 @@
+/**
+* Manages low level client-server communications, parameter marshalling, etc. There should not be any need for an
+* application to use this class directly - the *Api and model classes provide the public API for the service. The
+* contents of this file should be regarded as internal but are documented for completeness.
+* @alias module:externalfulfillmentinventory_v2024_09_11/ApiClient
+* @class
+*/
+export class ApiClient {
+    /**
+      * Enumeration of collection format separator strategies.
+      * @enum {String}
+      * @readonly
+      */
+    static readonly CollectionFormatEnum: {
+        /**
+             * Comma-separated values. Value: <code>csv</code>
+             * @const
+             */
+        CSV: string;
+        /**
+             * Space-separated values. Value: <code>ssv</code>
+             * @const
+             */
+        SSV: string;
+        /**
+             * Tab-separated values. Value: <code>tsv</code>
+             * @const
+             */
+        TSV: string;
+        /**
+             * Pipe(|)-separated values. Value: <code>pipes</code>
+             * @const
+             */
+        PIPES: string;
+        /**
+             * Native array. Value: <code>multi</code>
+             * @const
+             */
+        MULTI: string;
+    };
+    /**
+      * Parses an ISO-8601 string representation of a date value.
+      * @param {String} str The date value as a string.
+      * @returns {Date} The parsed date object.
+      */
+    static parseDate(str: string): Date;
+    /**
+      * Converts a value to the specified type.
+      * @param {(String|Object)} data The data to convert, as a string or object.
+      * @param {(String|Array<String>|Object<String, Object>|Function)} type The type to return. Pass a string for simple types
+      * or the constructor function for a complex type. Pass an array containing the type name to return an array of that type. To
+      * return an object, pass an object with one property whose name is the key type and whose value is the corresponding value type:
+      * all properties on <code>data<code> will be converted to this type.
+      * @returns An instance of the specified type or null or undefined if data is null or undefined.
+      */
+    static convertToType(data: (string | any), type: (string | Array<string> | any | Function)): any;
+    /**
+      * Constructs a new map or array model from REST data.
+      * @param data {Object|Array} The REST data.
+      * @param obj {Object|Array} The target object or array.
+      */
+    static constructFromObject(data: any | any[], obj: any | any[], itemType: any): void;
+    /**
+      * Constructs a new ApiClient.
+      * @param {String} baseUrl Base URL of endpoint ex. "https://sellingpartnerapi-na.amazon.com"
+      */
+    constructor(baseUrl: string);
+    /**
+         * The base URL against which to resolve every API call's (relative) path.
+         * @type {String}
+         * @default https://sellingpartnerapi-na.amazon.com
+         */
+    basePath: string;
+    /**
+         * The authentication methods to be included for all API calls.
+         * @type {Array<String>}
+         */
+    authentications: Array<string>;
+    /**
+         * The default HTTP headers to be included for all API calls.
+         * @type {Array<String>}
+         * @default {}
+         */
+    defaultHeaders: Array<string>;
+    /**
+         * The default HTTP timeout for all API calls.
+         * @type {Number}
+         * @default 60000
+         */
+    timeout: number;
+    /**
+         * If set to false an additional timestamp parameter is added to all API GET calls to
+         * prevent browser caching
+         * @type {Boolean}
+         * @default true
+         */
+    cache: boolean;
+    /**
+         * If set to true, the client will save the cookies from each server
+         * response, and return them in the next request.
+         * @default false
+         */
+    enableCookies: boolean;
+    agent: any;
+    requestAgent: any;
+    /**
+      * Set customized rate limiter for one operation
+      * For operations that customized rate limiter are not set
+      * Will use default rate limiter
+      * @param {String} operationName
+      * @param {RateLimitConfiguration} config
+      */
+    setCustomizedRateLimiterForOperation(operationName: string, config: RateLimitConfiguration): void;
+    /**
+      * Disable customized rate limiter for one operation
+      * Fall back to default rate limiter
+      * @param {String} operationName
+      */
+    disableCustomizedRatelimiterForOperation(operationName: string): void;
+    /**
+      * Clear customized rate limiter for all operations
+      * All operations will fall back to default rate limiter
+      * @param {String} operationName
+      */
+    disableCustomizedRatelimiterForAll(): void;
+    /**
+      * Disable both default and customized rate limiter for all operations
+      */
+    disableRateLimiter(): void;
+    /**
+      * Enable default or customized rate limiter for all operations
+      */
+    enableRateLimiter(): void;
+    /**
+      * Returns this ApiClient so that you can chain the methods.
+      * @param {String} clientId LWA client ID.
+      * @param {String} clientSecret LWA client secret.
+      * @param {String} refreshToken LWA refresh token.
+      * @param {Array<String>} dataElementsOption specify PII information to get from "buyerInfo", "shippingAddress" and "buyerTaxInformation".
+      * @returns {ApiClient} This ApiClient, which is going to use give accessToken for all API calls.
+      */
+    enableAutoRetrievalRestrictedDataToken(clientId: string, clientSecret: string, refreshToken: string, dataElementsOption: Array<string>): ApiClient;
+    /**
+      * Returns this ApiClient so that you can chain the methods.
+      * @param {String} clientId LWA client ID.
+      * @param {String} clientSecret LWA client secret.
+      * @param {String|null} refreshToken LWA refresh token.
+      * @param {String|null} scope LWA scope(s) for grantless operations.
+      * @returns {ApiClient} This ApiClient, which is going to use give accessToken for all API calls.
+      */
+    enableAutoRetrievalAccessToken(clientId: string, clientSecret: string, refreshToken?: string | null, scope?: string | null): ApiClient;
+    /**
+       * Clear Token Cache
+       */
+    clearAccessTokenCache(): void;
+    /**
+      * Returns this ApiClient so that you can chain the methods.
+      * @param {String} restrictedDataToken RDT token to use for SP-API call.
+      * @returns {ApiClient} This ApiClient, which is going to use give RDT for all API calls.
+      */
+    applyRestrictedDataToken(restrictedDataToken: string): ApiClient;
+    /**
+      * Applies authentication headers to the request.
+      * @param {String} accessOrRdtToken Either Access Token or Restricted Data Token to add as 'x-amz-access-token'.
+      * @returns {ApiClient} This ApiClient, which is going to use give RDT for all API calls.
+      */
+    applyXAmzAccessTokenToRequest(accessOrRdtToken: string): ApiClient;
+    /**
+      * Returns a string representation for an actual parameter.
+      * @param param The actual parameter.
+      * @returns {String} The string representation of <code>param</code>.
+      */
+    paramToString(param: any): string;
+    /**
+      * Builds full URL by appending the given path to the base URL and replacing path parameter place-holders with parameter values.
+      * NOTE: query parameters are not handled here.
+      * @param {String} path The path to append to the base URL.
+      * @param {Object} pathParams The parameter values to append.
+      * @returns {String} The encoded path with parameter values substituted.
+      */
+    buildUrl(path: string, pathParams: any): string;
+    /**
+      * Checks whether the given content type represents JSON.<br>
+      * JSON content type examples:<br>
+      * <ul>
+      * <li>application/json</li>
+      * <li>application/json; charset=UTF8</li>
+      * <li>APPLICATION/JSON</li>
+      * </ul>
+      * @param {String} contentType The MIME content type to check.
+      * @returns {Boolean} <code>true</code> if <code>contentType</code> represents JSON, otherwise <code>false</code>.
+      */
+    isJsonMime(contentType: string): boolean;
+    /**
+      * Chooses a content type from the given array, with JSON preferred; i.e. return JSON if included, otherwise return the first.
+      * @param {Array<String>} contentTypes
+      * @returns {String} The chosen content type, preferring JSON.
+      */
+    jsonPreferredMime(contentTypes: Array<string>): string;
+    /**
+      * Checks whether the given parameter value represents file-like content.
+      * @param param The parameter to check.
+      * @returns {Boolean} <code>true</code> if <code>param</code> represents a file.
+      */
+    isFileParam(param: any): boolean;
+    /**
+      * Normalizes parameter values:
+      * <ul>
+      * <li>remove nils</li>
+      * <li>keep files and arrays</li>
+      * <li>format to string with `paramToString` for other cases</li>
+      * </ul>
+      * @param {Object<String, Object>} params The parameters as object properties.
+      * @returns {Object<String, Object>} normalized parameters.
+      */
+    normalizeParams(params: any): any;
+    /**
+      * Builds a string representation of an array-type actual parameter, according to the given collection format.
+      * @param {Array} param An array parameter.
+      * @param {module:externalfulfillmentinventory_v2024_09_11/ApiClient.CollectionFormatEnum} collectionFormat The array element separator strategy.
+      * @returns {String|Array} A string representation of the supplied collection, using the specified delimiter. Returns
+      * <code>param</code> as is if <code>collectionFormat</code> is <code>multi</code>.
+      */
+    buildCollectionParam(param: any[], collectionFormat: any): string | any[];
+    /**
+      * Deserializes an HTTP response body into a value of the specified type.
+      * @param {Object} response A SuperAgent response object.
+      * @param {(String|Array<String>|Object<String, Object>|Function)} returnType The type to return. Pass a string for simple types
+      * or the constructor function for a complex type. Pass an array containing the type name to return an array of that type. To
+      * return an object, pass an object with one property whose name is the key type and whose value is the corresponding value type:
+      * all properties on <code>data<code> will be converted to this type.
+      * @returns A value of the specified type.
+      */
+    deserialize(response: any, returnType: (string | Array<string> | any | Function)): any;
+    /**
+      * Invokes the REST service using the supplied settings and parameters.
+      * @param {String} operation operation name.
+      * @param {String} path The base URL to invoke.
+      * @param {String} httpMethod The HTTP method to use.
+      * @param {Object<String, String>} pathParams A map of path parameters and their values.
+      * @param {Object<String, Object>} queryParams A map of query parameters and their values.
+      * @param {Object<String, Object>} headerParams A map of header parameters and their values.
+      * @param {Object<String, Object>} formParams A map of form parameters and their values.
+      * @param {Object} bodyParam The value to pass as the request body.
+      * @param {Array<String>} contentTypes An array of request MIME types.
+      * @param {Array<String>} accepts An array of acceptable response MIME types.
+      * @param {(String|Array|ObjectFunction)} returnType The required type to return; can be a string for simple types or the
+      * constructor for a complex type.
+      * @param {SuperagentRateLimiter} defaultRateLimiter The default rate limiter.
+      * @returns {Promise} A {@link https://www.promisejs.org/|Promise} object.
+      */
+    callApi(operation: string, path: string, httpMethod: string, pathParams: any, queryParams: any, headerParams: any, formParams: any, bodyParam: any, contentTypes: Array<string>, accepts: Array<string>, returnType: (string | any[] | ObjectFunction), defaultRateLimiter: SuperagentRateLimiter): Promise<any>;
+    #private;
+}
+export namespace ApiClient {
+    let instance: any;
+}
+import { RateLimitConfiguration } from '../../helper/RateLimitConfiguration.mjs';
+import { SuperagentRateLimiter } from '../../helper/SuperagentRateLimiter.mjs';
+//# sourceMappingURL=ApiClient.d.ts.map

package/src/externalfulfillmentinventory_v2024_09_11/ApiClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiClient.d.ts","sourceRoot":"","sources":["ApiClient.js"],"names":[],"mappings":"AAwLA;;;;;;EAME;AACF;IA4TE;;;;QAII;IACJ;QACE;;;eAGO;;QAGP;;;eAGO;;QAGP;;;eAGO;;QAGP;;;eAGO;;QAGP;;;eAGO;;MAER;IA4LD;;;;QAII;IACJ,+BAFc,IAAI,CAIjB;IAED;;;;;;;;QAQI;IACJ,2BAPY,CAAC,YAAa,CAAC,QACf,CAAC,SAAO,KAAK,QAAQ,iBAAgC,CAAC,OA6DjE;IAED;;;;QAII;IACJ,iCAHiB,WAAY,OACb,WAAY,uBAY3B;IA9mBD;;;QAGI;IACJ,6BAkEC;IAjEC;;;;WAIO;IACP,iBAAqH;IAErH;;;WAGO;IACP,iBAFc,KAAK,QAAQ,CAG1B;IAKD;;;;WAIO;IACP,gBAHc,KAAK,QAAQ,CAK1B;IAED;;;;WAIO;IACP,gBAAoB;IAEpB;;;;;WAKO;IACP,eAAiB;IAEjB;;;;WAIO;IACP,uBAA0B;IAOxB,WAAmC;IAMrC,kBAAwB;IAQ1B;;;;;;QAMI;IACJ,oEAFY,sBAAsB,QAIjC;IAED;;;;QAII;IACJ,sEAEC;IAED;;;;QAII;IACJ,2CAEC;IAED;;QAEI;IACJ,2BAEC;IAED;;QAEI;IACJ,0BAEC;IAED;;;;;;;QAOI;IACJ,yHAHY,KAAK,QAAQ,GACX,SAAS,CAQtB;IAED;;;;;;;QAOI;IACJ,sFAJY,SAAO,IAAI,UACX,SAAO,IAAI,GACT,SAAS,CAUtB;IAED;;SAEK;IACL,8BAIC;IAED;;;;QAII;IACJ,uDAFc,SAAS,CAKtB;IAED;;;;QAII;IACJ,yDAFc,SAAS,CAQtB;IAED;;;;QAII;IACJ,kCAQC;IAED;;;;;;QAMI;IACJ,gDAeC;IAED;;;;;;;;;;QAUI;IACJ,yCAEC;IAED;;;;QAII;IACJ,gCAHY,KAAK,QAAQ,UAUxB;IAED;;;;QAII;IACJ,iCA4BC;IAED;;;;;;;;;QASI;IACJ,kCAaC;IAuCD;;;;;;QAMI;IACJ,qDAJY,GAA8E,GAC5E,cAAY,CAsBzB;IAED;;;;;;;;QAQI;IACJ,uCANY,CAAC,SAAO,KAAK,QAAQ,iBAAgC,CAAC,OAoBjE;IAED;;;;;;;;;;;;;;;;QAgBI;IACJ,kKAPY,KAAK,QAAQ,WACb,KAAK,QAAQ,cACb,CAAC,iBAAa,cAAc,CAAC,sBAE7B,qBAAqB,gBAqHhC;;CA6FF;;kBAGQ,GAAyD;;uCAvyB3B,yCAAyC;sCAC1C,wCAAwC"}