ordercloud-python 2026.4.1__py3-none-any.whl

ordercloud/resources/me.py

@@ -0,0 +1,1882 @@
+# GENERATED by tools/codegen — DO NOT EDIT
+# Source: ordercloud-openapi-v3.json
+"""OrderCloud Me API resource."""
+
+from __future__ import annotations
+from typing import Any, Optional, Union
+
+from ..models.auth_models import AccessTokenBasic, TokenPasswordReset
+from ..models.buyer import BuyerAddress, BuyerCreditCard, BuyerProduct, BuyerSupplier, ProductSeller
+from ..models.catalog import Catalog
+from ..models.category import Category
+from ..models.cost_center import CostCenter
+from ..models.inventory_record import InventoryRecord
+from ..models.line_item import BundleItems, LineItem
+from ..models.misc import GroupOrderInvitation, SearchType
+from ..models.order import Order
+from ..models.product import Variant
+from ..models.product_collection import (
+    ProductCollection,
+    ProductCollectionBuyerProduct,
+    ProductCollectionEntry,
+    ProductCollectionInvitation,
+)
+from ..models.promotion import Promotion
+from ..models.shipment import Shipment, ShipmentItem
+from ..models.spec import Spec
+from ..models.spending_account import SpendingAccount
+from ..models.subscription import Subscription
+from ..models.user import MeUser
+from ..models.user_group import UserGroup
+from ..models.shared import ListPage, MetaWithFacets
+from .base import BaseResource
+
+__all__ = ["MeResource"]
+
+
+class MeResource(BaseResource):
+    """Operations on OrderCloud Me."""
+
+    async def get(
+        self,
+    ) -> MeUser:
+        """Get the currently authenticated user
+
+        Returns:
+            The MeUser object.
+        """
+        resp = await self._http.get("/me")
+        return MeUser(**resp.json())
+
+    async def save(
+        self,
+        me_user: Union[MeUser, dict[str, Any]],
+    ) -> MeUser:
+        """Update the currently authenticated user
+
+        Args:
+            me_user: A ``MeUser`` model or dict. Required fields: Username, FirstName, LastName, Email, Active.
+
+        Returns:
+            The MeUser object.
+        """
+        resp = await self._http.put(
+            "/me",
+            json=self._serialize(me_user),
+        )
+        return MeUser(**resp.json())
+
+    async def patch(
+        self,
+        partial: dict[str, Any],
+    ) -> MeUser:
+        """Patch the currently authenticated user
+
+        Args:
+            partial: A dict of fields to update.
+
+        Returns:
+            The MeUser object.
+        """
+        resp = await self._http.patch("/me", json=partial)
+        return MeUser(**resp.json())
+
+    async def list_addresses(
+        self,
+        *,
+        search: Optional[str] = None,
+        search_on: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+    ) -> ListPage[BuyerAddress]:
+        """List addresses visible to this user
+
+        Args:
+            search: Word or phrase to search for.
+            search_on: Comma-delimited list of fields to search on.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+
+        Returns:
+            A paginated list of BuyerAddress objects.
+        """
+        params = self._build_list_params(
+            search=search,
+            search_on=search_on,
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        resp = await self._http.get("/me/addresses", **params)
+        return self._parse_list(resp.json(), BuyerAddress)
+
+    async def create_address(
+        self,
+        buyer_address: Union[BuyerAddress, dict[str, Any]],
+    ) -> BuyerAddress:
+        """Create an address
+
+        Args:
+            buyer_address: A ``BuyerAddress`` model or dict. Required fields: Street1, City, Country.
+
+        Returns:
+            The BuyerAddress object.
+        """
+        resp = await self._http.post("/me/addresses", json=self._serialize(buyer_address))
+        return BuyerAddress(**resp.json())
+
+    async def get_address(
+        self,
+        address_id: str,
+    ) -> BuyerAddress:
+        """Retrieve an address
+
+        Args:
+            address_id: ID of the address.
+
+        Returns:
+            The BuyerAddress object.
+        """
+        resp = await self._http.get(f"/me/addresses/{address_id}")
+        return BuyerAddress(**resp.json())
+
+    async def save_address(
+        self,
+        address_id: str,
+        buyer_address: Union[BuyerAddress, dict[str, Any]],
+    ) -> BuyerAddress:
+        """Update an address
+
+        Args:
+            address_id: ID of the address.
+            buyer_address: A ``BuyerAddress`` model or dict. Required fields: Street1, City, Country.
+
+        Returns:
+            The BuyerAddress object.
+        """
+        resp = await self._http.put(
+            f"/me/addresses/{address_id}",
+            json=self._serialize(buyer_address),
+        )
+        return BuyerAddress(**resp.json())
+
+    async def delete_address(
+        self,
+        address_id: str,
+    ) -> None:
+        """Delete an address
+
+        Args:
+            address_id: ID of the address.
+        """
+        await self._http.delete(f"/me/addresses/{address_id}")
+
+    async def patch_address(
+        self,
+        address_id: str,
+        partial: dict[str, Any],
+    ) -> None:
+        """Partially update an address
+
+        Args:
+            address_id: ID of the address.
+            partial: A dict of fields to update.
+        """
+        await self._http.patch(f"/me/addresses/{address_id}", json=partial)
+
+    async def list_catalogs(
+        self,
+        *,
+        search: Optional[str] = None,
+        search_on: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+        seller_id: Optional[str] = None,
+    ) -> ListPage[Catalog]:
+        """List catalogs visible to this user
+
+        Args:
+            search: Word or phrase to search for.
+            search_on: Comma-delimited list of fields to search on.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+            seller_id: ID of the seller.
+
+        Returns:
+            A paginated list of Catalog objects.
+        """
+        params = self._build_list_params(
+            search=search,
+            search_on=search_on,
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        if seller_id is not None:
+            params["sellerID"] = seller_id
+        resp = await self._http.get("/me/catalogs", **params)
+        return self._parse_list(resp.json(), Catalog)
+
+    async def get_catalog(
+        self,
+        catalog_id: str,
+    ) -> Catalog:
+        """Retrieve a catalog
+
+        Args:
+            catalog_id: ID of the catalog.
+
+        Returns:
+            The Catalog object.
+        """
+        resp = await self._http.get(f"/me/catalogs/{catalog_id}")
+        return Catalog(**resp.json())
+
+    async def list_categories(
+        self,
+        *,
+        depth: Optional[str] = None,
+        catalog_id: Optional[str] = None,
+        product_id: Optional[str] = None,
+        search: Optional[str] = None,
+        search_on: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+    ) -> ListPage[Category]:
+        """List categories visible to this user
+
+        Args:
+            depth: Indicates how deep down the hierarchy to return results. Valid values are a number of 1 or greater, or 'all'. Relative to ParentID if specified. Default is 1.
+            catalog_id: The user’s default CatalogID will be used to return categories if you do not pass another CatalogID explicitly. Listing categories across multiple catalogs is not supported.
+            product_id: ID of the product.
+            search: Word or phrase to search for.
+            search_on: Comma-delimited list of fields to search on.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+
+        Returns:
+            A paginated list of Category objects.
+        """
+        params = self._build_list_params(
+            depth=depth,
+            search=search,
+            search_on=search_on,
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        if catalog_id is not None:
+            params["catalogID"] = catalog_id
+        if product_id is not None:
+            params["productID"] = product_id
+        resp = await self._http.get("/me/categories", **params)
+        return self._parse_list(resp.json(), Category)
+
+    async def get_category(
+        self,
+        category_id: str,
+        *,
+        catalog_id: Optional[str],
+    ) -> Category:
+        """Retrieve a category
+
+        Args:
+            category_id: ID of the category.
+            catalog_id: ID of the catalog.
+
+        Returns:
+            The Category object.
+        """
+        _params: dict[str, Any] = {}
+        if catalog_id is not None:
+            _params["catalogID"] = catalog_id
+        resp = await self._http.get(f"/me/categories/{category_id}", **_params)
+        return Category(**resp.json())
+
+    async def list_cost_centers(
+        self,
+        *,
+        search: Optional[str] = None,
+        search_on: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+    ) -> ListPage[CostCenter]:
+        """List cost centers visible to this user
+
+        Args:
+            search: Word or phrase to search for.
+            search_on: Comma-delimited list of fields to search on.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+
+        Returns:
+            A paginated list of CostCenter objects.
+        """
+        params = self._build_list_params(
+            search=search,
+            search_on=search_on,
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        resp = await self._http.get("/me/costcenters", **params)
+        return self._parse_list(resp.json(), CostCenter)
+
+    async def list_credit_cards(
+        self,
+        *,
+        search: Optional[str] = None,
+        search_on: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+    ) -> ListPage[BuyerCreditCard]:
+        """List credit cards visible to this user
+
+        Args:
+            search: Word or phrase to search for.
+            search_on: Comma-delimited list of fields to search on.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+
+        Returns:
+            A paginated list of BuyerCreditCard objects.
+        """
+        params = self._build_list_params(
+            search=search,
+            search_on=search_on,
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        resp = await self._http.get("/me/creditcards", **params)
+        return self._parse_list(resp.json(), BuyerCreditCard)
+
+    async def create_credit_card(
+        self,
+        buyer_credit_card: Union[BuyerCreditCard, dict[str, Any]],
+    ) -> BuyerCreditCard:
+        """Create a credit card
+
+        Args:
+            buyer_credit_card: A ``BuyerCreditCard`` model or dict.
+
+        Returns:
+            The BuyerCreditCard object.
+        """
+        resp = await self._http.post("/me/creditcards", json=self._serialize(buyer_credit_card))
+        return BuyerCreditCard(**resp.json())
+
+    async def get_credit_card(
+        self,
+        creditcard_id: str,
+    ) -> BuyerCreditCard:
+        """Retrieve a credit card
+
+        Args:
+            creditcard_id: ID of the creditcard.
+
+        Returns:
+            The BuyerCreditCard object.
+        """
+        resp = await self._http.get(f"/me/creditcards/{creditcard_id}")
+        return BuyerCreditCard(**resp.json())
+
+    async def save_credit_card(
+        self,
+        creditcard_id: str,
+        buyer_credit_card: Union[BuyerCreditCard, dict[str, Any]],
+    ) -> BuyerCreditCard:
+        """Update a credit card
+
+        Args:
+            creditcard_id: ID of the creditcard.
+            buyer_credit_card: A ``BuyerCreditCard`` model or dict.
+
+        Returns:
+            The BuyerCreditCard object.
+        """
+        resp = await self._http.put(
+            f"/me/creditcards/{creditcard_id}",
+            json=self._serialize(buyer_credit_card),
+        )
+        return BuyerCreditCard(**resp.json())
+
+    async def delete_credit_card(
+        self,
+        creditcard_id: str,
+    ) -> None:
+        """Delete a credit card
+
+        Args:
+            creditcard_id: ID of the creditcard.
+        """
+        await self._http.delete(f"/me/creditcards/{creditcard_id}")
+
+    async def patch_credit_card(
+        self,
+        creditcard_id: str,
+        partial: dict[str, Any],
+    ) -> None:
+        """Partially update a credit card
+
+        Args:
+            creditcard_id: ID of the creditcard.
+            partial: A dict of fields to update.
+        """
+        await self._http.patch(f"/me/creditcards/{creditcard_id}", json=partial)
+
+    async def list_group_order_invitations(
+        self,
+        *,
+        search: Optional[str] = None,
+        search_on: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+    ) -> ListPage[GroupOrderInvitation]:
+        """List group order invitations visible to this user
+
+        Args:
+            search: Word or phrase to search for.
+            search_on: Comma-delimited list of fields to search on.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+
+        Returns:
+            A paginated list of GroupOrderInvitation objects.
+        """
+        params = self._build_list_params(
+            search=search,
+            search_on=search_on,
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        resp = await self._http.get("/me/orderinvitations", **params)
+        return self._parse_list(resp.json(), GroupOrderInvitation)
+
+    async def create_group_order_invitation(
+        self,
+        group_order_invitation: Union[GroupOrderInvitation, dict[str, Any]],
+    ) -> GroupOrderInvitation:
+        """Create a group order invitation
+
+        Args:
+            group_order_invitation: A ``GroupOrderInvitation`` model or dict. Required fields: ExpirationDate, OrderID.
+
+        Returns:
+            The GroupOrderInvitation object.
+        """
+        resp = await self._http.post(
+            "/me/orderinvitations", json=self._serialize(group_order_invitation)
+        )
+        return GroupOrderInvitation(**resp.json())
+
+    async def get_group_order_invitation(
+        self,
+        invitation_id: str,
+    ) -> GroupOrderInvitation:
+        """Retrieve a group order invitation
+
+        Args:
+            invitation_id: ID of the invitation.
+
+        Returns:
+            The GroupOrderInvitation object.
+        """
+        resp = await self._http.get(f"/me/orderinvitations/{invitation_id}")
+        return GroupOrderInvitation(**resp.json())
+
+    async def delete_group_order_invitation(
+        self,
+        invitation_id: str,
+    ) -> None:
+        """Delete a group order invitation
+
+        Args:
+            invitation_id: ID of the invitation.
+        """
+        await self._http.delete(f"/me/orderinvitations/{invitation_id}")
+
+    async def patch_group_order_invitation(
+        self,
+        invitation_id: str,
+        partial: dict[str, Any],
+    ) -> GroupOrderInvitation:
+        """Partially update a group order invitation
+
+        Args:
+            invitation_id: ID of the invitation.
+            partial: A dict of fields to update.
+
+        Returns:
+            The GroupOrderInvitation object.
+        """
+        resp = await self._http.patch(f"/me/orderinvitations/{invitation_id}", json=partial)
+        return GroupOrderInvitation(**resp.json())
+
+    async def list_orders(
+        self,
+        *,
+        from_: Optional[str] = None,
+        to: Optional[str] = None,
+        search: Optional[str] = None,
+        search_on: Optional[str] = None,
+        search_type: Optional[SearchType] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+    ) -> ListPage[Order]:
+        """List orders visible to this user
+
+        Args:
+            from_: Lower bound of date range that the order was created (if outgoing) or submitted (if incoming).
+            to: Upper bound of date range that the order was created (if outgoing) or submitted (if incoming).
+            search: Word or phrase to search for.
+            search_on: Comma-delimited list of fields to search on.
+            search_type: Type of search to perform.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+
+        Returns:
+            A paginated list of Order objects.
+        """
+        params = self._build_list_params(
+            search=search,
+            search_on=search_on,
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        if from_ is not None:
+            params["from"] = from_
+        if to is not None:
+            params["to"] = to
+        if search_type is not None:
+            params["searchType"] = search_type
+        resp = await self._http.get("/me/orders", **params)
+        return self._parse_list(resp.json(), Order)
+
+    async def transfer_anon_user_order(
+        self,
+        *,
+        anon_user_token: Optional[str],
+    ) -> None:
+        """Transfer an anon user order
+
+        Args:
+            anon_user_token: Anon user token of the me.
+        """
+        _params: dict[str, Any] = {}
+        if anon_user_token is not None:
+            _params["anonUserToken"] = anon_user_token
+        await self._http.put("/me/orders", params=_params or None)
+
+    async def list_approvable_orders(
+        self,
+        *,
+        from_: Optional[str] = None,
+        to: Optional[str] = None,
+        search: Optional[str] = None,
+        search_on: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+    ) -> ListPage[Order]:
+        """Get a list of orders that this user can approve
+
+        Args:
+            from_: Lower bound of date range that the order was created (if outgoing) or submitted (if incoming).
+            to: Upper bound of date range that the order was created (if outgoing) or submitted (if incoming).
+            search: Word or phrase to search for.
+            search_on: Comma-delimited list of fields to search on.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+
+        Returns:
+            A paginated list of Order objects.
+        """
+        params = self._build_list_params(
+            search=search,
+            search_on=search_on,
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        if from_ is not None:
+            params["from"] = from_
+        if to is not None:
+            params["to"] = to
+        resp = await self._http.get("/me/orders/approvable", **params)
+        return self._parse_list(resp.json(), Order)
+
+    async def reset_password_by_token(
+        self,
+        token_password_reset: Union[TokenPasswordReset, dict[str, Any]],
+    ) -> None:
+        """Reset a password by token
+
+        Args:
+            token_password_reset: A ``TokenPasswordReset`` model or dict. Required fields: NewPassword.
+        """
+        await self._http.post("/me/password", json=self._serialize(token_password_reset))
+
+    async def list_product_collections(
+        self,
+        *,
+        search: Optional[str] = None,
+        search_on: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+    ) -> ListPage[ProductCollection]:
+        """List product collections visible to this user
+
+        Args:
+            search: Word or phrase to search for.
+            search_on: Comma-delimited list of fields to search on.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+
+        Returns:
+            A paginated list of ProductCollection objects.
+        """
+        params = self._build_list_params(
+            search=search,
+            search_on=search_on,
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        resp = await self._http.get("/me/productcollections", **params)
+        return self._parse_list(resp.json(), ProductCollection)
+
+    async def create_product_collection(
+        self,
+        product_collection: Union[ProductCollection, dict[str, Any]],
+    ) -> ProductCollection:
+        """Create a product collection
+
+        Args:
+            product_collection: A ``ProductCollection`` model or dict. Required fields: Name.
+
+        Returns:
+            The ProductCollection object.
+        """
+        resp = await self._http.post(
+            "/me/productcollections", json=self._serialize(product_collection)
+        )
+        return ProductCollection(**resp.json())
+
+    async def get_product_collection(
+        self,
+        product_collection_id: str,
+    ) -> ProductCollection:
+        """Retrieve a product collection
+
+        Args:
+            product_collection_id: ID of the product collection.
+
+        Returns:
+            The ProductCollection object.
+        """
+        resp = await self._http.get(f"/me/productcollections/{product_collection_id}")
+        return ProductCollection(**resp.json())
+
+    async def save_product_collection(
+        self,
+        product_collection_id: str,
+        product_collection: Union[ProductCollection, dict[str, Any]],
+    ) -> ProductCollection:
+        """Create or update a product collection
+
+        Args:
+            product_collection_id: ID of the product collection.
+            product_collection: A ``ProductCollection`` model or dict. Required fields: Name.
+
+        Returns:
+            The ProductCollection object.
+        """
+        resp = await self._http.put(
+            f"/me/productcollections/{product_collection_id}",
+            json=self._serialize(product_collection),
+        )
+        return ProductCollection(**resp.json())
+
+    async def delete_product_collection(
+        self,
+        product_collection_id: str,
+    ) -> None:
+        """Delete a product collection
+
+        Args:
+            product_collection_id: ID of the product collection.
+        """
+        await self._http.delete(f"/me/productcollections/{product_collection_id}")
+
+    async def patch_product_collection(
+        self,
+        product_collection_id: str,
+        partial: dict[str, Any],
+    ) -> ProductCollection:
+        """Partially update a product collection
+
+        Args:
+            product_collection_id: ID of the product collection.
+            partial: A dict of fields to update.
+
+        Returns:
+            The ProductCollection object.
+        """
+        resp = await self._http.patch(
+            f"/me/productcollections/{product_collection_id}", json=partial
+        )
+        return ProductCollection(**resp.json())
+
+    async def create_product_collection_entry(
+        self,
+        product_collection_id: str,
+        product_id: str,
+    ) -> None:
+        """Create a product collection entry
+
+        Args:
+            product_collection_id: ID of the product collection.
+            product_id: ID of the product.
+        """
+        await self._http.put(f"/me/productcollections/{product_collection_id}/{product_id}")
+
+    async def delete_product_collection_entry(
+        self,
+        product_collection_id: str,
+        product_id: str,
+    ) -> None:
+        """Delete a product collection entry
+
+        Args:
+            product_collection_id: ID of the product collection.
+            product_id: ID of the product.
+        """
+        await self._http.delete(f"/me/productcollections/{product_collection_id}/{product_id}")
+
+    async def list_product_collection_invitations(
+        self,
+        product_collection_id: str,
+        *,
+        search: Optional[str] = None,
+        search_on: Optional[str] = None,
+        search_type: Optional[SearchType] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+    ) -> ListPage[ProductCollectionInvitation]:
+        """List product collection invitations visible to this user
+
+        Args:
+            product_collection_id: ID of the product collection.
+            search: Word or phrase to search for.
+            search_on: Comma-delimited list of fields to search on.
+            search_type: Type of search to perform.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+
+        Returns:
+            A paginated list of ProductCollectionInvitation objects.
+        """
+        params = self._build_list_params(
+            search=search,
+            search_on=search_on,
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        if search_type is not None:
+            params["searchType"] = search_type
+        resp = await self._http.get(
+            f"/me/productcollections/{product_collection_id}/invitations", **params
+        )
+        return self._parse_list(resp.json(), ProductCollectionInvitation)
+
+    async def create_product_collection_invitation(
+        self,
+        product_collection_id: str,
+        product_collection_invitation: Union[ProductCollectionInvitation, dict[str, Any]],
+    ) -> ProductCollectionInvitation:
+        """Create a product collection invitation
+
+        Args:
+            product_collection_id: ID of the product collection.
+            product_collection_invitation: A ``ProductCollectionInvitation`` model or dict. Required fields: Name.
+
+        Returns:
+            The ProductCollectionInvitation object.
+        """
+        resp = await self._http.post(
+            f"/me/productcollections/{product_collection_id}/invitations",
+            json=self._serialize(product_collection_invitation),
+        )
+        return ProductCollectionInvitation(**resp.json())
+
+    async def get_product_collection_invitation(
+        self,
+        product_collection_id: str,
+        invitation_id: str,
+    ) -> ProductCollectionInvitation:
+        """Retrieve a product collection invitation
+
+        Args:
+            product_collection_id: ID of the product collection.
+            invitation_id: ID of the invitation.
+
+        Returns:
+            The ProductCollectionInvitation object.
+        """
+        resp = await self._http.get(
+            f"/me/productcollections/{product_collection_id}/invitations/{invitation_id}"
+        )
+        return ProductCollectionInvitation(**resp.json())
+
+    async def delete_product_collection_invitation(
+        self,
+        product_collection_id: str,
+        invitation_id: str,
+    ) -> None:
+        """Delete a product collection invitation
+
+        Args:
+            product_collection_id: ID of the product collection.
+            invitation_id: ID of the invitation.
+        """
+        await self._http.delete(
+            f"/me/productcollections/{product_collection_id}/invitations/{invitation_id}"
+        )
+
+    async def patch_product_collection_invitation(
+        self,
+        product_collection_id: str,
+        invitation_id: str,
+        partial: dict[str, Any],
+    ) -> ProductCollectionInvitation:
+        """Partially update a product collection invitation
+
+        Args:
+            product_collection_id: ID of the product collection.
+            invitation_id: ID of the invitation.
+            partial: A dict of fields to update.
+
+        Returns:
+            The ProductCollectionInvitation object.
+        """
+        resp = await self._http.patch(
+            f"/me/productcollections/{product_collection_id}/invitations/{invitation_id}",
+            json=partial,
+        )
+        return ProductCollectionInvitation(**resp.json())
+
+    async def accept_product_collection_invitation(
+        self,
+        product_collection_id: str,
+        invitation_id: str,
+    ) -> None:
+        """Accept a product collection invitation
+
+        Args:
+            product_collection_id: ID of the product collection.
+            invitation_id: ID of the invitation.
+        """
+        await self._http.post(
+            f"/me/productcollections/{product_collection_id}/invitations/accept/{invitation_id}"
+        )
+
+    async def decline_product_collection_invitation(
+        self,
+        product_collection_id: str,
+        invitation_id: str,
+    ) -> None:
+        """Decline a product collection invitation
+
+        Args:
+            product_collection_id: ID of the product collection.
+            invitation_id: ID of the invitation.
+        """
+        await self._http.post(
+            f"/me/productcollections/{product_collection_id}/invitations/decline/{invitation_id}"
+        )
+
+    async def list_product_collection_entries(
+        self,
+        product_collection_id: str,
+        *,
+        search: Optional[str] = None,
+        search_on: Optional[str] = None,
+        search_type: Optional[SearchType] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+    ) -> ListPage[ProductCollectionBuyerProduct]:
+        """List product collection entries visible to this user
+
+        Args:
+            product_collection_id: ID of the product collection.
+            search: Word or phrase to search for.
+            search_on: Comma-delimited list of fields to search on.
+            search_type: Type of search to perform.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+
+        Returns:
+            A paginated list of ProductCollectionBuyerProduct objects.
+        """
+        params = self._build_list_params(
+            search=search,
+            search_on=search_on,
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        if search_type is not None:
+            params["searchType"] = search_type
+        resp = await self._http.get(
+            f"/me/productcollections/{product_collection_id}/products", **params
+        )
+        return self._parse_list(resp.json(), ProductCollectionBuyerProduct, meta_cls=MetaWithFacets)
+
+    async def save_product_collection_entry(
+        self,
+        product_collection_id: str,
+        product_collection_entry: Union[ProductCollectionEntry, dict[str, Any]],
+    ) -> None:
+        """Create or update a product collection entry
+
+        Args:
+            product_collection_id: ID of the product collection.
+            product_collection_entry: A ``ProductCollectionEntry`` model or dict. Required fields: ProductID.
+        """
+        await self._http.post(
+            f"/me/productcollections/{product_collection_id}/products",
+            json=self._serialize(product_collection_entry),
+        )
+
+    async def list_products(
+        self,
+        *,
+        catalog_id: Optional[str] = None,
+        category_id: Optional[str] = None,
+        depth: Optional[str] = None,
+        search: Optional[str] = None,
+        search_on: Optional[str] = None,
+        search_type: Optional[SearchType] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+        seller_id: Optional[str] = None,
+    ) -> ListPage[BuyerProduct]:
+        """List products visible to this user
+
+        Args:
+            catalog_id: ID of the catalog.
+            category_id: ID of the category.
+            depth: Indicates how deep down the category hierarchy to return results. Valid values are a number of 1 or greater, or 'all'. Relative to CategoryID if specified, otherwise top level of the Catalog. Default is 'all'.
+            search: Word or phrase to search for.
+            search_on: Comma-delimited list of fields to search on.
+            search_type: Type of search to perform.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+            seller_id: ID of the seller.
+
+        Returns:
+            A paginated list of BuyerProduct objects.
+        """
+        params = self._build_list_params(
+            depth=depth,
+            search=search,
+            search_on=search_on,
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        if catalog_id is not None:
+            params["catalogID"] = catalog_id
+        if category_id is not None:
+            params["categoryID"] = category_id
+        if search_type is not None:
+            params["searchType"] = search_type
+        if seller_id is not None:
+            params["sellerID"] = seller_id
+        resp = await self._http.get("/me/products", **params)
+        return self._parse_list(resp.json(), BuyerProduct, meta_cls=MetaWithFacets)
+
+    async def get_product(
+        self,
+        product_id: str,
+        *,
+        seller_id: Optional[str] = None,
+    ) -> BuyerProduct:
+        """Retrieve a product
+
+        Args:
+            product_id: ID of the product.
+            seller_id: ID of the seller.
+
+        Returns:
+            The BuyerProduct object.
+        """
+        _params: dict[str, Any] = {}
+        if seller_id is not None:
+            _params["sellerID"] = seller_id
+        resp = await self._http.get(f"/me/products/{product_id}", **_params)
+        return BuyerProduct(**resp.json())
+
+    async def list_product_inventory_records(
+        self,
+        product_id: str,
+        *,
+        search: Optional[str] = None,
+        search_on: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+        include_address: Optional[bool] = None,
+    ) -> ListPage[InventoryRecord]:
+        """List product inventory records visible to this user
+
+        Args:
+            product_id: ID of the product.
+            search: Word or phrase to search for.
+            search_on: Comma-delimited list of fields to search on.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+            include_address: Include address of the inventory record.
+
+        Returns:
+            A paginated list of InventoryRecord objects.
+        """
+        params = self._build_list_params(
+            search=search,
+            search_on=search_on,
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        if include_address is not None:
+            params["includeAddress"] = include_address
+        resp = await self._http.get(f"/me/products/{product_id}/inventoryrecords", **params)
+        return self._parse_list(resp.json(), InventoryRecord)
+
+    async def list_product_sellers(
+        self,
+        product_id: str,
+        *,
+        search: Optional[str] = None,
+        search_on: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+    ) -> ListPage[ProductSeller]:
+        """List product sellers visible to this user
+
+        Args:
+            product_id: ID of the product.
+            search: Word or phrase to search for.
+            search_on: Comma-delimited list of fields to search on.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+
+        Returns:
+            A paginated list of ProductSeller objects.
+        """
+        params = self._build_list_params(
+            search=search,
+            search_on=search_on,
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        resp = await self._http.get(f"/me/products/{product_id}/sellers", **params)
+        return self._parse_list(resp.json(), ProductSeller)
+
+    async def list_specs(
+        self,
+        product_id: str,
+        *,
+        catalog_id: Optional[str] = None,
+        search: Optional[str] = None,
+        search_on: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+    ) -> ListPage[Spec]:
+        """List specs visible to this user
+
+        Args:
+            product_id: ID of the product.
+            catalog_id: ID of the catalog.
+            search: Word or phrase to search for.
+            search_on: Comma-delimited list of fields to search on.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+
+        Returns:
+            A paginated list of Spec objects.
+        """
+        params = self._build_list_params(
+            search=search,
+            search_on=search_on,
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        if catalog_id is not None:
+            params["catalogID"] = catalog_id
+        resp = await self._http.get(f"/me/products/{product_id}/specs", **params)
+        return self._parse_list(resp.json(), Spec)
+
+    async def get_spec(
+        self,
+        product_id: str,
+        spec_id: str,
+        *,
+        catalog_id: Optional[str] = None,
+    ) -> Spec:
+        """Retrieve a spec
+
+        Args:
+            product_id: ID of the product.
+            spec_id: ID of the spec.
+            catalog_id: ID of the catalog.
+
+        Returns:
+            The Spec object.
+        """
+        _params: dict[str, Any] = {}
+        if catalog_id is not None:
+            _params["catalogID"] = catalog_id
+        resp = await self._http.get(f"/me/products/{product_id}/specs/{spec_id}", **_params)
+        return Spec(**resp.json())
+
+    async def list_variants(
+        self,
+        product_id: str,
+        *,
+        search: Optional[str] = None,
+        search_on: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+    ) -> ListPage[Variant]:
+        """List variants visible to this user
+
+        Args:
+            product_id: ID of the product.
+            search: Word or phrase to search for.
+            search_on: Comma-delimited list of fields to search on.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+
+        Returns:
+            A paginated list of Variant objects.
+        """
+        params = self._build_list_params(
+            search=search,
+            search_on=search_on,
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        resp = await self._http.get(f"/me/products/{product_id}/variants", **params)
+        return self._parse_list(resp.json(), Variant)
+
+    async def get_variant(
+        self,
+        product_id: str,
+        variant_id: str,
+    ) -> Variant:
+        """Retrieve a variant
+
+        Args:
+            product_id: ID of the product.
+            variant_id: ID of the variant.
+
+        Returns:
+            The Variant object.
+        """
+        resp = await self._http.get(f"/me/products/{product_id}/variants/{variant_id}")
+        return Variant(**resp.json())
+
+    async def list_variant_inventory_records(
+        self,
+        product_id: str,
+        variant_id: str,
+        *,
+        search: Optional[str] = None,
+        search_on: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+        include_address: Optional[bool] = None,
+    ) -> ListPage[InventoryRecord]:
+        """List variant inventory records visible to this user
+
+        Args:
+            product_id: ID of the product.
+            variant_id: ID of the variant.
+            search: Word or phrase to search for.
+            search_on: Comma-delimited list of fields to search on.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+            include_address: Include address of the inventory record.
+
+        Returns:
+            A paginated list of InventoryRecord objects.
+        """
+        params = self._build_list_params(
+            search=search,
+            search_on=search_on,
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        if include_address is not None:
+            params["includeAddress"] = include_address
+        resp = await self._http.get(
+            f"/me/products/{product_id}/variants/{variant_id}/inventoryrecords", **params
+        )
+        return self._parse_list(resp.json(), InventoryRecord)
+
+    async def list_promotions(
+        self,
+        *,
+        search: Optional[str] = None,
+        search_on: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+    ) -> ListPage[Promotion]:
+        """List promotions visible to this user
+
+        Args:
+            search: Word or phrase to search for.
+            search_on: Comma-delimited list of fields to search on.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+
+        Returns:
+            A paginated list of Promotion objects.
+        """
+        params = self._build_list_params(
+            search=search,
+            search_on=search_on,
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        resp = await self._http.get("/me/promotions", **params)
+        return self._parse_list(resp.json(), Promotion)
+
+    async def get_promotion(
+        self,
+        promotion_id: str,
+    ) -> Promotion:
+        """Retrieve a promotion
+
+        Args:
+            promotion_id: ID of the promotion.
+
+        Returns:
+            The Promotion object.
+        """
+        resp = await self._http.get(f"/me/promotions/{promotion_id}")
+        return Promotion(**resp.json())
+
+    async def register(
+        self,
+        me_user: Union[MeUser, dict[str, Any]],
+        *,
+        anon_user_token: Optional[str],
+    ) -> AccessTokenBasic:
+        """Register a user
+
+        Args:
+            me_user: A ``MeUser`` model or dict. Required fields: Username, FirstName, LastName, Email, Active.
+            anon_user_token: Anon user token of the user.
+
+        Returns:
+            The AccessTokenBasic object.
+        """
+        _params: dict[str, Any] = {}
+        if anon_user_token is not None:
+            _params["anonUserToken"] = anon_user_token
+        resp = await self._http.put(
+            "/me/register",
+            json=self._serialize(me_user),
+            params=_params or None,
+        )
+        return AccessTokenBasic(**resp.json())
+
+    async def list_buyer_sellers(
+        self,
+        *,
+        search: Optional[str] = None,
+        search_on: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+    ) -> ListPage[BuyerSupplier]:
+        """Get a list of sellers this user can purchase from
+
+        Args:
+            search: Word or phrase to search for.
+            search_on: Comma-delimited list of fields to search on.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+
+        Returns:
+            A paginated list of BuyerSupplier objects.
+        """
+        params = self._build_list_params(
+            search=search,
+            search_on=search_on,
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        resp = await self._http.get("/me/sellers", **params)
+        return self._parse_list(resp.json(), BuyerSupplier)
+
+    async def list_shipments(
+        self,
+        *,
+        order_id: Optional[str] = None,
+        search: Optional[str] = None,
+        search_on: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+    ) -> ListPage[Shipment]:
+        """List shipments visible to this user
+
+        Args:
+            order_id: ID of the order.
+            search: Word or phrase to search for.
+            search_on: Comma-delimited list of fields to search on.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+
+        Returns:
+            A paginated list of Shipment objects.
+        """
+        params = self._build_list_params(
+            search=search,
+            search_on=search_on,
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        if order_id is not None:
+            params["orderID"] = order_id
+        resp = await self._http.get("/me/shipments", **params)
+        return self._parse_list(resp.json(), Shipment)
+
+    async def get_shipment(
+        self,
+        shipment_id: str,
+    ) -> Shipment:
+        """Retrieve a shipment
+
+        Args:
+            shipment_id: ID of the shipment.
+
+        Returns:
+            The Shipment object.
+        """
+        resp = await self._http.get(f"/me/shipments/{shipment_id}")
+        return Shipment(**resp.json())
+
+    async def list_shipment_items(
+        self,
+        shipment_id: str,
+        *,
+        order_id: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+    ) -> ListPage[ShipmentItem]:
+        """List shipment items visible to this user
+
+        Args:
+            shipment_id: ID of the shipment.
+            order_id: ID of the order.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+
+        Returns:
+            A paginated list of ShipmentItem objects.
+        """
+        params = self._build_list_params(
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        if order_id is not None:
+            params["orderID"] = order_id
+        resp = await self._http.get(f"/me/shipments/{shipment_id}/items", **params)
+        return self._parse_list(resp.json(), ShipmentItem)
+
+    async def list_spending_accounts(
+        self,
+        *,
+        search: Optional[str] = None,
+        search_on: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+    ) -> ListPage[SpendingAccount]:
+        """List spending accounts visible to this user
+
+        Args:
+            search: Word or phrase to search for.
+            search_on: Comma-delimited list of fields to search on.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+
+        Returns:
+            A paginated list of SpendingAccount objects.
+        """
+        params = self._build_list_params(
+            search=search,
+            search_on=search_on,
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        resp = await self._http.get("/me/spendingAccounts", **params)
+        return self._parse_list(resp.json(), SpendingAccount)
+
+    async def get_spending_account(
+        self,
+        spending_account_id: str,
+    ) -> SpendingAccount:
+        """Retrieve a spending account
+
+        Args:
+            spending_account_id: ID of the spending account.
+
+        Returns:
+            The SpendingAccount object.
+        """
+        resp = await self._http.get(f"/me/spendingaccounts/{spending_account_id}")
+        return SpendingAccount(**resp.json())
+
+    async def list_subscriptions(
+        self,
+        *,
+        search: Optional[str] = None,
+        search_on: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+    ) -> ListPage[Subscription]:
+        """List subscriptions visible to this user
+
+        Args:
+            search: Word or phrase to search for.
+            search_on: Comma-delimited list of fields to search on.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+
+        Returns:
+            A paginated list of Subscription objects.
+        """
+        params = self._build_list_params(
+            search=search,
+            search_on=search_on,
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        resp = await self._http.get("/me/subscriptions", **params)
+        return self._parse_list(resp.json(), Subscription)
+
+    async def create_subscription(
+        self,
+        subscription: Union[Subscription, dict[str, Any]],
+    ) -> Subscription:
+        """Create a subscription
+
+        Args:
+            subscription: A ``Subscription`` model or dict. Required fields: Frequency, Interval, NextOrderDate.
+
+        Returns:
+            The Subscription object.
+        """
+        resp = await self._http.post("/me/subscriptions", json=self._serialize(subscription))
+        return Subscription(**resp.json())
+
+    async def get_subscription(
+        self,
+        subscription_id: str,
+    ) -> Subscription:
+        """Retrieve a subscription
+
+        Args:
+            subscription_id: ID of the subscription.
+
+        Returns:
+            The Subscription object.
+        """
+        resp = await self._http.get(f"/me/subscriptions/{subscription_id}")
+        return Subscription(**resp.json())
+
+    async def save_subscription(
+        self,
+        subscription_id: str,
+        subscription: Union[Subscription, dict[str, Any]],
+    ) -> Subscription:
+        """Create or update a subscription
+
+        Args:
+            subscription_id: ID of the subscription.
+            subscription: A ``Subscription`` model or dict. Required fields: Frequency, Interval, NextOrderDate.
+
+        Returns:
+            The Subscription object.
+        """
+        resp = await self._http.put(
+            f"/me/subscriptions/{subscription_id}",
+            json=self._serialize(subscription),
+        )
+        return Subscription(**resp.json())
+
+    async def delete_subscription(
+        self,
+        subscription_id: str,
+    ) -> None:
+        """Delete a subscription
+
+        Args:
+            subscription_id: ID of the subscription.
+        """
+        await self._http.delete(f"/me/subscriptions/{subscription_id}")
+
+    async def patch_subscription(
+        self,
+        subscription_id: str,
+        partial: dict[str, Any],
+    ) -> Subscription:
+        """Partially update a subscription
+
+        Args:
+            subscription_id: ID of the subscription.
+            partial: A dict of fields to update.
+
+        Returns:
+            The Subscription object.
+        """
+        resp = await self._http.patch(f"/me/subscriptions/{subscription_id}", json=partial)
+        return Subscription(**resp.json())
+
+    async def list_subscription_items(
+        self,
+        subscription_id: str,
+        *,
+        search: Optional[str] = None,
+        search_on: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+    ) -> ListPage[LineItem]:
+        """List subscription items visible to this user
+
+        Args:
+            subscription_id: ID of the subscription.
+            search: Word or phrase to search for.
+            search_on: Comma-delimited list of fields to search on.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+
+        Returns:
+            A paginated list of LineItem objects.
+        """
+        params = self._build_list_params(
+            search=search,
+            search_on=search_on,
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        resp = await self._http.get(f"/me/subscriptions/{subscription_id}/items", **params)
+        return self._parse_list(resp.json(), LineItem)
+
+    async def create_subscription_item(
+        self,
+        subscription_id: str,
+        line_item: Union[LineItem, dict[str, Any]],
+    ) -> LineItem:
+        """Create a subscription item
+
+        Args:
+            subscription_id: ID of the subscription.
+            line_item: A ``LineItem`` model or dict. Required fields: ProductID.
+
+        Returns:
+            The LineItem object.
+        """
+        resp = await self._http.post(
+            f"/me/subscriptions/{subscription_id}/items", json=self._serialize(line_item)
+        )
+        return LineItem(**resp.json())
+
+    async def get_subscription_item(
+        self,
+        subscription_id: str,
+        subscription_item_id: str,
+    ) -> LineItem:
+        """Retrieve a subscription item
+
+        Args:
+            subscription_id: ID of the subscription.
+            subscription_item_id: ID of the subscription item.
+
+        Returns:
+            The LineItem object.
+        """
+        resp = await self._http.get(
+            f"/me/subscriptions/{subscription_id}/items/{subscription_item_id}"
+        )
+        return LineItem(**resp.json())
+
+    async def save_subscription_item(
+        self,
+        subscription_id: str,
+        subscription_item_id: str,
+        line_item: Union[LineItem, dict[str, Any]],
+    ) -> LineItem:
+        """Create or update a subscription item
+
+        Args:
+            subscription_id: ID of the subscription.
+            subscription_item_id: ID of the subscription item.
+            line_item: A ``LineItem`` model or dict. Required fields: ProductID.
+
+        Returns:
+            The LineItem object.
+        """
+        resp = await self._http.put(
+            f"/me/subscriptions/{subscription_id}/items/{subscription_item_id}",
+            json=self._serialize(line_item),
+        )
+        return LineItem(**resp.json())
+
+    async def delete_subscription_item(
+        self,
+        subscription_id: str,
+        subscription_item_id: str,
+    ) -> None:
+        """Delete a subscription item
+
+        Args:
+            subscription_id: ID of the subscription.
+            subscription_item_id: ID of the subscription item.
+        """
+        await self._http.delete(f"/me/subscriptions/{subscription_id}/items/{subscription_item_id}")
+
+    async def patch_subscription_item(
+        self,
+        subscription_id: str,
+        subscription_item_id: str,
+        partial: dict[str, Any],
+    ) -> LineItem:
+        """Partially update a subscription item
+
+        Args:
+            subscription_id: ID of the subscription.
+            subscription_item_id: ID of the subscription item.
+            partial: A dict of fields to update.
+
+        Returns:
+            The LineItem object.
+        """
+        resp = await self._http.patch(
+            f"/me/subscriptions/{subscription_id}/items/{subscription_item_id}", json=partial
+        )
+        return LineItem(**resp.json())
+
+    async def create_subscription_bundle_item(
+        self,
+        subscription_id: str,
+        bundle_id: str,
+        bundle_items: Union[BundleItems, dict[str, Any]],
+    ) -> LineItem:
+        """Create a subscription bundle item
+
+        Args:
+            subscription_id: ID of the subscription.
+            bundle_id: ID of the bundle.
+            bundle_items: A ``BundleItems`` model or dict.
+
+        Returns:
+            The LineItem object.
+        """
+        resp = await self._http.post(
+            f"/me/subscriptions/{subscription_id}/items/bundles/{bundle_id}",
+            json=self._serialize(bundle_items),
+        )
+        return LineItem(**resp.json())
+
+    async def delete_subscription_bundle_item(
+        self,
+        subscription_id: str,
+        bundle_id: str,
+        bundle_item_id: str,
+    ) -> None:
+        """Delete a subscription bundle item
+
+        Args:
+            subscription_id: ID of the subscription.
+            bundle_id: ID of the bundle.
+            bundle_item_id: ID of the bundle item.
+        """
+        await self._http.delete(
+            f"/me/subscriptions/{subscription_id}/items/bundles/{bundle_id}/{bundle_item_id}"
+        )
+
+    async def revoke_tokens(
+        self,
+    ) -> None:
+        """Revoke tokens"""
+        await self._http.delete("/me/tokens")
+
+    async def list_user_groups(
+        self,
+        *,
+        search: Optional[str] = None,
+        search_on: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        filters: Optional[dict[str, Any]] = None,
+    ) -> ListPage[UserGroup]:
+        """List user groups visible to this user
+
+        Args:
+            search: Word or phrase to search for.
+            search_on: Comma-delimited list of fields to search on.
+            sort_by: Comma-delimited list of fields to sort by.
+            page: Page of results to return. When paginating through many items (> page 30), we recommend the "Last ID" method, as outlined in the Advanced Querying documentation.
+            page_size: Number of results to return per page.
+            filters: An object or dictionary representing key/value pairs to apply as filters. Valid keys are top-level properties of the returned model or 'xp.???'
+
+        Returns:
+            A paginated list of UserGroup objects.
+        """
+        params = self._build_list_params(
+            search=search,
+            search_on=search_on,
+            sort_by=sort_by,
+            page=page,
+            page_size=page_size,
+            filters=filters,
+        )
+        resp = await self._http.get("/me/usergroups", **params)
+        return self._parse_list(resp.json(), UserGroup)