@sp-api-sdk/amazon-warehousing-and-distribution-api-2024-05-09 5.0.0 → 5.1.0

package/dist/index.cjs

@@ -39,12 +39,14 @@ __export(index_exports, {
   ConfirmationMode: () => ConfirmationMode,
   DimensionUnitOfMeasurement: () => DimensionUnitOfMeasurement,
   DistributionPackageType: () => DistributionPackageType,
+  FormatType: () => FormatType,
   GetInboundShipmentLabelsFormatTypeEnum: () => GetInboundShipmentLabelsFormatTypeEnum,
   GetInboundShipmentLabelsPageTypeEnum: () => GetInboundShipmentLabelsPageTypeEnum,
   GetInboundShipmentSkuQuantitiesEnum: () => GetInboundShipmentSkuQuantitiesEnum,
   InboundEligibilityStatus: () => InboundEligibilityStatus,
   InboundShipmentStatus: () => InboundShipmentStatus,
   InboundStatus: () => InboundStatus,
+  InventoryDetailsVisibility: () => InventoryDetailsVisibility,
   InventoryUnitOfMeasurement: () => InventoryUnitOfMeasurement,
   LabelOwner: () => LabelOwner,
   LabelStatus: () => LabelStatus,
@@ -53,11 +55,19 @@ __export(index_exports, {
   ListInboundShipmentsSortOrderEnum: () => ListInboundShipmentsSortOrderEnum,
   ListInventoryDetailsEnum: () => ListInventoryDetailsEnum,
   ListInventorySortOrderEnum: () => ListInventorySortOrderEnum,
+  ListOutboundsSortOrderEnum: () => ListOutboundsSortOrderEnum,
   ListReplenishmentOrdersSortOrderEnum: () => ListReplenishmentOrdersSortOrderEnum,
+  OrderPreference: () => OrderPreference,
+  OrderPreferenceValue: () => OrderPreferenceValue,
   OutboundShipmentStatus: () => OutboundShipmentStatus,
+  OutboundStatus: () => OutboundStatus,
+  PageType: () => PageType,
   PrepCategory: () => PrepCategory,
   PrepOwner: () => PrepOwner,
   ReplenishmentOrderStatus: () => ReplenishmentOrderStatus,
+  ShipmentSortableField: () => ShipmentSortableField,
+  SkuQuantitiesVisibility: () => SkuQuantitiesVisibility,
+  SortOrder: () => SortOrder,
   VolumeUnitOfMeasurement: () => VolumeUnitOfMeasurement,
   WeightUnitOfMeasurement: () => WeightUnitOfMeasurement,
   clientRateLimits: () => clientRateLimits
@@ -231,6 +241,32 @@ var AmazonWarehousingAndDistributionApiAxiosParamCreator = function(configuratio
         options: localVarRequestOptions
       };
     },
+    /**
+     * Confirms an AWD outbound order for a set of shipments that contain items that must be outbound to a destination node. You can confirm the order only if it\'s in an`ELIGIBLE` state.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 1 |  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, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
+     * @param {string} orderId ID for the outbound order you want to confirm.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    confirmOutbound: async (orderId, options = {}) => {
+      assertParamExists("confirmOutbound", "orderId", orderId);
+      const localVarPath = `/awd/2024-05-09/outboundOrders/{orderId}/confirmation`.replace("{orderId}", encodeURIComponent(String(orderId)));
+      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+      let baseOptions;
+      if (configuration) {
+        baseOptions = configuration.baseOptions;
+      }
+      const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
+      const localVarHeaderParameter = {};
+      const localVarQueryParameter = {};
+      localVarHeaderParameter["Accept"] = "application/json";
+      setSearchParams(localVarUrlObj, localVarQueryParameter);
+      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+      return {
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions
+      };
+    },
     /**
      * Confirms an AWD replenishment order in ELIGIBLE state with a set of shipments containing items that are needed to be replenished to an FBA node. Order can only be confirmed in ELIGIBLE state.
      * @param {string} orderId ID of the replenishment order to be confirmed.
@@ -285,6 +321,34 @@ var AmazonWarehousingAndDistributionApiAxiosParamCreator = function(configuratio
         options: localVarRequestOptions
       };
     },
+    /**
+     * Creates a draft AWD outbound order with the specified products. The API returns the order ID for the newly created order and starts an async validation check on the outbound products. After the validation check, the order status transitions from `VALIDATING` to `ELIGIBLE/INELIGIBLE`.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 1 |  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, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
+     * @param {OutboundOrderCreationData} body Payload for creating an outbound order.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    createOutbound: async (body, options = {}) => {
+      assertParamExists("createOutbound", "body", body);
+      const localVarPath = `/awd/2024-05-09/outboundOrders`;
+      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+      let baseOptions;
+      if (configuration) {
+        baseOptions = configuration.baseOptions;
+      }
+      const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
+      const localVarHeaderParameter = {};
+      const localVarQueryParameter = {};
+      localVarHeaderParameter["Content-Type"] = "application/json";
+      localVarHeaderParameter["Accept"] = "application/json";
+      setSearchParams(localVarUrlObj, localVarQueryParameter);
+      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+      localVarRequestOptions.data = serializeDataIfNeeded(body, localVarRequestOptions, configuration);
+      return {
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions
+      };
+    },
     /**
      * Creates an AWD replenishment order with given products to replenish. The API will return the order ID of the newly created order and also start an async validation check on the products to e. The order status will transition to ELIGIBLE/INELIGIBLE status from VALIDATING post validation check
      * @param {ReplenishmentOrderCreationData} body Payload for creating a replenishment order.
@@ -403,6 +467,58 @@ var AmazonWarehousingAndDistributionApiAxiosParamCreator = function(configuratio
         options: localVarRequestOptions
       };
     },
+    /**
+     * Retrieves the available label page types for a shipment ID that you specify. This is an asynchronous operation. If the label status is `GENERATED`, then the pageTypes are available.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 2 |  The `x-amzn-RateLimit-Limit` response header returns the usage plan rate limits that were applied to the requested operation, when available. The preceding table indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may have higher rate and burst values than those shown here. For more information, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
+     * @param {string} shipmentId ID for the shipment.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getLabelPageTypes: async (shipmentId, options = {}) => {
+      assertParamExists("getLabelPageTypes", "shipmentId", shipmentId);
+      const localVarPath = `/awd/2024-05-09/inboundShipments/{shipmentId}/labelPageTypes`.replace("{shipmentId}", encodeURIComponent(String(shipmentId)));
+      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+      let baseOptions;
+      if (configuration) {
+        baseOptions = configuration.baseOptions;
+      }
+      const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
+      const localVarHeaderParameter = {};
+      const localVarQueryParameter = {};
+      localVarHeaderParameter["Accept"] = "application/json";
+      setSearchParams(localVarUrlObj, localVarQueryParameter);
+      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+      return {
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions
+      };
+    },
+    /**
+     * Retrieves an AWD outbound order with a set of shipments that contain items that are outbound into a destination channel. If the order is not eligible, the validation errors field is included in the order response. The API returns the order ID for the newly created order and starts an async validation check on the outbound products. After the validation check, the order status transitions from `VALIDATING` to `ELIGIBLE/INELIGIBLE`.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 1 |  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, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
+     * @param {string} orderId ID for the outbound order to be retrieved.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getOutbound: async (orderId, options = {}) => {
+      assertParamExists("getOutbound", "orderId", orderId);
+      const localVarPath = `/awd/2024-05-09/outboundOrders/{orderId}`.replace("{orderId}", encodeURIComponent(String(orderId)));
+      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+      let baseOptions;
+      if (configuration) {
+        baseOptions = configuration.baseOptions;
+      }
+      const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
+      const localVarHeaderParameter = {};
+      const localVarQueryParameter = {};
+      localVarHeaderParameter["Accept"] = "application/json";
+      setSearchParams(localVarUrlObj, localVarQueryParameter);
+      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+      return {
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions
+      };
+    },
     /**
      * Retrieves an AWD Replenishment order with a set of shipments containing items that is/was planned to be replenished into an FBA node.
      * @param {string} orderId ID of the replenishment order to be retrieved.
@@ -525,6 +641,50 @@ var AmazonWarehousingAndDistributionApiAxiosParamCreator = function(configuratio
         options: localVarRequestOptions
       };
     },
+    /**
+     * Retrieves all outbound AWD orders (with optional filters) that pertain to a merchant. By default, orders are sorted by the `updatedAt` attribute in descending order.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 1 |  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, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
+     * @param {string} [updatedAfter] Get the outbound orders updated after a certain time (inclusive). The date must be in <a href=\'https://developer-docs.amazon.com/sp-api/docs/iso-8601\'>ISO 8601</a> format.
+     * @param {string} [updatedBefore] Get the outbound orders updated before a certain time (inclusive). The date must be in <a href=\'https://developer-docs.amazon.com/sp-api/docs/iso-8601\'>ISO 8601</a> format.
+     * @param {ListOutboundsSortOrderEnum} [sortOrder] Sort the response in `ASCENDING` or `DESCENDING` order.
+     * @param {number} [maxResults] Maximum number of results to return.
+     * @param {string} [nextToken] A token that is used to retrieve the next page of results. The response includes `nextToken` when the number of results exceeds the specified `maxResults` value. To get the next page of results, call the operation with this token and include the same arguments as the call that produced the token. To get a complete list, call this operation until `nextToken` is null. Note that this operation can return empty pages.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    listOutbounds: async (updatedAfter, updatedBefore, sortOrder, maxResults, nextToken, options = {}) => {
+      const localVarPath = `/awd/2024-05-09/outboundOrders`;
+      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+      let baseOptions;
+      if (configuration) {
+        baseOptions = configuration.baseOptions;
+      }
+      const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
+      const localVarHeaderParameter = {};
+      const localVarQueryParameter = {};
+      if (updatedAfter !== void 0) {
+        localVarQueryParameter["updatedAfter"] = updatedAfter instanceof Date ? updatedAfter.toISOString() : updatedAfter;
+      }
+      if (updatedBefore !== void 0) {
+        localVarQueryParameter["updatedBefore"] = updatedBefore instanceof Date ? updatedBefore.toISOString() : updatedBefore;
+      }
+      if (sortOrder !== void 0) {
+        localVarQueryParameter["sortOrder"] = sortOrder;
+      }
+      if (maxResults !== void 0) {
+        localVarQueryParameter["maxResults"] = maxResults;
+      }
+      if (nextToken !== void 0) {
+        localVarQueryParameter["nextToken"] = nextToken;
+      }
+      localVarHeaderParameter["Accept"] = "application/json";
+      setSearchParams(localVarUrlObj, localVarQueryParameter);
+      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+      return {
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions
+      };
+    },
     /**
      * Retrieves all the AWD replenishment orders pertaining to a merchant with optional filters. API by default will sort orders by updatedAt attribute in descending order.
      * @param {string} [updatedAfter] Get the replenishment orders updated after certain time (Inclusive) Date should be in ISO 8601 format as defined by date-time in - https://www.rfc-editor.org/rfc/rfc3339.
@@ -628,6 +788,36 @@ var AmazonWarehousingAndDistributionApiAxiosParamCreator = function(configuratio
         url: toPathString(localVarUrlObj),
         options: localVarRequestOptions
       };
+    },
+    /**
+     * Updates an AWD outbound order that is in `DRAFT`, `ELIGIBLE`, or `INELIGIBLE` status. This API allows updates on `productsToOutbound` and `orderPreferences` attributes only. Any updates will restart the outbound order validation.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 1 |  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, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
+     * @param {string} orderId ID for the outbound order to be updated.
+     * @param {OutboundOrder} body Represents an AWD outbound order.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    updateOutbound: async (orderId, body, options = {}) => {
+      assertParamExists("updateOutbound", "orderId", orderId);
+      assertParamExists("updateOutbound", "body", body);
+      const localVarPath = `/awd/2024-05-09/outboundOrders/{orderId}`.replace("{orderId}", encodeURIComponent(String(orderId)));
+      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+      let baseOptions;
+      if (configuration) {
+        baseOptions = configuration.baseOptions;
+      }
+      const localVarRequestOptions = { method: "PUT", ...baseOptions, ...options };
+      const localVarHeaderParameter = {};
+      const localVarQueryParameter = {};
+      localVarHeaderParameter["Content-Type"] = "application/json";
+      localVarHeaderParameter["Accept"] = "application/json";
+      setSearchParams(localVarUrlObj, localVarQueryParameter);
+      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+      localVarRequestOptions.data = serializeDataIfNeeded(body, localVarRequestOptions, configuration);
+      return {
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions
+      };
     }
   };
 };
@@ -670,6 +860,18 @@ var AmazonWarehousingAndDistributionApiFp = function(configuration) {
       const localVarOperationServerBasePath = operationServerMap["AmazonWarehousingAndDistributionApi.confirmInbound"]?.[localVarOperationServerIndex]?.url;
       return (axios, basePath) => createRequestFunction(localVarAxiosArgs, import_axios2.default, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
     },
+    /**
+     * Confirms an AWD outbound order for a set of shipments that contain items that must be outbound to a destination node. You can confirm the order only if it\'s in an`ELIGIBLE` state.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 1 |  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, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
+     * @param {string} orderId ID for the outbound order you want to confirm.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async confirmOutbound(orderId, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.confirmOutbound(orderId, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["AmazonWarehousingAndDistributionApi.confirmOutbound"]?.[localVarOperationServerIndex]?.url;
+      return (axios, basePath) => createRequestFunction(localVarAxiosArgs, import_axios2.default, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+    },
     /**
      * Confirms an AWD replenishment order in ELIGIBLE state with a set of shipments containing items that are needed to be replenished to an FBA node. Order can only be confirmed in ELIGIBLE state.
      * @param {string} orderId ID of the replenishment order to be confirmed.
@@ -694,6 +896,18 @@ var AmazonWarehousingAndDistributionApiFp = function(configuration) {
       const localVarOperationServerBasePath = operationServerMap["AmazonWarehousingAndDistributionApi.createInbound"]?.[localVarOperationServerIndex]?.url;
       return (axios, basePath) => createRequestFunction(localVarAxiosArgs, import_axios2.default, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
     },
+    /**
+     * Creates a draft AWD outbound order with the specified products. The API returns the order ID for the newly created order and starts an async validation check on the outbound products. After the validation check, the order status transitions from `VALIDATING` to `ELIGIBLE/INELIGIBLE`.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 1 |  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, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
+     * @param {OutboundOrderCreationData} body Payload for creating an outbound order.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async createOutbound(body, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.createOutbound(body, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["AmazonWarehousingAndDistributionApi.createOutbound"]?.[localVarOperationServerIndex]?.url;
+      return (axios, basePath) => createRequestFunction(localVarAxiosArgs, import_axios2.default, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+    },
     /**
      * Creates an AWD replenishment order with given products to replenish. The API will return the order ID of the newly created order and also start an async validation check on the products to e. The order status will transition to ELIGIBLE/INELIGIBLE status from VALIDATING post validation check
      * @param {ReplenishmentOrderCreationData} body Payload for creating a replenishment order.
@@ -745,6 +959,30 @@ var AmazonWarehousingAndDistributionApiFp = function(configuration) {
       const localVarOperationServerBasePath = operationServerMap["AmazonWarehousingAndDistributionApi.getInboundShipmentLabels"]?.[localVarOperationServerIndex]?.url;
       return (axios, basePath) => createRequestFunction(localVarAxiosArgs, import_axios2.default, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
     },
+    /**
+     * Retrieves the available label page types for a shipment ID that you specify. This is an asynchronous operation. If the label status is `GENERATED`, then the pageTypes are available.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 2 |  The `x-amzn-RateLimit-Limit` response header returns the usage plan rate limits that were applied to the requested operation, when available. The preceding table indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may have higher rate and burst values than those shown here. For more information, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
+     * @param {string} shipmentId ID for the shipment.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async getLabelPageTypes(shipmentId, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.getLabelPageTypes(shipmentId, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["AmazonWarehousingAndDistributionApi.getLabelPageTypes"]?.[localVarOperationServerIndex]?.url;
+      return (axios, basePath) => createRequestFunction(localVarAxiosArgs, import_axios2.default, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+    },
+    /**
+     * Retrieves an AWD outbound order with a set of shipments that contain items that are outbound into a destination channel. If the order is not eligible, the validation errors field is included in the order response. The API returns the order ID for the newly created order and starts an async validation check on the outbound products. After the validation check, the order status transitions from `VALIDATING` to `ELIGIBLE/INELIGIBLE`.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 1 |  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, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
+     * @param {string} orderId ID for the outbound order to be retrieved.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async getOutbound(orderId, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.getOutbound(orderId, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["AmazonWarehousingAndDistributionApi.getOutbound"]?.[localVarOperationServerIndex]?.url;
+      return (axios, basePath) => createRequestFunction(localVarAxiosArgs, import_axios2.default, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+    },
     /**
      * Retrieves an AWD Replenishment order with a set of shipments containing items that is/was planned to be replenished into an FBA node.
      * @param {string} orderId ID of the replenishment order to be retrieved.
@@ -791,6 +1029,22 @@ var AmazonWarehousingAndDistributionApiFp = function(configuration) {
       const localVarOperationServerBasePath = operationServerMap["AmazonWarehousingAndDistributionApi.listInventory"]?.[localVarOperationServerIndex]?.url;
       return (axios, basePath) => createRequestFunction(localVarAxiosArgs, import_axios2.default, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
     },
+    /**
+     * Retrieves all outbound AWD orders (with optional filters) that pertain to a merchant. By default, orders are sorted by the `updatedAt` attribute in descending order.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 1 |  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, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
+     * @param {string} [updatedAfter] Get the outbound orders updated after a certain time (inclusive). The date must be in <a href=\'https://developer-docs.amazon.com/sp-api/docs/iso-8601\'>ISO 8601</a> format.
+     * @param {string} [updatedBefore] Get the outbound orders updated before a certain time (inclusive). The date must be in <a href=\'https://developer-docs.amazon.com/sp-api/docs/iso-8601\'>ISO 8601</a> format.
+     * @param {ListOutboundsSortOrderEnum} [sortOrder] Sort the response in `ASCENDING` or `DESCENDING` order.
+     * @param {number} [maxResults] Maximum number of results to return.
+     * @param {string} [nextToken] A token that is used to retrieve the next page of results. The response includes `nextToken` when the number of results exceeds the specified `maxResults` value. To get the next page of results, call the operation with this token and include the same arguments as the call that produced the token. To get a complete list, call this operation until `nextToken` is null. Note that this operation can return empty pages.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async listOutbounds(updatedAfter, updatedBefore, sortOrder, maxResults, nextToken, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.listOutbounds(updatedAfter, updatedBefore, sortOrder, maxResults, nextToken, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["AmazonWarehousingAndDistributionApi.listOutbounds"]?.[localVarOperationServerIndex]?.url;
+      return (axios, basePath) => createRequestFunction(localVarAxiosArgs, import_axios2.default, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+    },
     /**
      * Retrieves all the AWD replenishment orders pertaining to a merchant with optional filters. API by default will sort orders by updatedAt attribute in descending order.
      * @param {string} [updatedAfter] Get the replenishment orders updated after certain time (Inclusive) Date should be in ISO 8601 format as defined by date-time in - https://www.rfc-editor.org/rfc/rfc3339.
@@ -832,6 +1086,19 @@ var AmazonWarehousingAndDistributionApiFp = function(configuration) {
       const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
       const localVarOperationServerBasePath = operationServerMap["AmazonWarehousingAndDistributionApi.updateInboundShipmentTransportDetails"]?.[localVarOperationServerIndex]?.url;
       return (axios, basePath) => createRequestFunction(localVarAxiosArgs, import_axios2.default, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+    },
+    /**
+     * Updates an AWD outbound order that is in `DRAFT`, `ELIGIBLE`, or `INELIGIBLE` status. This API allows updates on `productsToOutbound` and `orderPreferences` attributes only. Any updates will restart the outbound order validation.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 1 |  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, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
+     * @param {string} orderId ID for the outbound order to be updated.
+     * @param {OutboundOrder} body Represents an AWD outbound order.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async updateOutbound(orderId, body, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.updateOutbound(orderId, body, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["AmazonWarehousingAndDistributionApi.updateOutbound"]?.[localVarOperationServerIndex]?.url;
+      return (axios, basePath) => createRequestFunction(localVarAxiosArgs, import_axios2.default, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
     }
   };
 };
@@ -865,6 +1132,15 @@ var AmazonWarehousingAndDistributionApiFactory = function(configuration, basePat
     confirmInbound(requestParameters, options) {
       return localVarFp.confirmInbound(requestParameters.orderId, options).then((request) => request(axios, basePath));
     },
+    /**
+     * Confirms an AWD outbound order for a set of shipments that contain items that must be outbound to a destination node. You can confirm the order only if it\'s in an`ELIGIBLE` state.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 1 |  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, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
+     * @param {AmazonWarehousingAndDistributionApiConfirmOutboundRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    confirmOutbound(requestParameters, options) {
+      return localVarFp.confirmOutbound(requestParameters.orderId, options).then((request) => request(axios, basePath));
+    },
     /**
      * Confirms an AWD replenishment order in ELIGIBLE state with a set of shipments containing items that are needed to be replenished to an FBA node. Order can only be confirmed in ELIGIBLE state.
      * @param {AmazonWarehousingAndDistributionApiConfirmReplenishmentOrderRequest} requestParameters Request parameters.
@@ -883,6 +1159,15 @@ var AmazonWarehousingAndDistributionApiFactory = function(configuration, basePat
     createInbound(requestParameters, options) {
       return localVarFp.createInbound(requestParameters.body, options).then((request) => request(axios, basePath));
     },
+    /**
+     * Creates a draft AWD outbound order with the specified products. The API returns the order ID for the newly created order and starts an async validation check on the outbound products. After the validation check, the order status transitions from `VALIDATING` to `ELIGIBLE/INELIGIBLE`.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 1 |  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, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
+     * @param {AmazonWarehousingAndDistributionApiCreateOutboundRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    createOutbound(requestParameters, options) {
+      return localVarFp.createOutbound(requestParameters.body, options).then((request) => request(axios, basePath));
+    },
     /**
      * Creates an AWD replenishment order with given products to replenish. The API will return the order ID of the newly created order and also start an async validation check on the products to e. The order status will transition to ELIGIBLE/INELIGIBLE status from VALIDATING post validation check
      * @param {AmazonWarehousingAndDistributionApiCreateReplenishmentOrderRequest} requestParameters Request parameters.
@@ -919,6 +1204,24 @@ var AmazonWarehousingAndDistributionApiFactory = function(configuration, basePat
     getInboundShipmentLabels(requestParameters, options) {
       return localVarFp.getInboundShipmentLabels(requestParameters.shipmentId, requestParameters.pageType, requestParameters.formatType, options).then((request) => request(axios, basePath));
     },
+    /**
+     * Retrieves the available label page types for a shipment ID that you specify. This is an asynchronous operation. If the label status is `GENERATED`, then the pageTypes are available.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 2 |  The `x-amzn-RateLimit-Limit` response header returns the usage plan rate limits that were applied to the requested operation, when available. The preceding table indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may have higher rate and burst values than those shown here. For more information, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
+     * @param {AmazonWarehousingAndDistributionApiGetLabelPageTypesRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getLabelPageTypes(requestParameters, options) {
+      return localVarFp.getLabelPageTypes(requestParameters.shipmentId, options).then((request) => request(axios, basePath));
+    },
+    /**
+     * Retrieves an AWD outbound order with a set of shipments that contain items that are outbound into a destination channel. If the order is not eligible, the validation errors field is included in the order response. The API returns the order ID for the newly created order and starts an async validation check on the outbound products. After the validation check, the order status transitions from `VALIDATING` to `ELIGIBLE/INELIGIBLE`.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 1 |  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, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
+     * @param {AmazonWarehousingAndDistributionApiGetOutboundRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getOutbound(requestParameters, options) {
+      return localVarFp.getOutbound(requestParameters.orderId, options).then((request) => request(axios, basePath));
+    },
     /**
      * Retrieves an AWD Replenishment order with a set of shipments containing items that is/was planned to be replenished into an FBA node.
      * @param {AmazonWarehousingAndDistributionApiGetReplenishmentOrderRequest} requestParameters Request parameters.
@@ -946,6 +1249,15 @@ var AmazonWarehousingAndDistributionApiFactory = function(configuration, basePat
     listInventory(requestParameters = {}, options) {
       return localVarFp.listInventory(requestParameters.sku, requestParameters.sortOrder, requestParameters.details, requestParameters.nextToken, requestParameters.maxResults, options).then((request) => request(axios, basePath));
     },
+    /**
+     * Retrieves all outbound AWD orders (with optional filters) that pertain to a merchant. By default, orders are sorted by the `updatedAt` attribute in descending order.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 1 |  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, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
+     * @param {AmazonWarehousingAndDistributionApiListOutboundsRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    listOutbounds(requestParameters = {}, options) {
+      return localVarFp.listOutbounds(requestParameters.updatedAfter, requestParameters.updatedBefore, requestParameters.sortOrder, requestParameters.maxResults, requestParameters.nextToken, options).then((request) => request(axios, basePath));
+    },
     /**
      * Retrieves all the AWD replenishment orders pertaining to a merchant with optional filters. API by default will sort orders by updatedAt attribute in descending order.
      * @param {AmazonWarehousingAndDistributionApiListReplenishmentOrdersRequest} requestParameters Request parameters.
@@ -972,6 +1284,15 @@ var AmazonWarehousingAndDistributionApiFactory = function(configuration, basePat
      */
     updateInboundShipmentTransportDetails(requestParameters, options) {
       return localVarFp.updateInboundShipmentTransportDetails(requestParameters.shipmentId, requestParameters.body, options).then((request) => request(axios, basePath));
+    },
+    /**
+     * Updates an AWD outbound order that is in `DRAFT`, `ELIGIBLE`, or `INELIGIBLE` status. This API allows updates on `productsToOutbound` and `orderPreferences` attributes only. Any updates will restart the outbound order validation.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 1 |  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, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
+     * @param {AmazonWarehousingAndDistributionApiUpdateOutboundRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    updateOutbound(requestParameters, options) {
+      return localVarFp.updateOutbound(requestParameters.orderId, requestParameters.body, options).then((request) => request(axios, basePath));
     }
   };
 };
@@ -1003,6 +1324,15 @@ var AmazonWarehousingAndDistributionApi = class extends BaseAPI {
   confirmInbound(requestParameters, options) {
     return AmazonWarehousingAndDistributionApiFp(this.configuration).confirmInbound(requestParameters.orderId, options).then((request) => request(this.axios, this.basePath));
   }
+  /**
+   * Confirms an AWD outbound order for a set of shipments that contain items that must be outbound to a destination node. You can confirm the order only if it\'s in an`ELIGIBLE` state.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 1 |  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, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
+   * @param {AmazonWarehousingAndDistributionApiConfirmOutboundRequest} requestParameters Request parameters.
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   */
+  confirmOutbound(requestParameters, options) {
+    return AmazonWarehousingAndDistributionApiFp(this.configuration).confirmOutbound(requestParameters.orderId, options).then((request) => request(this.axios, this.basePath));
+  }
   /**
    * Confirms an AWD replenishment order in ELIGIBLE state with a set of shipments containing items that are needed to be replenished to an FBA node. Order can only be confirmed in ELIGIBLE state.
    * @param {AmazonWarehousingAndDistributionApiConfirmReplenishmentOrderRequest} requestParameters Request parameters.
@@ -1021,6 +1351,15 @@ var AmazonWarehousingAndDistributionApi = class extends BaseAPI {
   createInbound(requestParameters, options) {
     return AmazonWarehousingAndDistributionApiFp(this.configuration).createInbound(requestParameters.body, options).then((request) => request(this.axios, this.basePath));
   }
+  /**
+   * Creates a draft AWD outbound order with the specified products. The API returns the order ID for the newly created order and starts an async validation check on the outbound products. After the validation check, the order status transitions from `VALIDATING` to `ELIGIBLE/INELIGIBLE`.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 1 |  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, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
+   * @param {AmazonWarehousingAndDistributionApiCreateOutboundRequest} requestParameters Request parameters.
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   */
+  createOutbound(requestParameters, options) {
+    return AmazonWarehousingAndDistributionApiFp(this.configuration).createOutbound(requestParameters.body, options).then((request) => request(this.axios, this.basePath));
+  }
   /**
    * Creates an AWD replenishment order with given products to replenish. The API will return the order ID of the newly created order and also start an async validation check on the products to e. The order status will transition to ELIGIBLE/INELIGIBLE status from VALIDATING post validation check
    * @param {AmazonWarehousingAndDistributionApiCreateReplenishmentOrderRequest} requestParameters Request parameters.
@@ -1057,6 +1396,24 @@ var AmazonWarehousingAndDistributionApi = class extends BaseAPI {
   getInboundShipmentLabels(requestParameters, options) {
     return AmazonWarehousingAndDistributionApiFp(this.configuration).getInboundShipmentLabels(requestParameters.shipmentId, requestParameters.pageType, requestParameters.formatType, options).then((request) => request(this.axios, this.basePath));
   }
+  /**
+   * Retrieves the available label page types for a shipment ID that you specify. This is an asynchronous operation. If the label status is `GENERATED`, then the pageTypes are available.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 2 |  The `x-amzn-RateLimit-Limit` response header returns the usage plan rate limits that were applied to the requested operation, when available. The preceding table indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may have higher rate and burst values than those shown here. For more information, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
+   * @param {AmazonWarehousingAndDistributionApiGetLabelPageTypesRequest} requestParameters Request parameters.
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   */
+  getLabelPageTypes(requestParameters, options) {
+    return AmazonWarehousingAndDistributionApiFp(this.configuration).getLabelPageTypes(requestParameters.shipmentId, options).then((request) => request(this.axios, this.basePath));
+  }
+  /**
+   * Retrieves an AWD outbound order with a set of shipments that contain items that are outbound into a destination channel. If the order is not eligible, the validation errors field is included in the order response. The API returns the order ID for the newly created order and starts an async validation check on the outbound products. After the validation check, the order status transitions from `VALIDATING` to `ELIGIBLE/INELIGIBLE`.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 1 |  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, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
+   * @param {AmazonWarehousingAndDistributionApiGetOutboundRequest} requestParameters Request parameters.
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   */
+  getOutbound(requestParameters, options) {
+    return AmazonWarehousingAndDistributionApiFp(this.configuration).getOutbound(requestParameters.orderId, options).then((request) => request(this.axios, this.basePath));
+  }
   /**
    * Retrieves an AWD Replenishment order with a set of shipments containing items that is/was planned to be replenished into an FBA node.
    * @param {AmazonWarehousingAndDistributionApiGetReplenishmentOrderRequest} requestParameters Request parameters.
@@ -1084,6 +1441,15 @@ var AmazonWarehousingAndDistributionApi = class extends BaseAPI {
   listInventory(requestParameters = {}, options) {
     return AmazonWarehousingAndDistributionApiFp(this.configuration).listInventory(requestParameters.sku, requestParameters.sortOrder, requestParameters.details, requestParameters.nextToken, requestParameters.maxResults, options).then((request) => request(this.axios, this.basePath));
   }
+  /**
+   * Retrieves all outbound AWD orders (with optional filters) that pertain to a merchant. By default, orders are sorted by the `updatedAt` attribute in descending order.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 1 |  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, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
+   * @param {AmazonWarehousingAndDistributionApiListOutboundsRequest} requestParameters Request parameters.
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   */
+  listOutbounds(requestParameters = {}, options) {
+    return AmazonWarehousingAndDistributionApiFp(this.configuration).listOutbounds(requestParameters.updatedAfter, requestParameters.updatedBefore, requestParameters.sortOrder, requestParameters.maxResults, requestParameters.nextToken, options).then((request) => request(this.axios, this.basePath));
+  }
   /**
    * Retrieves all the AWD replenishment orders pertaining to a merchant with optional filters. API by default will sort orders by updatedAt attribute in descending order.
    * @param {AmazonWarehousingAndDistributionApiListReplenishmentOrdersRequest} requestParameters Request parameters.
@@ -1111,15 +1477,22 @@ var AmazonWarehousingAndDistributionApi = class extends BaseAPI {
   updateInboundShipmentTransportDetails(requestParameters, options) {
     return AmazonWarehousingAndDistributionApiFp(this.configuration).updateInboundShipmentTransportDetails(requestParameters.shipmentId, requestParameters.body, options).then((request) => request(this.axios, this.basePath));
   }
+  /**
+   * Updates an AWD outbound order that is in `DRAFT`, `ELIGIBLE`, or `INELIGIBLE` status. This API allows updates on `productsToOutbound` and `orderPreferences` attributes only. Any updates will restart the outbound order validation.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 1 | 1 |  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, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
+   * @param {AmazonWarehousingAndDistributionApiUpdateOutboundRequest} requestParameters Request parameters.
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   */
+  updateOutbound(requestParameters, options) {
+    return AmazonWarehousingAndDistributionApiFp(this.configuration).updateOutbound(requestParameters.orderId, requestParameters.body, options).then((request) => request(this.axios, this.basePath));
+  }
 };
 var GetInboundShipmentSkuQuantitiesEnum = {
   Show: "SHOW",
   Hide: "HIDE"
 };
 var GetInboundShipmentLabelsPageTypeEnum = {
-  ThermalNonpcp: "THERMAL_NONPCP",
-  PlainPaper: "PLAIN_PAPER",
-  Letter6: "LETTER_6"
+  PlainPaper: "PLAIN_PAPER"
 };
 var GetInboundShipmentLabelsFormatTypeEnum = {
   Pdf: "PDF"
@@ -1149,6 +1522,10 @@ var ListInventoryDetailsEnum = {
   Show: "SHOW",
   Hide: "HIDE"
 };
+var ListOutboundsSortOrderEnum = {
+  Ascending: "ASCENDING",
+  Descending: "DESCENDING"
+};
 var ListReplenishmentOrdersSortOrderEnum = {
   Ascending: "ASCENDING",
   Descending: "DESCENDING"
@@ -1261,6 +1638,11 @@ var DistributionPackageType = {
   Pallet: "PALLET"
 };
 
+// src/api-model/models/format-type.ts
+var FormatType = {
+  Pdf: "PDF"
+};
+
 // src/api-model/models/inbound-eligibility-status.ts
 var InboundEligibilityStatus = {
   Eligible: "ELIGIBLE",
@@ -1288,6 +1670,12 @@ var InboundStatus = {
   Cancelled: "CANCELLED"
 };
 
+// src/api-model/models/inventory-details-visibility.ts
+var InventoryDetailsVisibility = {
+  Show: "SHOW",
+  Hide: "HIDE"
+};
+
 // src/api-model/models/inventory-unit-of-measurement.ts
 var InventoryUnitOfMeasurement = {
   ProductUnits: "PRODUCT_UNITS",
@@ -1309,6 +1697,17 @@ var LabelStatus = {
   NotReady: "NOT_READY"
 };
 
+// src/api-model/models/order-preference.ts
+var OrderPreference = {
+  PartialOrder: "PARTIAL_ORDER"
+};
+
+// src/api-model/models/order-preference-value.ts
+var OrderPreferenceValue = {
+  Set: "SET",
+  Unset: "UNSET"
+};
+
 // src/api-model/models/outbound-shipment-status.ts
 var OutboundShipmentStatus = {
   Created: "CREATED",
@@ -1321,6 +1720,32 @@ var OutboundShipmentStatus = {
   Failed: "FAILED"
 };
 
+// src/api-model/models/outbound-status.ts
+var OutboundStatus = {
+  Confirmed: "CONFIRMED",
+  Draft: "DRAFT",
+  Eligible: "ELIGIBLE",
+  Executing: "EXECUTING",
+  Failure: "FAILURE",
+  Ineligible: "INELIGIBLE",
+  InventoryOutbound: "INVENTORY_OUTBOUND",
+  Success: "SUCCESS",
+  Validating: "VALIDATING"
+};
+
+// src/api-model/models/page-type.ts
+var PageType = {
+  PlainPaper: "PLAIN_PAPER",
+  LetterPcpFulfillmentlabel: "LETTER_PCP_FULFILLMENTLABEL",
+  Letter2Horizontal: "LETTER_2_HORIZONTAL",
+  Letter2: "LETTER_2",
+  ThermalNoCarrierRotation: "THERMAL_NO_CARRIER_ROTATION",
+  Thermal: "THERMAL",
+  A4Paper: "A4_PAPER",
+  A42Horizontal: "A4_2_HORIZONTAL",
+  ThermalSquare10Cm: "THERMAL_SQUARE_10CM"
+};
+
 // src/api-model/models/prep-category.ts
 var PrepCategory = {
   Adult: "ADULT",
@@ -1358,6 +1783,24 @@ var ReplenishmentOrderStatus = {
   Validating: "VALIDATING"
 };
 
+// src/api-model/models/shipment-sortable-field.ts
+var ShipmentSortableField = {
+  UpdatedAt: "UPDATED_AT",
+  CreatedAt: "CREATED_AT"
+};
+
+// src/api-model/models/sku-quantities-visibility.ts
+var SkuQuantitiesVisibility = {
+  Show: "SHOW",
+  Hide: "HIDE"
+};
+
+// src/api-model/models/sort-order.ts
+var SortOrder = {
+  Ascending: "ASCENDING",
+  Descending: "DESCENDING"
+};
+
 // src/api-model/models/volume-unit-of-measurement.ts
 var VolumeUnitOfMeasurement = {
   CuIn: "CU_IN",
@@ -1422,6 +1865,13 @@ var clientRateLimits = [
     rate: 1,
     burst: 2
   },
+  {
+    method: "get",
+    // eslint-disable-next-line prefer-regex-literals
+    urlRegex: new RegExp("^/awd/2024-05-09/inboundShipments/[^/]*/labelPageTypes$"),
+    rate: 1,
+    burst: 2
+  },
   {
     method: "put",
     // eslint-disable-next-line prefer-regex-literals
@@ -1449,6 +1899,41 @@ var clientRateLimits = [
     urlRegex: new RegExp("^/awd/2024-05-09/inventory$"),
     rate: 2,
     burst: 2
+  },
+  {
+    method: "get",
+    // eslint-disable-next-line prefer-regex-literals
+    urlRegex: new RegExp("^/awd/2024-05-09/outboundOrders$"),
+    rate: 1,
+    burst: 1
+  },
+  {
+    method: "post",
+    // eslint-disable-next-line prefer-regex-literals
+    urlRegex: new RegExp("^/awd/2024-05-09/outboundOrders$"),
+    rate: 1,
+    burst: 1
+  },
+  {
+    method: "get",
+    // eslint-disable-next-line prefer-regex-literals
+    urlRegex: new RegExp("^/awd/2024-05-09/outboundOrders/[^/]*$"),
+    rate: 1,
+    burst: 1
+  },
+  {
+    method: "put",
+    // eslint-disable-next-line prefer-regex-literals
+    urlRegex: new RegExp("^/awd/2024-05-09/outboundOrders/[^/]*$"),
+    rate: 1,
+    burst: 1
+  },
+  {
+    method: "post",
+    // eslint-disable-next-line prefer-regex-literals
+    urlRegex: new RegExp("^/awd/2024-05-09/outboundOrders/[^/]*/confirmation$"),
+    rate: 1,
+    burst: 1
   }
 ];
 var AmazonWarehousingAndDistributionApiClient = class extends AmazonWarehousingAndDistributionApi {
@@ -1468,12 +1953,14 @@ var AmazonWarehousingAndDistributionApiClient = class extends AmazonWarehousingA
   ConfirmationMode,
   DimensionUnitOfMeasurement,
   DistributionPackageType,
+  FormatType,
   GetInboundShipmentLabelsFormatTypeEnum,
   GetInboundShipmentLabelsPageTypeEnum,
   GetInboundShipmentSkuQuantitiesEnum,
   InboundEligibilityStatus,
   InboundShipmentStatus,
   InboundStatus,
+  InventoryDetailsVisibility,
   InventoryUnitOfMeasurement,
   LabelOwner,
   LabelStatus,
@@ -1482,11 +1969,19 @@ var AmazonWarehousingAndDistributionApiClient = class extends AmazonWarehousingA
   ListInboundShipmentsSortOrderEnum,
   ListInventoryDetailsEnum,
   ListInventorySortOrderEnum,
+  ListOutboundsSortOrderEnum,
   ListReplenishmentOrdersSortOrderEnum,
+  OrderPreference,
+  OrderPreferenceValue,
   OutboundShipmentStatus,
+  OutboundStatus,
+  PageType,
   PrepCategory,
   PrepOwner,
   ReplenishmentOrderStatus,
+  ShipmentSortableField,
+  SkuQuantitiesVisibility,
+  SortOrder,
   VolumeUnitOfMeasurement,
   WeightUnitOfMeasurement,
   clientRateLimits