vtexpy 0.0.0b9__py3-none-any.whl → 0.0.0b11__py3-none-any.whl

vtex/__init__.py

@@ -1,10 +1,10 @@
 from . import _constants as VTEXConstants  # noqa: N812
 from ._dto import (
     VTEXCartItem,
-    VTEXListResponse,
-    VTEXPaginatedListResponse,
+    VTEXDataResponse,
+    VTEXItemsResponse,
+    VTEXPaginatedItemsResponse,
     VTEXResponse,
-    VTEXScrollListResponse,
 )
 from ._exceptions import VTEXError, VTEXRequestError, VTEXResponseError
 from ._vtex import VTEX
@@ -14,12 +14,12 @@ __all__ = [
     "VTEXCartItem",
     "VTEXConstants",
     "VTEXError",
-    "VTEXListResponse",
-    "VTEXPaginatedListResponse",
+    "VTEXDataResponse",
+    "VTEXItemsResponse",
+    "VTEXPaginatedItemsResponse",
     "VTEXRequestError",
     "VTEXResponse",
     "VTEXResponseError",
-    "VTEXScrollListResponse",
 ]
 
 

vtex/_api/base.py

@@ -1,6 +1,6 @@
 from http import HTTPStatus
 from json import JSONDecodeError
-from logging import WARNING, Logger
+from logging import WARNING
 from typing import Any, Type, Union, cast
 from urllib.parse import urljoin
 
