# coding: utf-8

"""
    Selling Partner APIs for Fulfillment Outbound

    The Selling Partner API for Fulfillment Outbound lets you create applications that help a seller fulfill Multi-Channel Fulfillment orders using their inventory in Amazon's fulfillment network. You can get information on both potential and existing fulfillment orders.

    The version of the OpenAPI document: 2020-07-01
    Generated by OpenAPI Generator (https://openapi-generator.tech)

    Do not edit the class manually.
"""  # noqa: E501


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from spapi.api_client import ApiClient


class FbaOutboundApi(object):
    """NOTE: This class is auto generated by the openapi generator.

    Do not edit the class manually.
    """

    api_models_module = "spapi.models.fulfillment_outbound_v2020_07_01"

    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client
        self.classFileName = 'fba_outbound_api'

    def cancel_fulfillment_order(self, seller_fulfillment_order_id, **kwargs):  # noqa: E501
        """cancel_fulfillment_order  # noqa: E501

        Requests that Amazon stop attempting to fulfill the fulfillment order indicated by the specified order identifier.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 30 |  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 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).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.cancel_fulfillment_order(seller_fulfillment_order_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str seller_fulfillment_order_id: The identifier assigned to the item by the seller when the fulfillment order was created. (required)
        :return: CancelFulfillmentOrderResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.cancel_fulfillment_order_with_http_info(seller_fulfillment_order_id, **kwargs)  # noqa: E501
        else:
            (data) = self.cancel_fulfillment_order_with_http_info(seller_fulfillment_order_id, **kwargs)  # noqa: E501
            return data

    def cancel_fulfillment_order_with_http_info(self, seller_fulfillment_order_id, **kwargs):  # noqa: E501
        """cancel_fulfillment_order  # noqa: E501

        Requests that Amazon stop attempting to fulfill the fulfillment order indicated by the specified order identifier.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 30 |  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 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).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.cancel_fulfillment_order_with_http_info(seller_fulfillment_order_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str seller_fulfillment_order_id: The identifier assigned to the item by the seller when the fulfillment order was created. (required)
        :return: CancelFulfillmentOrderResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['seller_fulfillment_order_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method cancel_fulfillment_order" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'seller_fulfillment_order_id' is set
        if self.api_client.client_side_validation and ('seller_fulfillment_order_id' not in params or
                                                       params['seller_fulfillment_order_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `seller_fulfillment_order_id` when calling `cancel_fulfillment_order`")  # noqa: E501

        if self.api_client.client_side_validation and ('seller_fulfillment_order_id' in params and
                                                       len(params['seller_fulfillment_order_id']) > 40):
            raise ValueError("Invalid value for parameter `seller_fulfillment_order_id` when calling `cancel_fulfillment_order`, length must be less than or equal to `40`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'seller_fulfillment_order_id' in params:
            path_params['sellerFulfillmentOrderId'] = params['seller_fulfillment_order_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/fba/outbound/2020-07-01/fulfillmentOrders/{sellerFulfillmentOrderId}/cancel', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CancelFulfillmentOrderResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats, api_models_module=self.api_models_module)

    def create_fulfillment_order(self, body, **kwargs):  # noqa: E501
        """create_fulfillment_order  # noqa: E501

        Requests that Amazon ship items from the seller's inventory in Amazon's fulfillment network to a destination address.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 30 |  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 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)  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_fulfillment_order(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateFulfillmentOrderRequest body: CreateFulfillmentOrderRequest parameter (required)
        :return: CreateFulfillmentOrderResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_fulfillment_order_with_http_info(body, **kwargs)  # noqa: E501
        else:
            (data) = self.create_fulfillment_order_with_http_info(body, **kwargs)  # noqa: E501
            return data

    def create_fulfillment_order_with_http_info(self, body, **kwargs):  # noqa: E501
        """create_fulfillment_order  # noqa: E501

        Requests that Amazon ship items from the seller's inventory in Amazon's fulfillment network to a destination address.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 30 |  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 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)  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_fulfillment_order_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateFulfillmentOrderRequest body: CreateFulfillmentOrderRequest parameter (required)
        :return: CreateFulfillmentOrderResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_fulfillment_order" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if self.api_client.client_side_validation and ('body' not in params or
                                                       params['body'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `body` when calling `create_fulfillment_order`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/fba/outbound/2020-07-01/fulfillmentOrders', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateFulfillmentOrderResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats, api_models_module=self.api_models_module)

    def create_fulfillment_return(self, seller_fulfillment_order_id, body, **kwargs):  # noqa: E501
        """create_fulfillment_return  # noqa: E501

        Creates a fulfillment return.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 30 |  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 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).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_fulfillment_return(seller_fulfillment_order_id, body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str seller_fulfillment_order_id: An identifier the seller assigns to the fulfillment order at the time it was created. The seller uses their own records to find the correct `sellerFulfillmentOrderId` value based on the buyer's request to return items. (required)
        :param CreateFulfillmentReturnRequest body: The request body of the `createFulfillmentReturn` operation. (required)
        :return: CreateFulfillmentReturnResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_fulfillment_return_with_http_info(seller_fulfillment_order_id, body, **kwargs)  # noqa: E501
        else:
            (data) = self.create_fulfillment_return_with_http_info(seller_fulfillment_order_id, body, **kwargs)  # noqa: E501
            return data

    def create_fulfillment_return_with_http_info(self, seller_fulfillment_order_id, body, **kwargs):  # noqa: E501
        """create_fulfillment_return  # noqa: E501

        Creates a fulfillment return.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 30 |  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 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).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_fulfillment_return_with_http_info(seller_fulfillment_order_id, body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str seller_fulfillment_order_id: An identifier the seller assigns to the fulfillment order at the time it was created. The seller uses their own records to find the correct `sellerFulfillmentOrderId` value based on the buyer's request to return items. (required)
        :param CreateFulfillmentReturnRequest body: The request body of the `createFulfillmentReturn` operation. (required)
        :return: CreateFulfillmentReturnResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['seller_fulfillment_order_id', 'body']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_fulfillment_return" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'seller_fulfillment_order_id' is set
        if self.api_client.client_side_validation and ('seller_fulfillment_order_id' not in params or
                                                       params['seller_fulfillment_order_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `seller_fulfillment_order_id` when calling `create_fulfillment_return`")  # noqa: E501
        # verify the required parameter 'body' is set
        if self.api_client.client_side_validation and ('body' not in params or
                                                       params['body'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `body` when calling `create_fulfillment_return`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'seller_fulfillment_order_id' in params:
            path_params['sellerFulfillmentOrderId'] = params['seller_fulfillment_order_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'payload'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/fba/outbound/2020-07-01/fulfillmentOrders/{sellerFulfillmentOrderId}/return', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateFulfillmentReturnResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats, api_models_module=self.api_models_module)

    def delivery_offers(self, body, **kwargs):  # noqa: E501
        """delivery_offers  # noqa: E501

        Returns delivery options that include an estimated delivery date and offer expiration, based on criteria that you specify.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 5 | 30 |  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 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).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delivery_offers(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetDeliveryOffersRequest body: GetDeliveryOffersRequest parameter (required)
        :return: GetDeliveryOffersResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delivery_offers_with_http_info(body, **kwargs)  # noqa: E501
        else:
            (data) = self.delivery_offers_with_http_info(body, **kwargs)  # noqa: E501
            return data

    def delivery_offers_with_http_info(self, body, **kwargs):  # noqa: E501
        """delivery_offers  # noqa: E501

        Returns delivery options that include an estimated delivery date and offer expiration, based on criteria that you specify.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 5 | 30 |  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 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).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delivery_offers_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetDeliveryOffersRequest body: GetDeliveryOffersRequest parameter (required)
        :return: GetDeliveryOffersResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delivery_offers" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if self.api_client.client_side_validation and ('body' not in params or
                                                       params['body'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `body` when calling `delivery_offers`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'payload'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/fba/outbound/2020-07-01/deliveryOffers', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GetDeliveryOffersResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats, api_models_module=self.api_models_module)

    def get_feature_inventory(self, marketplace_id, feature_name, **kwargs):  # noqa: E501
        """get_feature_inventory  # noqa: E501

        Returns a list of inventory items that are eligible for the fulfillment feature you specify.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 30 |  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 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)..  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_feature_inventory(marketplace_id, feature_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str marketplace_id: The marketplace for which to return a list of the inventory that is eligible for the specified feature. (required)
        :param str feature_name: The name of the feature for which to return a list of eligible inventory. (required)
        :param str next_token: A string token returned in the response to your previous request that is used to return the next response page. A value of `null` will return the first page.
        :param datetime query_start_date: A date that you can use to select inventory that has been updated since a specified date. An update is defined as any change in feature-enabled inventory availability. The date must be in the format `yyyy-MM-ddTHH:mm:ss.sssZ`
        :return: GetFeatureInventoryResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_feature_inventory_with_http_info(marketplace_id, feature_name, **kwargs)  # noqa: E501
        else:
            (data) = self.get_feature_inventory_with_http_info(marketplace_id, feature_name, **kwargs)  # noqa: E501
            return data

    def get_feature_inventory_with_http_info(self, marketplace_id, feature_name, **kwargs):  # noqa: E501
        """get_feature_inventory  # noqa: E501

        Returns a list of inventory items that are eligible for the fulfillment feature you specify.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 30 |  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 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)..  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_feature_inventory_with_http_info(marketplace_id, feature_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str marketplace_id: The marketplace for which to return a list of the inventory that is eligible for the specified feature. (required)
        :param str feature_name: The name of the feature for which to return a list of eligible inventory. (required)
        :param str next_token: A string token returned in the response to your previous request that is used to return the next response page. A value of `null` will return the first page.
        :param datetime query_start_date: A date that you can use to select inventory that has been updated since a specified date. An update is defined as any change in feature-enabled inventory availability. The date must be in the format `yyyy-MM-ddTHH:mm:ss.sssZ`
        :return: GetFeatureInventoryResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['marketplace_id', 'feature_name', 'next_token', 'query_start_date']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_feature_inventory" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'marketplace_id' is set
        if self.api_client.client_side_validation and ('marketplace_id' not in params or
                                                       params['marketplace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `marketplace_id` when calling `get_feature_inventory`")  # noqa: E501
        # verify the required parameter 'feature_name' is set
        if self.api_client.client_side_validation and ('feature_name' not in params or
                                                       params['feature_name'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `feature_name` when calling `get_feature_inventory`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'feature_name' in params:
            path_params['featureName'] = params['feature_name']  # noqa: E501

        query_params = []
        if 'marketplace_id' in params:
            query_params.append(('marketplaceId', params['marketplace_id']))  # noqa: E501
        if 'next_token' in params:
            query_params.append(('nextToken', params['next_token']))  # noqa: E501
        if 'query_start_date' in params:
            query_params.append(('queryStartDate', params['query_start_date']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'payload'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/fba/outbound/2020-07-01/features/inventory/{featureName}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GetFeatureInventoryResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats, api_models_module=self.api_models_module)

    def get_feature_sku(self, marketplace_id, feature_name, seller_sku, **kwargs):  # noqa: E501
        """get_feature_sku  # noqa: E501

        Returns the number of items with the `sellerSku` you specify that can have orders fulfilled using the specified feature. Note that if the `sellerSku` isn't eligible, the response will contain an empty `skuInfo` object. The parameters for this operation may contain special characters that require URL encoding. To avoid errors with SKUs when encoding URLs, refer to [URL Encoding](https://developer-docs.amazon.com/sp-api/docs/url-encoding).  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 30 |  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 see higher rate and burst values than those shown here. For more information, see [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).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_feature_sku(marketplace_id, feature_name, seller_sku, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str marketplace_id: The marketplace for which to return the count. (required)
        :param str feature_name: The name of the feature. (required)
        :param str seller_sku: Used to identify an item in the given marketplace. `sellerSku` is qualified by the seller's `sellerId`, which is included with every operation that you submit. (required)
        :return: GetFeatureSkuResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_feature_sku_with_http_info(marketplace_id, feature_name, seller_sku, **kwargs)  # noqa: E501
        else:
            (data) = self.get_feature_sku_with_http_info(marketplace_id, feature_name, seller_sku, **kwargs)  # noqa: E501
            return data

    def get_feature_sku_with_http_info(self, marketplace_id, feature_name, seller_sku, **kwargs):  # noqa: E501
        """get_feature_sku  # noqa: E501

        Returns the number of items with the `sellerSku` you specify that can have orders fulfilled using the specified feature. Note that if the `sellerSku` isn't eligible, the response will contain an empty `skuInfo` object. The parameters for this operation may contain special characters that require URL encoding. To avoid errors with SKUs when encoding URLs, refer to [URL Encoding](https://developer-docs.amazon.com/sp-api/docs/url-encoding).  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 30 |  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 see higher rate and burst values than those shown here. For more information, see [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).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_feature_sku_with_http_info(marketplace_id, feature_name, seller_sku, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str marketplace_id: The marketplace for which to return the count. (required)
        :param str feature_name: The name of the feature. (required)
        :param str seller_sku: Used to identify an item in the given marketplace. `sellerSku` is qualified by the seller's `sellerId`, which is included with every operation that you submit. (required)
        :return: GetFeatureSkuResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['marketplace_id', 'feature_name', 'seller_sku']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_feature_sku" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'marketplace_id' is set
        if self.api_client.client_side_validation and ('marketplace_id' not in params or
                                                       params['marketplace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `marketplace_id` when calling `get_feature_sku`")  # noqa: E501
        # verify the required parameter 'feature_name' is set
        if self.api_client.client_side_validation and ('feature_name' not in params or
                                                       params['feature_name'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `feature_name` when calling `get_feature_sku`")  # noqa: E501
        # verify the required parameter 'seller_sku' is set
        if self.api_client.client_side_validation and ('seller_sku' not in params or
                                                       params['seller_sku'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `seller_sku` when calling `get_feature_sku`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'feature_name' in params:
            path_params['featureName'] = params['feature_name']  # noqa: E501
        if 'seller_sku' in params:
            path_params['sellerSku'] = params['seller_sku']  # noqa: E501

        query_params = []
        if 'marketplace_id' in params:
            query_params.append(('marketplaceId', params['marketplace_id']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'payload'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/fba/outbound/2020-07-01/features/inventory/{featureName}/{sellerSku}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GetFeatureSkuResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats, api_models_module=self.api_models_module)

    def get_features(self, marketplace_id, **kwargs):  # noqa: E501
        """get_features  # noqa: E501

        Returns a list of features available for Multi-Channel Fulfillment orders in the marketplace you specify, and whether the seller for which you made the call is enrolled for each feature.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 30 |  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 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).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_features(marketplace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str marketplace_id: The marketplace for which to return the list of features. (required)
        :return: GetFeaturesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_features_with_http_info(marketplace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_features_with_http_info(marketplace_id, **kwargs)  # noqa: E501
            return data

    def get_features_with_http_info(self, marketplace_id, **kwargs):  # noqa: E501
        """get_features  # noqa: E501

        Returns a list of features available for Multi-Channel Fulfillment orders in the marketplace you specify, and whether the seller for which you made the call is enrolled for each feature.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 30 |  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 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).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_features_with_http_info(marketplace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str marketplace_id: The marketplace for which to return the list of features. (required)
        :return: GetFeaturesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['marketplace_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_features" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'marketplace_id' is set
        if self.api_client.client_side_validation and ('marketplace_id' not in params or
                                                       params['marketplace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `marketplace_id` when calling `get_features`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'marketplace_id' in params:
            query_params.append(('marketplaceId', params['marketplace_id']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'payload'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/fba/outbound/2020-07-01/features', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GetFeaturesResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats, api_models_module=self.api_models_module)

    def get_fulfillment_order(self, seller_fulfillment_order_id, **kwargs):  # noqa: E501
        """get_fulfillment_order  # noqa: E501

        Returns the fulfillment order indicated by the specified order identifier.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 30 |  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 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).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_fulfillment_order(seller_fulfillment_order_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str seller_fulfillment_order_id: The identifier assigned to the item by the seller when the fulfillment order was created. (required)
        :return: GetFulfillmentOrderResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_fulfillment_order_with_http_info(seller_fulfillment_order_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_fulfillment_order_with_http_info(seller_fulfillment_order_id, **kwargs)  # noqa: E501
            return data

    def get_fulfillment_order_with_http_info(self, seller_fulfillment_order_id, **kwargs):  # noqa: E501
        """get_fulfillment_order  # noqa: E501

        Returns the fulfillment order indicated by the specified order identifier.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 30 |  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 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).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_fulfillment_order_with_http_info(seller_fulfillment_order_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str seller_fulfillment_order_id: The identifier assigned to the item by the seller when the fulfillment order was created. (required)
        :return: GetFulfillmentOrderResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['seller_fulfillment_order_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_fulfillment_order" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'seller_fulfillment_order_id' is set
        if self.api_client.client_side_validation and ('seller_fulfillment_order_id' not in params or
                                                       params['seller_fulfillment_order_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `seller_fulfillment_order_id` when calling `get_fulfillment_order`")  # noqa: E501

        if self.api_client.client_side_validation and ('seller_fulfillment_order_id' in params and
                                                       len(params['seller_fulfillment_order_id']) > 40):
            raise ValueError("Invalid value for parameter `seller_fulfillment_order_id` when calling `get_fulfillment_order`, length must be less than or equal to `40`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'seller_fulfillment_order_id' in params:
            path_params['sellerFulfillmentOrderId'] = params['seller_fulfillment_order_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'payload'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/fba/outbound/2020-07-01/fulfillmentOrders/{sellerFulfillmentOrderId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GetFulfillmentOrderResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats, api_models_module=self.api_models_module)

    def get_fulfillment_preview(self, body, **kwargs):  # noqa: E501
        """get_fulfillment_preview  # noqa: E501

        Returns a list of fulfillment order previews based on shipping criteria that you specify.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 30 |  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 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).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_fulfillment_preview(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetFulfillmentPreviewRequest body: GetFulfillmentPreviewRequest parameter (required)
        :return: GetFulfillmentPreviewResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_fulfillment_preview_with_http_info(body, **kwargs)  # noqa: E501
        else:
            (data) = self.get_fulfillment_preview_with_http_info(body, **kwargs)  # noqa: E501
            return data

    def get_fulfillment_preview_with_http_info(self, body, **kwargs):  # noqa: E501
        """get_fulfillment_preview  # noqa: E501

        Returns a list of fulfillment order previews based on shipping criteria that you specify.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 30 |  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 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).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_fulfillment_preview_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetFulfillmentPreviewRequest body: GetFulfillmentPreviewRequest parameter (required)
        :return: GetFulfillmentPreviewResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_fulfillment_preview" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if self.api_client.client_side_validation and ('body' not in params or
                                                       params['body'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `body` when calling `get_fulfillment_preview`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'payload'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/fba/outbound/2020-07-01/fulfillmentOrders/preview', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GetFulfillmentPreviewResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats, api_models_module=self.api_models_module)

    def get_package_tracking_details(self, **kwargs):  # noqa: E501
        """get_package_tracking_details  # noqa: E501

        Returns delivery tracking information for a package in an outbound shipment for a Multi-Channel Fulfillment order.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 30 |  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 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).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_package_tracking_details(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param int package_number: The unencrypted package identifier. You can obtain this value from the `getFulfillmentOrder` operation.
        :param str amazon_fulfillment_tracking_number: The Amazon fulfillment tracking number. You can obtain this value from the `getFulfillmentOrder` operation.
        :return: GetPackageTrackingDetailsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_package_tracking_details_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.get_package_tracking_details_with_http_info(**kwargs)  # noqa: E501
            return data

    def get_package_tracking_details_with_http_info(self, **kwargs):  # noqa: E501
        """get_package_tracking_details  # noqa: E501

        Returns delivery tracking information for a package in an outbound shipment for a Multi-Channel Fulfillment order.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 30 |  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 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).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_package_tracking_details_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param int package_number: The unencrypted package identifier. You can obtain this value from the `getFulfillmentOrder` operation.
        :param str amazon_fulfillment_tracking_number: The Amazon fulfillment tracking number. You can obtain this value from the `getFulfillmentOrder` operation.
        :return: GetPackageTrackingDetailsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['package_number', 'amazon_fulfillment_tracking_number']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_package_tracking_details" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'package_number' in params:
            query_params.append(('packageNumber', params['package_number']))  # noqa: E501
        if 'amazon_fulfillment_tracking_number' in params:
            query_params.append(('amazonFulfillmentTrackingNumber', params['amazon_fulfillment_tracking_number']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'payload'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/fba/outbound/2020-07-01/tracking', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GetPackageTrackingDetailsResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats, api_models_module=self.api_models_module)

    def list_all_fulfillment_orders(self, **kwargs):  # noqa: E501
        """list_all_fulfillment_orders  # noqa: E501

        Returns a list of fulfillment orders fulfilled after (or at) a specified date-time, or indicated by the `nextToken` parameter.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 30 |  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 see higher rate and burst values than those shown here. For more information, see [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)  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_all_fulfillment_orders(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param datetime query_start_date: A date used to select fulfillment orders that were last updated after (or at) a specified time. An update is defined as any change in fulfillment order status, including the creation of a new fulfillment order.
        :param str next_token: A string token returned in the response to your previous request.
        :return: ListAllFulfillmentOrdersResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_all_fulfillment_orders_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.list_all_fulfillment_orders_with_http_info(**kwargs)  # noqa: E501
            return data

    def list_all_fulfillment_orders_with_http_info(self, **kwargs):  # noqa: E501
        """list_all_fulfillment_orders  # noqa: E501

        Returns a list of fulfillment orders fulfilled after (or at) a specified date-time, or indicated by the `nextToken` parameter.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 30 |  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 see higher rate and burst values than those shown here. For more information, see [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)  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_all_fulfillment_orders_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param datetime query_start_date: A date used to select fulfillment orders that were last updated after (or at) a specified time. An update is defined as any change in fulfillment order status, including the creation of a new fulfillment order.
        :param str next_token: A string token returned in the response to your previous request.
        :return: ListAllFulfillmentOrdersResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['query_start_date', 'next_token']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_all_fulfillment_orders" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'query_start_date' in params:
            query_params.append(('queryStartDate', params['query_start_date']))  # noqa: E501
        if 'next_token' in params:
            query_params.append(('nextToken', params['next_token']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'payload'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/fba/outbound/2020-07-01/fulfillmentOrders', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ListAllFulfillmentOrdersResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats, api_models_module=self.api_models_module)

    def list_return_reason_codes(self, seller_sku, **kwargs):  # noqa: E501
        """list_return_reason_codes  # noqa: E501

        Returns a list of return reason codes for a seller SKU in a given marketplace. The parameters for this operation may contain special characters that require URL encoding. To avoid errors with SKUs when encoding URLs, refer to [URL Encoding](https://developer-docs.amazon.com/sp-api/docs/url-encoding).  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 30 |  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 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).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_return_reason_codes(seller_sku, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str seller_sku: The seller SKU for which return reason codes are required. (required)
        :param str marketplace_id: The marketplace for which the seller wants return reason codes.
        :param str seller_fulfillment_order_id: The identifier assigned to the item by the seller when the fulfillment order was created. The service uses this value to determine the marketplace for which the seller wants return reason codes.
        :param str language: The language that the `TranslatedDescription` property of the `ReasonCodeDetails` response object should be translated into.
        :return: ListReturnReasonCodesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_return_reason_codes_with_http_info(seller_sku, **kwargs)  # noqa: E501
        else:
            (data) = self.list_return_reason_codes_with_http_info(seller_sku, **kwargs)  # noqa: E501
            return data

    def list_return_reason_codes_with_http_info(self, seller_sku, **kwargs):  # noqa: E501
        """list_return_reason_codes  # noqa: E501

        Returns a list of return reason codes for a seller SKU in a given marketplace. The parameters for this operation may contain special characters that require URL encoding. To avoid errors with SKUs when encoding URLs, refer to [URL Encoding](https://developer-docs.amazon.com/sp-api/docs/url-encoding).  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 30 |  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 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).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_return_reason_codes_with_http_info(seller_sku, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str seller_sku: The seller SKU for which return reason codes are required. (required)
        :param str marketplace_id: The marketplace for which the seller wants return reason codes.
        :param str seller_fulfillment_order_id: The identifier assigned to the item by the seller when the fulfillment order was created. The service uses this value to determine the marketplace for which the seller wants return reason codes.
        :param str language: The language that the `TranslatedDescription` property of the `ReasonCodeDetails` response object should be translated into.
        :return: ListReturnReasonCodesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['seller_sku', 'marketplace_id', 'seller_fulfillment_order_id', 'language']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_return_reason_codes" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'seller_sku' is set
        if self.api_client.client_side_validation and ('seller_sku' not in params or
                                                       params['seller_sku'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `seller_sku` when calling `list_return_reason_codes`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'seller_sku' in params:
            query_params.append(('sellerSku', params['seller_sku']))  # noqa: E501
        if 'marketplace_id' in params:
            query_params.append(('marketplaceId', params['marketplace_id']))  # noqa: E501
        if 'seller_fulfillment_order_id' in params:
            query_params.append(('sellerFulfillmentOrderId', params['seller_fulfillment_order_id']))  # noqa: E501
        if 'language' in params:
            query_params.append(('language', params['language']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'payload'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/fba/outbound/2020-07-01/returnReasonCodes', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ListReturnReasonCodesResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats, api_models_module=self.api_models_module)

    def submit_fulfillment_order_status_update(self, seller_fulfillment_order_id, body, **kwargs):  # noqa: E501
        """submit_fulfillment_order_status_update  # noqa: E501

        Requests that Amazon update the status of an order in the sandbox testing environment. This is a sandbox-only operation and must be directed to a sandbox endpoint. Refer to [Fulfillment Outbound Dynamic Sandbox Guide](https://developer-docs.amazon.com/sp-api/docs/fulfillment-outbound-dynamic-sandbox-guide) and [Selling Partner API sandbox](https://developer-docs.amazon.com/sp-api/docs/the-selling-partner-api-sandbox) for more information.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.submit_fulfillment_order_status_update(seller_fulfillment_order_id, body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str seller_fulfillment_order_id: The identifier assigned to the item by the seller when the fulfillment order was created. (required)
        :param SubmitFulfillmentOrderStatusUpdateRequest body: The identifier assigned to the item by the seller when the fulfillment order was created. (required)
        :return: SubmitFulfillmentOrderStatusUpdateResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.submit_fulfillment_order_status_update_with_http_info(seller_fulfillment_order_id, body, **kwargs)  # noqa: E501
        else:
            (data) = self.submit_fulfillment_order_status_update_with_http_info(seller_fulfillment_order_id, body, **kwargs)  # noqa: E501
            return data

    def submit_fulfillment_order_status_update_with_http_info(self, seller_fulfillment_order_id, body, **kwargs):  # noqa: E501
        """submit_fulfillment_order_status_update  # noqa: E501

        Requests that Amazon update the status of an order in the sandbox testing environment. This is a sandbox-only operation and must be directed to a sandbox endpoint. Refer to [Fulfillment Outbound Dynamic Sandbox Guide](https://developer-docs.amazon.com/sp-api/docs/fulfillment-outbound-dynamic-sandbox-guide) and [Selling Partner API sandbox](https://developer-docs.amazon.com/sp-api/docs/the-selling-partner-api-sandbox) for more information.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.submit_fulfillment_order_status_update_with_http_info(seller_fulfillment_order_id, body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str seller_fulfillment_order_id: The identifier assigned to the item by the seller when the fulfillment order was created. (required)
        :param SubmitFulfillmentOrderStatusUpdateRequest body: The identifier assigned to the item by the seller when the fulfillment order was created. (required)
        :return: SubmitFulfillmentOrderStatusUpdateResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['seller_fulfillment_order_id', 'body']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method submit_fulfillment_order_status_update" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'seller_fulfillment_order_id' is set
        if self.api_client.client_side_validation and ('seller_fulfillment_order_id' not in params or
                                                       params['seller_fulfillment_order_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `seller_fulfillment_order_id` when calling `submit_fulfillment_order_status_update`")  # noqa: E501
        # verify the required parameter 'body' is set
        if self.api_client.client_side_validation and ('body' not in params or
                                                       params['body'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `body` when calling `submit_fulfillment_order_status_update`")  # noqa: E501

        if self.api_client.client_side_validation and ('seller_fulfillment_order_id' in params and
                                                       len(params['seller_fulfillment_order_id']) > 40):
            raise ValueError("Invalid value for parameter `seller_fulfillment_order_id` when calling `submit_fulfillment_order_status_update`, length must be less than or equal to `40`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'seller_fulfillment_order_id' in params:
            path_params['sellerFulfillmentOrderId'] = params['seller_fulfillment_order_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/fba/outbound/2020-07-01/fulfillmentOrders/{sellerFulfillmentOrderId}/status', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SubmitFulfillmentOrderStatusUpdateResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats, api_models_module=self.api_models_module)

    def update_fulfillment_order(self, seller_fulfillment_order_id, body, **kwargs):  # noqa: E501
        """update_fulfillment_order  # noqa: E501

        Updates and/or requests shipment for a fulfillment order with an order hold on it.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 30 |  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 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).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_fulfillment_order(seller_fulfillment_order_id, body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str seller_fulfillment_order_id: The identifier assigned to the item by the seller when the fulfillment order was created. (required)
        :param UpdateFulfillmentOrderRequest body: The request body of the `updateFulfillmentOrder` operation. (required)
        :return: UpdateFulfillmentOrderResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_fulfillment_order_with_http_info(seller_fulfillment_order_id, body, **kwargs)  # noqa: E501
        else:
            (data) = self.update_fulfillment_order_with_http_info(seller_fulfillment_order_id, body, **kwargs)  # noqa: E501
            return data

    def update_fulfillment_order_with_http_info(self, seller_fulfillment_order_id, body, **kwargs):  # noqa: E501
        """update_fulfillment_order  # noqa: E501

        Updates and/or requests shipment for a fulfillment order with an order hold on it.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 30 |  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 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).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_fulfillment_order_with_http_info(seller_fulfillment_order_id, body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str seller_fulfillment_order_id: The identifier assigned to the item by the seller when the fulfillment order was created. (required)
        :param UpdateFulfillmentOrderRequest body: The request body of the `updateFulfillmentOrder` operation. (required)
        :return: UpdateFulfillmentOrderResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['seller_fulfillment_order_id', 'body']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_fulfillment_order" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'seller_fulfillment_order_id' is set
        if self.api_client.client_side_validation and ('seller_fulfillment_order_id' not in params or
                                                       params['seller_fulfillment_order_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `seller_fulfillment_order_id` when calling `update_fulfillment_order`")  # noqa: E501
        # verify the required parameter 'body' is set
        if self.api_client.client_side_validation and ('body' not in params or
                                                       params['body'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `body` when calling `update_fulfillment_order`")  # noqa: E501

        if self.api_client.client_side_validation and ('seller_fulfillment_order_id' in params and
                                                       len(params['seller_fulfillment_order_id']) > 40):
            raise ValueError("Invalid value for parameter `seller_fulfillment_order_id` when calling `update_fulfillment_order`, length must be less than or equal to `40`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'seller_fulfillment_order_id' in params:
            path_params['sellerFulfillmentOrderId'] = params['seller_fulfillment_order_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/fba/outbound/2020-07-01/fulfillmentOrders/{sellerFulfillmentOrderId}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='UpdateFulfillmentOrderResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats, api_models_module=self.api_models_module)