@@ -28,27 +28,24 @@ from tenacity import (
 
 from .._config import Config  # type: ignore[attr-defined]
 from .._constants import APP_KEY_HEADER, APP_TOKEN_HEADER
-from .._dto import VTEXResponse, VTEXResponseType
+from .._dto import VTEXDataResponse, VTEXResponseType
 from .._exceptions import VTEXRequestError, VTEXResponseError
 from .._logging import get_logger, log_before_retry
 from .._types import HTTPMethodType
 from .._utils import redact_headers, to_snake_case, to_snake_case_deep
+from .._vtex import VTEX
 
 
 class BaseAPI:
     """
-    Base client for VTEX API.
+    Base client for a VTEX API.
     """
 
-    def __init__(
-        self,
-        config: Union[Config, None] = None,
-        logger: Union[Logger, None] = None,
-    ) -> None:
-        self._config = config or Config()
-        self._logger = get_logger(
+    def __init__(self, client: VTEX) -> None:
+        self.client = client
+        self.logger = get_logger(
             name=to_snake_case(type(self).__name__),
-            parent=logger,
+            parent=self.client.logger,
         )
 
     def _request(
@@ -66,14 +63,18 @@ class BaseAPI:
         config: Union[Config, None] = None,
         response_class: Union[Type[VTEXResponseType], None] = None,
     ) -> VTEXResponseType:
-        request_config = self._get_config(config=config)
-        url = self._get_url(
-            config=request_config,
-            environment=environment,
-            endpoint=endpoint,
+        request_config = config or self.client.config
+
+        url = urljoin(
+            f"https://{request_config.get_account_name()}.{environment}.com.br",
+            endpoint,
         )
-        headers = self._get_headers(config=request_config, headers=headers)
-        retry_statuses = set(request_config.get_retry_statuses())
+
+        headers = Headers(headers=headers)
+        headers[APP_KEY_HEADER] = request_config.get_app_key()
+        headers[APP_TOKEN_HEADER] = request_config.get_app_token()
+        headers["Content-Type"] = "application/json; charset=utf-8"
+        headers["Accept"] = "application/json"
 
         @retry(
             stop=stop_after_attempt(
@@ -86,7 +87,7 @@ class BaseAPI:
             ),
             retry=retry_if_exception_type(exception_types=HTTPError),
             before_sleep=(
-                log_before_retry(logger=self._logger, log_level=WARNING)
+                log_before_retry(logger=self.logger, log_level=WARNING)
                 if request_config.get_retry_logs()
                 else None
             ),
@@ -110,7 +111,7 @@ class BaseAPI:
                     redact_headers(dict(response.request.headers)),
                 )
                 response.headers = Headers(redact_headers(dict(response.headers)))
-                if response.status_code in retry_statuses:
+                if response.status_code in request_config.get_retry_statuses():
                     response.raise_for_status()
 
                 return response
@@ -129,7 +130,7 @@ class BaseAPI:
                 "headers": headers,
             }
 
-            self._logger.error(str(exception), extra=details, exc_info=True)
+            self.logger.error(str(exception), extra=details, exc_info=True)
 
             raise VTEXRequestError(**details) from None  # type: ignore[arg-type]
 
@@ -137,33 +138,9 @@ class BaseAPI:
 
         return cast(
             VTEXResponseType,
-            (response_class or VTEXResponse).factory(response),
+            (response_class or VTEXDataResponse).factory(response),
         )
 
-    def _get_config(self, config: Union[Config, None]) -> Config:
-        return config or self._config
-
-    def _get_url(self, config: Config, environment: str, endpoint: str) -> str:
-        return urljoin(
-            f"https://{config.get_account_name()}.{environment}.com.br",
-            endpoint,
-        )
-
-    def _get_headers(
-        self,
-        config: Config,
-        headers: Union[HeaderTypes, None] = None,
-    ) -> Headers:
-        request_headers = Headers(headers=headers)
-
-        request_headers[APP_KEY_HEADER] = config.get_app_key()
-        request_headers[APP_TOKEN_HEADER] = config.get_app_token()
-
-        request_headers["Content-Type"] = "application/json; charset=utf-8"
-        request_headers["Accept"] = "application/json"
-
-        return request_headers
-
     def _raise_from_response(self, response: Response, config: Config) -> None:
         if response.is_error and config.get_raise_for_status():
             try:
@@ -182,8 +159,8 @@ class BaseAPI:
             )
 
             if response.is_server_error:
-                self._logger.error(data, extra=error.to_dict())
+                self.logger.error(data, extra=error.to_dict())
             else:
-                self._logger.warning(data, extra=error.to_dict())
+                self.logger.warning(data, extra=error.to_dict())
 
             raise error from None

vtex/_api/catalog.py

@@ -1,6 +1,5 @@
-from typing import Any, Union
+from typing import Any, List, Union
 
-from .. import VTEXPaginatedListResponse
 from .._constants import (
     GET_CATEGORY_TREE_MAX_LEVELS,
     LIST_CATEGORIES_MAX_PAGE_SIZE,
@@ -9,8 +8,9 @@ from .._constants import (
     LIST_SKU_IDS_START_PAGE,
     MIN_PAGE_SIZE,
 )
-from .._dto import VTEXListResponse, VTEXResponse
+from .._dto import VTEXDataResponse, VTEXItemsResponse, VTEXPaginatedItemsResponse
 from .._sentinels import UNDEFINED, UndefinedSentinel
+from .._types import DictType
 from .._utils import exclude_undefined_values
 from .base import BaseAPI
 
@@ -29,7 +29,7 @@ class CatalogAPI(BaseAPI):
         seller_type: Union[int, UndefinedSentinel] = UNDEFINED,
         is_better_scope: Union[bool, UndefinedSentinel] = UNDEFINED,
         **kwargs: Any,
-    ) -> VTEXListResponse:
+    ) -> VTEXItemsResponse[DictType, DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
@@ -39,8 +39,8 @@ class CatalogAPI(BaseAPI):
                 "sellerType": seller_type,
                 "isBetterScope": is_better_scope,
             }),
-            config=self._config.with_overrides(**kwargs),
-            response_class=VTEXListResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            response_class=VTEXItemsResponse[DictType, DictType],
         )
 
     def list_sku_ids(
@@ -48,7 +48,7 @@ class CatalogAPI(BaseAPI):
         page: int = LIST_SKU_IDS_START_PAGE,
         page_size: int = LIST_SKU_IDS_MAX_PAGE_SIZE,
         **kwargs: Any,
-    ) -> VTEXListResponse:
+    ) -> VTEXItemsResponse[List[str], str]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
@@ -60,17 +60,21 @@ class CatalogAPI(BaseAPI):
                     MIN_PAGE_SIZE,
                 ),
             },
-            config=self._config.with_overrides(**kwargs),
-            response_class=VTEXListResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            response_class=VTEXItemsResponse[List[str], str],
         )
 
-    def get_sku_with_context(self, sku_id: int, **kwargs: Any) -> VTEXResponse:
+    def get_sku_with_context(
+        self,
+        sku_id: int,
+        **kwargs: Any,
+    ) -> VTEXDataResponse[DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/catalog_system/pvt/sku/stockkeepingunitbyid/{sku_id}",
-            config=self._config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            response_class=VTEXDataResponse[DictType],
         )
 
     def list_categories(
@@ -78,7 +82,7 @@ class CatalogAPI(BaseAPI):
         page: int = LIST_SKU_IDS_START_PAGE,
         page_size: int = LIST_SKU_IDS_MAX_PAGE_SIZE,
         **kwargs: Any,
-    ) -> VTEXPaginatedListResponse:
+    ) -> VTEXPaginatedItemsResponse[DictType, DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
@@ -90,28 +94,32 @@ class CatalogAPI(BaseAPI):
                     MIN_PAGE_SIZE,
                 ),
             },
-            config=self._config.with_overrides(**kwargs),
-            response_class=VTEXPaginatedListResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            response_class=VTEXPaginatedItemsResponse[DictType, DictType],
         )
 
     def get_category_tree(
         self,
         levels: int = GET_CATEGORY_TREE_MAX_LEVELS,
         **kwargs: Any,
-    ) -> VTEXResponse:
+    ) -> VTEXDataResponse[DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/catalog_system/pub/category/tree/{levels}",
-            config=self._config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            response_class=VTEXDataResponse[DictType],
         )
 
-    def get_category(self, category_id: str, **kwargs: Any) -> VTEXResponse:
+    def get_category(
+        self,
+        category_id: str,
+        **kwargs: Any,
+    ) -> VTEXDataResponse[DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/catalog/pvt/category/{category_id}",
-            config=self._config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            response_class=VTEXDataResponse[DictType],
         )

vtex/_api/checkout.py

@@ -1,7 +1,8 @@
 from typing import Any, List, Union
 
-from .._dto import VTEXCartItem, VTEXResponse
+from .._dto import VTEXCartItem, VTEXDataResponse
 from .._sentinels import UNDEFINED, UndefinedSentinel
+from .._types import DictType
 from .._utils import exclude_undefined_values
 from .base import BaseAPI
 
@@ -14,7 +15,7 @@ class CheckoutAPI(BaseAPI):
 
     ENVIRONMENT = "vtexcommercestable"
 
-    def cart_simulation(
+    def run_cart_simulation(
         self,
         cart: List[VTEXCartItem],
         country: Union[str, UndefinedSentinel] = UNDEFINED,
@@ -24,7 +25,7 @@ class CheckoutAPI(BaseAPI):
         sales_channel: Union[int, UndefinedSentinel] = UNDEFINED,
         individual_shipping_estimates: Union[bool, UndefinedSentinel] = UNDEFINED,
         **kwargs: Any,
-    ) -> VTEXResponse:
+    ) -> VTEXDataResponse[DictType]:
         return self._request(
             method="POST",
             environment=self.ENVIRONMENT,
@@ -40,6 +41,6 @@ class CheckoutAPI(BaseAPI):
                 "postalCode": postal_code,
                 "geoCoordinates": geo_coordinates,
             }),
-            config=self._config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            response_class=VTEXDataResponse[DictType],
         )

vtex/_api/custom.py

@@ -1,4 +1,5 @@
-from typing import Any, Type, Union
+from datetime import datetime
+from typing import Any, List, Type, Union
 
 from httpx._types import (
     CookieTypes,
@@ -11,6 +12,7 @@ from httpx._types import (
 
 from .._dto import VTEXResponseType
 from .._types import HTTPMethodType
+from .._utils import to_datetime
 from .base import BaseAPI
 
 
@@ -46,6 +48,35 @@ class CustomAPI(BaseAPI):
             data=data,
             content=content,
             files=files,
-            config=self._config.with_overrides(**kwargs),
+            config=self.client.config.with_overrides(**kwargs),
             response_class=response_class,
         )
+
+    def get_account_name(self) -> str:
+        return self.client.license_manager.get_account().data["account_name"]
+
+    def get_account_creation_date(self) -> datetime:
+        return to_datetime(
+            self.client.license_manager.get_account().data["creation_date"],
+        )
+
+    def get_account_site_names(self) -> datetime:
+        return to_datetime(
+            self.client.license_manager.get_account().data["creation_date"],
+        )
+
+    def get_main_seller(self) -> str:
+        return "1"
+
+    def get_market_place_sellers(self) -> List[str]:
+        return [
+            seller["seller_id"]
+            for seller in self.client.catalog.list_sellers(seller_type=1).items
+            if seller["seller_id"] != "1"
+        ]
+
+    def get_franchise_sellers(self) -> List[str]:
+        return [
+            seller["seller_id"]
+            for seller in self.client.catalog.list_sellers(seller_type=2).items
+        ]

vtex/_api/license_manager.py

@@ -1,7 +1,8 @@
 from typing import Any
 
-from .._dto import VTEXResponse
+from .._dto import VTEXDataResponse
 from .base import BaseAPI
+from .types.license_manager import GetAccountData
 
 
 class LicenseManagerAPI(BaseAPI):
@@ -12,11 +13,11 @@ class LicenseManagerAPI(BaseAPI):
 
     ENVIRONMENT = "vtexcommercestable"
 
-    def get_account(self, **kwargs: Any) -> VTEXResponse:
+    def get_account(self, **kwargs: Any) -> VTEXDataResponse[GetAccountData]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint="/api/vlm/account",
-            config=self._config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            response_class=VTEXDataResponse[GetAccountData],
         )

vtex/_api/logistics.py

@@ -9,7 +9,8 @@ from .._constants import (
     LIST_SHIPPING_POLICIES_START_PAGE,
     MIN_PAGE_SIZE,
 )
-from .._dto import VTEXPaginatedListResponse, VTEXResponse
+from .._dto import VTEXDataResponse, VTEXPaginatedItemsResponse
+from .._types import DictType
 from .base import BaseAPI
 
 
@@ -26,7 +27,7 @@ class LogisticsAPI(BaseAPI):
         page: int = LIST_SHIPPING_POLICIES_START_PAGE,
         page_size: int = LIST_SHIPPING_POLICIES_MAX_PAGE_SIZE,
         **kwargs: Any,
-    ) -> VTEXPaginatedListResponse:
+    ) -> VTEXPaginatedItemsResponse[DictType, DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
@@ -38,21 +39,21 @@ class LogisticsAPI(BaseAPI):
                     MIN_PAGE_SIZE,
                 ),
             },
-            config=self._config.with_overrides(**kwargs),
-            response_class=VTEXPaginatedListResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            response_class=VTEXPaginatedItemsResponse[DictType, DictType],
         )
 
     def get_shipping_policy(
         self,
         shipping_policy_id: str,
         **kwargs: Any,
-    ) -> VTEXResponse:
+    ) -> VTEXDataResponse[DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/logistics/pvt/shipping-policies/{shipping_policy_id}",
-            config=self._config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            response_class=VTEXDataResponse[DictType],
         )
 
     def list_carriers(
@@ -60,7 +61,7 @@ class LogisticsAPI(BaseAPI):
         page: int = LIST_CARRIERS_START_PAGE,
         page_size: int = LIST_CARRIERS_MAX_PAGE_SIZE,
         **kwargs: Any,
-    ) -> VTEXPaginatedListResponse:
+    ) -> VTEXPaginatedItemsResponse[DictType, DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
@@ -72,21 +73,21 @@ class LogisticsAPI(BaseAPI):
                     MIN_PAGE_SIZE,
                 ),
             },
-            config=self._config.with_overrides(**kwargs),
-            response_class=VTEXPaginatedListResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            response_class=VTEXPaginatedItemsResponse[DictType, DictType],
         )
 
     def get_carrier(
         self,
         carrier_id: str,
         **kwargs: Any,
-    ) -> VTEXResponse:
+    ) -> VTEXDataResponse[DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/logistics/pvt/configuration/carriers/{carrier_id}",
-            config=self._config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            response_class=VTEXDataResponse[DictType],
         )
 
     def list_docks(
@@ -94,7 +95,7 @@ class LogisticsAPI(BaseAPI):
         page: int = LIST_DOCKS_START_PAGE,
         page_size: int = LIST_DOCKS_MAX_PAGE_SIZE,
         **kwargs: Any,
-    ) -> VTEXPaginatedListResponse:
+    ) -> VTEXPaginatedItemsResponse[DictType, DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
@@ -106,24 +107,28 @@ class LogisticsAPI(BaseAPI):
                     MIN_PAGE_SIZE,
                 ),
             },
-            config=self._config.with_overrides(**kwargs),
-            response_class=VTEXPaginatedListResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            response_class=VTEXPaginatedItemsResponse[DictType, DictType],
         )
 
-    def get_dock(self, dock_id: str, **kwargs: Any) -> VTEXResponse:
+    def get_dock(self, dock_id: str, **kwargs: Any) -> VTEXDataResponse[DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/logistics/pvt/configuration/docks/{dock_id}",
-            config=self._config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            response_class=VTEXDataResponse[DictType],
         )
 
-    def get_sku_inventories(self, sku_id: str, **kwargs: Any) -> VTEXResponse:
+    def get_sku_inventories(
+        self,
+        sku_id: str,
+        **kwargs: Any,
+    ) -> VTEXDataResponse[DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/logistics/pvt/inventory/skus/{sku_id}",
-            config=self._config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            response_class=VTEXDataResponse[DictType],
         )

vtex/_api/master_data.py

@@ -1,13 +1,13 @@
-from typing import Any, Iterable, Union
+from typing import Any, List, Union
 
 from .._constants import (
     MIN_PAGE_SIZE,
     SEARCH_DOCUMENTS_MAX_PAGE_SIZE,
     SEARCH_DOCUMENTS_START_PAGE,
 )
-from .._dto import VTEXPaginatedListResponse
+from .._dto import VTEXPaginatedItemsResponse
 from .._sentinels import UNDEFINED, UndefinedSentinel
-from .._types import IterableType, OrderingDirectionType
+from .._types import DictType, OrderingDirectionType
 from .._utils import exclude_undefined_values
 from .base import BaseAPI
 
@@ -20,17 +20,17 @@ class MasterDataAPI(BaseAPI):
 
     ENVIRONMENT = "vtexcommercestable"
 
-    def search_documents(
+    def list_documents(
         self,
         entity_name: str,
         where: Union[str, UndefinedSentinel] = UNDEFINED,
-        fields: Union[IterableType[str], str, UndefinedSentinel] = UNDEFINED,
+        fields: Union[List[str], str, UndefinedSentinel] = UNDEFINED,
         order_by_field: str = "id",
         order_by_direction: OrderingDirectionType = "DESC",
         page: int = SEARCH_DOCUMENTS_START_PAGE,
         page_size: int = SEARCH_DOCUMENTS_MAX_PAGE_SIZE,
         **kwargs: Any,
-    ) -> VTEXPaginatedListResponse:
+    ) -> VTEXPaginatedItemsResponse[DictType, DictType]:
         params = {
             "_where": where,
             "_sort": f"{order_by_field} {order_by_direction.upper()}",
@@ -38,7 +38,7 @@ class MasterDataAPI(BaseAPI):
 
         if fields is UNDEFINED:
             params["_fields"] = "all"
-        elif not isinstance(fields, str) and isinstance(fields, Iterable):
+        elif not isinstance(fields, str) and isinstance(fields, list):
             params["_fields"] = ",".join(fields)
         else:
             params["_fields"] = fields
@@ -57,6 +57,6 @@ class MasterDataAPI(BaseAPI):
             headers={
                 "REST-Range": f"resources={(page - 1) * page_size}-{page * page_size}",
             },
-            config=self._config.with_overrides(**kwargs),
-            response_class=VTEXPaginatedListResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            response_class=VTEXPaginatedItemsResponse[DictType, DictType],
         )

vtex/_api/orders.py

@@ -1,5 +1,5 @@
 from datetime import datetime, timedelta, timezone
-from typing import Any, Dict, Union
+from typing import Any, Dict, List, Union
 
 from .._constants import (
     LIST_FEED_ORDERS_MAX_PAGE_SIZE,
@@ -8,9 +8,9 @@ from .._constants import (
     LIST_ORDERS_START_PAGE,
     MIN_PAGE_SIZE,
 )
-from .._dto import VTEXListResponse, VTEXPaginatedListResponse, VTEXResponse
+from .._dto import VTEXDataResponse, VTEXItemsResponse, VTEXPaginatedItemsResponse
 from .._sentinels import UNDEFINED, UndefinedSentinel
-from .._types import IterableType, OrderingDirectionType
+from .._types import DictType, OrderingDirectionType
 from .._utils import now, three_years_ago
 from .base import BaseAPI
 
@@ -35,7 +35,7 @@ class OrdersAPI(BaseAPI):
         page: int = LIST_ORDERS_START_PAGE,
         page_size: int = LIST_ORDERS_MAX_PAGE_SIZE,
         **kwargs: Any,
-    ) -> VTEXPaginatedListResponse:
+    ) -> VTEXPaginatedItemsResponse[DictType, DictType]:
         if page > LIST_ORDERS_MAX_PAGE:
             raise ValueError("List Orders endpoint can only return up to page 30")
 
@@ -83,8 +83,8 @@ class OrdersAPI(BaseAPI):
             environment=self.ENVIRONMENT,
             endpoint="/api/oms/pvt/orders/",
             params=params,
-            config=self._config.with_overrides(**kwargs),
-            response_class=VTEXPaginatedListResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            response_class=VTEXPaginatedItemsResponse[DictType, DictType],
         )
 
         pagination = response.pagination
@@ -93,20 +93,20 @@ class OrdersAPI(BaseAPI):
 
         return response
 
-    def get_order(self, order_id: str, **kwargs: Any) -> VTEXResponse:
+    def get_order(self, order_id: str, **kwargs: Any) -> VTEXDataResponse[DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/oms/pvt/orders/{order_id}",
-            config=self._config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            response_class=VTEXDataResponse[DictType],
         )
 
     def list_feed_orders(
         self,
         page_size: int = LIST_FEED_ORDERS_MAX_PAGE_SIZE,
         **kwargs: Any,
-    ) -> VTEXListResponse:
+    ) -> VTEXItemsResponse[DictType, DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
@@ -117,15 +117,15 @@ class OrdersAPI(BaseAPI):
                     MIN_PAGE_SIZE,
                 ),
             },
-            config=self._config.with_overrides(**kwargs),
-            response_class=VTEXListResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            response_class=VTEXItemsResponse[DictType, DictType],
         )
 
     def commit_feed_orders(
         self,
-        handles: IterableType[str],
+        handles: List[str],
         **kwargs: Any,
-    ) -> VTEXResponse:
+    ) -> VTEXDataResponse[DictType]:
         if not handles:
             raise ValueError(
                 "At least one handle must be provided to commit to the feed"
@@ -141,6 +141,6 @@ class OrdersAPI(BaseAPI):
             environment=self.ENVIRONMENT,
             endpoint="/api/orders/feed/",
             json={"handles": handles},
-            config=self._config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            response_class=VTEXDataResponse[DictType],
         )