checkout-intents 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

checkout_intents/__init__.py

@@ -29,6 +29,7 @@ from ._exceptions import (
     RateLimitError,
     APITimeoutError,
     BadRequestError,
+    PollTimeoutError,
     APIConnectionError,
     AuthenticationError,
     InternalServerError,
@@ -66,6 +67,7 @@ __all__ = [
     "UnprocessableEntityError",
     "RateLimitError",
     "InternalServerError",
+    "PollTimeoutError",
     "Timeout",
     "RequestOptions",
     "Client",

checkout_intents/_client.py

@@ -48,6 +48,23 @@ ENVIRONMENTS: Dict[str, str] = {
 }
 
 
+def _extract_environment_from_api_key(api_key: str) -> Literal["staging", "production"] | None:
+    """
+    Extracts the environment from a Rye API key.
+    API keys follow the format: RYE/{environment}-{key}
+
+    Args:
+        api_key: The API key to parse
+
+    Returns:
+        The extracted environment ('staging' or 'production'), or None if the format doesn't match
+    """
+    import re
+
+    match = re.match(r"^RYE/(staging|production)-", api_key)
+    return match.group(1) if match else None  # type: ignore[return-value]
+
+
 class CheckoutIntents(SyncAPIClient):
     checkout_intents: checkout_intents.CheckoutIntentsResource
     brands: brands.BrandsResource
@@ -95,7 +112,26 @@ class CheckoutIntents(SyncAPIClient):
             )
         self.api_key = api_key
 
-        self._environment = environment
+        # Auto-infer environment from API key
+        inferred_environment = _extract_environment_from_api_key(api_key)
+
+        # Validate environment option matches API key (if both provided)
+        if is_given(environment) and inferred_environment and environment != inferred_environment:
+            raise CheckoutIntentsError(
+                f"Environment mismatch: API key is for '{inferred_environment}' environment but 'environment' option is set to '{environment}'. Please use an API key that matches your desired environment or omit the 'environment' option to auto-detect from the API key (only auto-detectable with the RYE/{{environment}}-abcdef api key format)."
+            )
+
+        # Use provided environment, or infer from API key, or default to staging
+        resolved_environment: Literal["staging", "production"]
+        if is_given(environment):
+            resolved_environment = cast(Literal["staging", "production"], environment)
+            self._environment = cast(Literal["staging", "production"], environment)
+        elif inferred_environment:
+            resolved_environment = inferred_environment
+            self._environment = inferred_environment
+        else:
+            resolved_environment = "staging"
+            self._environment = "staging"
 
         base_url_env = os.environ.get("CHECKOUT_INTENTS_BASE_URL")
         if is_given(base_url) and base_url is not None:
@@ -108,18 +144,16 @@ class CheckoutIntents(SyncAPIClient):
                 )
 
             try:
-                base_url = ENVIRONMENTS[environment]
+                base_url = ENVIRONMENTS[resolved_environment]
             except KeyError as exc:
-                raise ValueError(f"Unknown environment: {environment}") from exc
+                raise ValueError(f"Unknown environment: {resolved_environment}") from exc
         elif base_url_env is not None:
             base_url = base_url_env
         else:
-            self._environment = environment = "staging"
-
             try:
-                base_url = ENVIRONMENTS[environment]
+                base_url = ENVIRONMENTS[resolved_environment]
             except KeyError as exc:
-                raise ValueError(f"Unknown environment: {environment}") from exc
+                raise ValueError(f"Unknown environment: {resolved_environment}") from exc
 
         super().__init__(
             version=__version__,
@@ -291,7 +325,26 @@ class AsyncCheckoutIntents(AsyncAPIClient):
             )
         self.api_key = api_key
 
-        self._environment = environment
+        # Auto-infer environment from API key
+        inferred_environment = _extract_environment_from_api_key(api_key)
+
+        # Validate environment option matches API key (if both provided)
+        if is_given(environment) and inferred_environment and environment != inferred_environment:
+            raise CheckoutIntentsError(
+                f"Environment mismatch: API key is for '{inferred_environment}' environment but 'environment' option is set to '{environment}'. Please use an API key that matches your desired environment or omit the 'environment' option to auto-detect from the API key (only auto-detectable with the RYE/{{environment}}-abcdef api key format)."
+            )
+
+        # Use provided environment, or infer from API key, or default to staging
+        resolved_environment: Literal["staging", "production"]
+        if is_given(environment):
+            resolved_environment = cast(Literal["staging", "production"], environment)
+            self._environment = cast(Literal["staging", "production"], environment)
+        elif inferred_environment:
+            resolved_environment = inferred_environment
+            self._environment = inferred_environment
+        else:
+            resolved_environment = "staging"
+            self._environment = "staging"
 
         base_url_env = os.environ.get("CHECKOUT_INTENTS_BASE_URL")
         if is_given(base_url) and base_url is not None:
@@ -304,18 +357,16 @@ class AsyncCheckoutIntents(AsyncAPIClient):
                 )
 
             try:
-                base_url = ENVIRONMENTS[environment]
+                base_url = ENVIRONMENTS[resolved_environment]
             except KeyError as exc:
-                raise ValueError(f"Unknown environment: {environment}") from exc
+                raise ValueError(f"Unknown environment: {resolved_environment}") from exc
         elif base_url_env is not None:
             base_url = base_url_env
         else:
-            self._environment = environment = "staging"
-
             try:
-                base_url = ENVIRONMENTS[environment]
+                base_url = ENVIRONMENTS[resolved_environment]
             except KeyError as exc:
-                raise ValueError(f"Unknown environment: {environment}") from exc
+                raise ValueError(f"Unknown environment: {resolved_environment}") from exc
 
         super().__init__(
             version=__version__,

checkout_intents/_exceptions.py

@@ -15,6 +15,7 @@ __all__ = [
     "UnprocessableEntityError",
     "RateLimitError",
     "InternalServerError",
+    "PollTimeoutError",
 ]
 
 
@@ -106,3 +107,36 @@ class RateLimitError(APIStatusError):
 
 class InternalServerError(APIStatusError):
     pass
+
+
+class PollTimeoutError(CheckoutIntentsError):
+    """Raised when a polling operation times out before the condition is met."""
+
+    intent_id: str
+    attempts: int
+    poll_interval: float
+    max_attempts: int
+
+    def __init__(
+        self,
+        *,
+        intent_id: str,
+        attempts: int,
+        poll_interval: float,
+        max_attempts: int,
+        message: str | None = None,
+    ) -> None:
+        self.intent_id = intent_id
+        self.attempts = attempts
+        self.poll_interval = poll_interval
+        self.max_attempts = max_attempts
+
+        if message is None:
+            total_time_s = max_attempts * poll_interval
+            message = (
+                f"Polling timeout for checkout intent '{intent_id}': "
+                f"condition not met after {attempts} attempts ({total_time_s}s). "
+                f"Consider increasing max_attempts, polling_interval_ms, or checking the intent state manually."
+            )
+
+        super().__init__(message)

checkout_intents/_models.py

@@ -251,21 +251,22 @@ class BaseModel(pydantic.BaseModel):
         # pydantic version they are currently using
 
         @override
-        def model_dump(
+        def model_dump(  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
             self,
             *,
             mode: Literal["json", "python"] | str = "python",
             include: IncEx | None = None,
             exclude: IncEx | None = None,
+            context: Any | None = None,
             by_alias: bool | None = None,
             exclude_unset: bool = False,
             exclude_defaults: bool = False,
             exclude_none: bool = False,
+            exclude_computed_fields: bool = False,
             round_trip: bool = False,
             warnings: bool | Literal["none", "warn", "error"] = True,
-            context: dict[str, Any] | None = None,
-            serialize_as_any: bool = False,
             fallback: Callable[[Any], Any] | None = None,
+            serialize_as_any: bool = False,
         ) -> dict[str, Any]:
             """Usage docs: https://docs.pydantic.dev/2.4/concepts/serialization/#modelmodel_dump
 
@@ -273,16 +274,24 @@ class BaseModel(pydantic.BaseModel):
 
             Args:
                 mode: The mode in which `to_python` should run.
-                    If mode is 'json', the dictionary will only contain JSON serializable types.
-                    If mode is 'python', the dictionary may contain any Python objects.
-                include: A list of fields to include in the output.
-                exclude: A list of fields to exclude from the output.
+                    If mode is 'json', the output will only contain JSON serializable types.
+                    If mode is 'python', the output may contain non-JSON-serializable Python objects.
+                include: A set of fields to include in the output.
+                exclude: A set of fields to exclude from the output.
+                context: Additional context to pass to the serializer.
                 by_alias: Whether to use the field's alias in the dictionary key if defined.
-                exclude_unset: Whether to exclude fields that are unset or None from the output.
-                exclude_defaults: Whether to exclude fields that are set to their default value from the output.
-                exclude_none: Whether to exclude fields that have a value of `None` from the output.
-                round_trip: Whether to enable serialization and deserialization round-trip support.
-                warnings: Whether to log warnings when invalid fields are encountered.
+                exclude_unset: Whether to exclude fields that have not been explicitly set.
+                exclude_defaults: Whether to exclude fields that are set to their default value.
+                exclude_none: Whether to exclude fields that have a value of `None`.
+                exclude_computed_fields: Whether to exclude computed fields.
+                    While this can be useful for round-tripping, it is usually recommended to use the dedicated
+                    `round_trip` parameter instead.
+                round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+                warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+                    "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
+                fallback: A function to call when an unknown value is encountered. If not provided,
+                    a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
+                serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
 
             Returns:
                 A dictionary representation of the model.
@@ -299,6 +308,8 @@ class BaseModel(pydantic.BaseModel):
                 raise ValueError("serialize_as_any is only supported in Pydantic v2")
             if fallback is not None:
                 raise ValueError("fallback is only supported in Pydantic v2")
+            if exclude_computed_fields != False:
+                raise ValueError("exclude_computed_fields is only supported in Pydantic v2")
             dumped = super().dict(  # pyright: ignore[reportDeprecated]
                 include=include,
                 exclude=exclude,
@@ -311,19 +322,21 @@ class BaseModel(pydantic.BaseModel):
             return cast("dict[str, Any]", json_safe(dumped)) if mode == "json" else dumped
 
         @override
-        def model_dump_json(
+        def model_dump_json(  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
             self,
             *,
             indent: int | None = None,
+            ensure_ascii: bool = False,
             include: IncEx | None = None,
             exclude: IncEx | None = None,
+            context: Any | None = None,
             by_alias: bool | None = None,
             exclude_unset: bool = False,
             exclude_defaults: bool = False,
             exclude_none: bool = False,
+            exclude_computed_fields: bool = False,
             round_trip: bool = False,
             warnings: bool | Literal["none", "warn", "error"] = True,
-            context: dict[str, Any] | None = None,
             fallback: Callable[[Any], Any] | None = None,
             serialize_as_any: bool = False,
         ) -> str:
@@ -355,6 +368,10 @@ class BaseModel(pydantic.BaseModel):
                 raise ValueError("serialize_as_any is only supported in Pydantic v2")
             if fallback is not None:
                 raise ValueError("fallback is only supported in Pydantic v2")
+            if ensure_ascii != False:
+                raise ValueError("ensure_ascii is only supported in Pydantic v2")
+            if exclude_computed_fields != False:
+                raise ValueError("exclude_computed_fields is only supported in Pydantic v2")
             return super().json(  # type: ignore[reportDeprecated]
                 indent=indent,
                 include=include,

checkout_intents/_utils/_compat.py

@@ -34,7 +34,7 @@ def is_typeddict(tp: Type[Any]) -> bool:
 
 
 def is_literal_type(tp: Type[Any]) -> bool:
-    return get_origin(tp) in _LITERAL_TYPES
+    return get_origin(tp) in _LITERAL_TYPES  # type: ignore[comparison-overlap]
 
 
 def parse_date(value: Union[date, StrBytesIntFloat]) -> date:

checkout_intents/_utils/_utils.py

@@ -373,9 +373,9 @@ def get_required_header(headers: HeadersLike, header: str) -> str:
     lower_header = header.lower()
     if is_mapping_t(headers):
         # mypy doesn't understand the type narrowing here
-        for k, v in headers.items():  # type: ignore
-            if k.lower() == lower_header and isinstance(v, str):
-                return v
+        for k, v in headers.items():  # type: ignore[misc, has-type, attr-defined]
+            if k.lower() == lower_header and isinstance(v, str):  # type: ignore[has-type]
+                return v  # type: ignore[has-type]
 
     # to deal with the case where the header looks like Stainless-Event-Id
     intercaps_header = re.sub(r"([^\w])(\w)", lambda pat: pat.group(1) + pat.group(2).upper(), header.capitalize())

checkout_intents/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "checkout_intents"
-__version__ = "0.1.0"  # x-release-please-version
+__version__ = "0.2.0"  # x-release-please-version

checkout_intents/resources/checkout_intents.py

@@ -2,7 +2,9 @@
 
 from __future__ import annotations
 
-from typing import Any, Iterable, cast
+import logging
+from typing import Any, Union, TypeVar, Callable, Iterable, cast
+from typing_extensions import TypeGuard
 
 import httpx
 
@@ -21,14 +23,24 @@ from .._response import (
     async_to_raw_response_wrapper,
     async_to_streamed_response_wrapper,
 )
+from .._exceptions import PollTimeoutError
 from .._base_client import make_request_options
 from ..types.buyer_param import BuyerParam
-from ..types.checkout_intent import CheckoutIntent
+from ..types.checkout_intent import (
+    CheckoutIntent,
+    FailedCheckoutIntent,
+    CompletedCheckoutIntent,
+    AwaitingConfirmationCheckoutIntent,
+)
 from ..types.payment_method_param import PaymentMethodParam
 from ..types.variant_selection_param import VariantSelectionParam
 
 __all__ = ["CheckoutIntentsResource", "AsyncCheckoutIntentsResource"]
 
+T = TypeVar("T", bound=CheckoutIntent)
+
+logger: logging.Logger = logging.getLogger(__name__)
+
 
 class CheckoutIntentsResource(SyncAPIResource):
     @cached_property
@@ -218,6 +230,365 @@ class CheckoutIntentsResource(SyncAPIResource):
             ),
         )
 
+    def _poll_until(
+        self,
+        id: str,
+        condition: Callable[[CheckoutIntent], TypeGuard[T]],
+        *,
+        poll_interval: float = 5.0,
+        max_attempts: int = 120,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> T:
+        """
+        A helper to poll a checkout intent until a specific condition is met.
+
+        Args:
+            id: The checkout intent ID to poll
+            condition: A callable that returns True when the desired state is reached
+            poll_interval: The interval in seconds between polling attempts (default: 5.0)
+            max_attempts: The maximum number of polling attempts before timing out (default: 120)
+            extra_headers: Send extra headers
+            extra_query: Add additional query parameters to the request
+            extra_body: Add additional JSON properties to the request
+            timeout: Override the client-level default timeout for this request, in seconds
+
+        Returns:
+            The checkout intent once the condition is met
+
+        Raises:
+            CheckoutIntentsError: If the maximum number of attempts is reached without the condition being met
+        """
+        if max_attempts < 1:
+            logger.warning(
+                "[Checkout Intents SDK] Invalid max_attempts value: %s. max_attempts must be >= 1. "
+                "Defaulting to 1 to ensure at least one polling attempt.",
+                max_attempts,
+            )
+            max_attempts = 1
+
+        attempts = 0
+
+        # Build headers for polling
+        poll_headers: dict[str, str] = {
+            "X-Stainless-Poll-Helper": "true",
+            "X-Stainless-Custom-Poll-Interval": str(int(poll_interval * 1000)),
+        }
+        if extra_headers:
+            for k, v in extra_headers.items():
+                if not isinstance(v, Omit):
+                    poll_headers[k] = v  # type: ignore[assignment]
+
+        while attempts < max_attempts:
+            # Use with_raw_response to access response headers
+            response = self.with_raw_response.retrieve(
+                id,
+                extra_headers=poll_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+            )
+
+            intent = response.parse()
+
+            # Check if condition is met
+            if condition(intent):
+                return intent
+
+            attempts += 1
+
+            # If we've reached max attempts, throw an error
+            if attempts >= max_attempts:
+                raise PollTimeoutError(
+                    intent_id=id,
+                    attempts=attempts,
+                    poll_interval=poll_interval,
+                    max_attempts=max_attempts,
+                )
+
+            # Check if server suggests a polling interval
+            sleep_interval = poll_interval
+            header_interval = response.headers.get("retry-after-ms")
+            if header_interval:
+                try:
+                    header_interval_ms = int(header_interval)
+                    sleep_interval = header_interval_ms / 1000.0
+                except ValueError:
+                    pass  # Ignore invalid header values
+
+            # Sleep before next poll
+            self._sleep(sleep_interval)
+
+        # This should never be reached due to the throw above, but TypeScript needs it
+        raise PollTimeoutError(
+            intent_id=id,
+            attempts=attempts,
+            poll_interval=poll_interval,
+            max_attempts=max_attempts,
+        )
+
+    def poll_until_completed(
+        self,
+        id: str,
+        *,
+        poll_interval: float = 5.0,
+        max_attempts: int = 120,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Union[CompletedCheckoutIntent, FailedCheckoutIntent]:
+        """
+        A helper to poll a checkout intent until it reaches a completed state
+        (completed or failed).
+
+        Args:
+            id: The checkout intent ID to poll
+            poll_interval: The interval in seconds between polling attempts (default: 5.0)
+            max_attempts: The maximum number of polling attempts before timing out (default: 120)
+            extra_headers: Send extra headers
+            extra_query: Add additional query parameters to the request
+            extra_body: Add additional JSON properties to the request
+            timeout: Override the client-level default timeout for this request, in seconds
+
+        Returns:
+            The checkout intent once it reaches completed or failed state
+
+        Example:
+            ```python
+            checkout_intent = client.checkout_intents.poll_until_completed("id")
+            if checkout_intent.state == "completed":
+                print("Order placed successfully!")
+            elif checkout_intent.state == "failed":
+                print("Order failed:", checkout_intent.failure_reason)
+            ```
+        """
+
+        def is_completed(
+            intent: CheckoutIntent,
+        ) -> TypeGuard[Union[CompletedCheckoutIntent, FailedCheckoutIntent]]:
+            return intent.state in ("completed", "failed")
+
+        return self._poll_until(
+            id,
+            is_completed,
+            poll_interval=poll_interval,
+            max_attempts=max_attempts,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+
+    def poll_until_awaiting_confirmation(
+        self,
+        id: str,
+        *,
+        poll_interval: float = 5.0,
+        max_attempts: int = 120,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Union[AwaitingConfirmationCheckoutIntent, FailedCheckoutIntent]:
+        """
+        A helper to poll a checkout intent until it's ready for confirmation
+        (awaiting_confirmation state) or has failed. This is typically used after
+        creating a checkout intent to wait for the offer to be retrieved from the merchant.
+
+        The intent can reach awaiting_confirmation (success - ready to confirm) or failed
+        (offer retrieval failed). Always check the state after polling.
+
+        Args:
+            id: The checkout intent ID to poll
+            poll_interval: The interval in seconds between polling attempts (default: 5.0)
+            max_attempts: The maximum number of polling attempts before timing out (default: 120)
+            extra_headers: Send extra headers
+            extra_query: Add additional query parameters to the request
+            extra_body: Add additional JSON properties to the request
+            timeout: Override the client-level default timeout for this request, in seconds
+
+        Returns:
+            The checkout intent once it reaches awaiting_confirmation or failed state
+
+        Example:
+            ```python
+            intent = client.checkout_intents.poll_until_awaiting_confirmation("id")
+
+            if intent.state == "awaiting_confirmation":
+                # Review the offer before confirming
+                print("Total:", intent.offer.cost.total)
+            elif intent.state == "failed":
+                # Handle failure (e.g., offer retrieval failed, product out of stock)
+                print("Failed:", intent.failure_reason)
+            ```
+        """
+
+        def is_awaiting_confirmation(
+            intent: CheckoutIntent,
+        ) -> TypeGuard[Union[AwaitingConfirmationCheckoutIntent, FailedCheckoutIntent]]:
+            return intent.state in ("awaiting_confirmation", "failed")
+
+        return self._poll_until(
+            id,
+            is_awaiting_confirmation,
+            poll_interval=poll_interval,
+            max_attempts=max_attempts,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+
+    def create_and_poll(
+        self,
+        *,
+        buyer: BuyerParam,
+        product_url: str,
+        quantity: float,
+        variant_selections: Iterable[VariantSelectionParam] | Omit = omit,
+        poll_interval: float = 5.0,
+        max_attempts: int = 120,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Union[AwaitingConfirmationCheckoutIntent, FailedCheckoutIntent]:
+        """
+        A helper to create a checkout intent and poll until it's ready for confirmation.
+        This follows the Rye documented flow: create → poll until awaiting_confirmation.
+
+        After this method completes, you should review the offer (pricing, shipping, taxes)
+        with the user before calling confirm().
+
+        Args:
+            buyer: Buyer information
+            product_url: URL of the product to purchase
+            quantity: Quantity of the product
+            variant_selections: Product variant selections (optional)
+            poll_interval: The interval in seconds between polling attempts (default: 5.0)
+            max_attempts: The maximum number of polling attempts before timing out (default: 120)
+            extra_headers: Send extra headers
+            extra_query: Add additional query parameters to the request
+            extra_body: Add additional JSON properties to the request
+            timeout: Override the client-level default timeout for this request, in seconds
+
+        Returns:
+            The checkout intent once it reaches awaiting_confirmation or failed state
+
+        Example:
+            ```python
+            # Phase 1: Create and wait for offer
+            intent = client.checkout_intents.create_and_poll(
+                buyer={
+                    "address1": "123 Main St",
+                    "city": "New York",
+                    "country": "United States",
+                    "email": "john.doe@example.com",
+                    "first_name": "John",
+                    "last_name": "Doe",
+                    "phone": "+1234567890",
+                    "postal_code": "10001",
+                    "province": "NY",
+                },
+                product_url="https://example.com/product",
+                quantity=1,
+            )
+
+            # Review the offer with the user
+            print("Total:", intent.offer.cost.total)
+
+            # Phase 2: Confirm with payment
+            completed = client.checkout_intents.confirm_and_poll(
+                intent.id, payment_method={"type": "stripe_token", "stripe_token": "tok_visa"}
+            )
+            ```
+        """
+        intent = self.create(
+            buyer=buyer,
+            product_url=product_url,
+            quantity=quantity,
+            variant_selections=variant_selections,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        return self.poll_until_awaiting_confirmation(
+            intent.id,
+            poll_interval=poll_interval,
+            max_attempts=max_attempts,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+
+    def confirm_and_poll(
+        self,
+        id: str,
+        *,
+        payment_method: PaymentMethodParam,
+        poll_interval: float = 5.0,
+        max_attempts: int = 120,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Union[CompletedCheckoutIntent, FailedCheckoutIntent]:
+        """
+        A helper to confirm a checkout intent and poll until it reaches a completed state
+        (completed or failed).
+
+        Args:
+            id: The checkout intent ID to confirm
+            payment_method: Payment method information
+            poll_interval: The interval in seconds between polling attempts (default: 5.0)
+            max_attempts: The maximum number of polling attempts before timing out (default: 120)
+            extra_headers: Send extra headers
+            extra_query: Add additional query parameters to the request
+            extra_body: Add additional JSON properties to the request
+            timeout: Override the client-level default timeout for this request, in seconds
+
+        Returns:
+            The checkout intent once it reaches completed or failed state
+
+        Example:
+            ```python
+            checkout_intent = client.checkout_intents.confirm_and_poll(
+                "id",
+                payment_method={
+                    "stripe_token": "tok_1RkrWWHGDlstla3f1Fc7ZrhH",
+                    "type": "stripe_token",
+                },
+            )
+
+            if checkout_intent.state == "completed":
+                print("Order placed successfully!")
+            elif checkout_intent.state == "failed":
+                print("Order failed:", checkout_intent.failure_reason)
+            ```
+        """
+        intent = self.confirm(
+            id,
+            payment_method=payment_method,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        return self.poll_until_completed(
+            intent.id,
+            poll_interval=poll_interval,
+            max_attempts=max_attempts,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+
 
 class AsyncCheckoutIntentsResource(AsyncAPIResource):
     @cached_property
@@ -407,6 +778,365 @@ class AsyncCheckoutIntentsResource(AsyncAPIResource):
             ),
         )
 
+    async def _poll_until(
+        self,
+        id: str,
+        condition: Callable[[CheckoutIntent], TypeGuard[T]],
+        *,
+        poll_interval: float = 5.0,
+        max_attempts: int = 120,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> T:
+        """
+        A helper to poll a checkout intent until a specific condition is met.
+
+        Args:
+            id: The checkout intent ID to poll
+            condition: A callable that returns True when the desired state is reached
+            poll_interval: The interval in seconds between polling attempts (default: 5.0)
+            max_attempts: The maximum number of polling attempts before timing out (default: 120)
+            extra_headers: Send extra headers
+            extra_query: Add additional query parameters to the request
+            extra_body: Add additional JSON properties to the request
+            timeout: Override the client-level default timeout for this request, in seconds
+
+        Returns:
+            The checkout intent once the condition is met
+
+        Raises:
+            CheckoutIntentsError: If the maximum number of attempts is reached without the condition being met
+        """
+        if max_attempts < 1:
+            logger.warning(
+                "[Checkout Intents SDK] Invalid max_attempts value: %s. max_attempts must be >= 1. "
+                "Defaulting to 1 to ensure at least one polling attempt.",
+                max_attempts,
+            )
+            max_attempts = 1
+
+        attempts = 0
+
+        # Build headers for polling
+        poll_headers: dict[str, str] = {
+            "X-Stainless-Poll-Helper": "true",
+            "X-Stainless-Custom-Poll-Interval": str(int(poll_interval * 1000)),
+        }
+        if extra_headers:
+            for k, v in extra_headers.items():
+                if not isinstance(v, Omit):
+                    poll_headers[k] = v  # type: ignore[assignment]
+
+        while attempts < max_attempts:
+            # Use with_raw_response to access response headers
+            response = await self.with_raw_response.retrieve(
+                id,
+                extra_headers=poll_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+            )
+
+            intent = await response.parse()
+
+            # Check if condition is met
+            if condition(intent):
+                return intent
+
+            attempts += 1
+
+            # If we've reached max attempts, throw an error
+            if attempts >= max_attempts:
+                raise PollTimeoutError(
+                    intent_id=id,
+                    attempts=attempts,
+                    poll_interval=poll_interval,
+                    max_attempts=max_attempts,
+                )
+
+            # Check if server suggests a polling interval
+            sleep_interval = poll_interval
+            header_interval = response.headers.get("retry-after-ms")
+            if header_interval:
+                try:
+                    header_interval_ms = int(header_interval)
+                    sleep_interval = header_interval_ms / 1000.0
+                except ValueError:
+                    pass  # Ignore invalid header values
+
+            # Sleep before next poll
+            await self._sleep(sleep_interval)
+
+        # This should never be reached due to the throw above, but TypeScript needs it
+        raise PollTimeoutError(
+            intent_id=id,
+            attempts=attempts,
+            poll_interval=poll_interval,
+            max_attempts=max_attempts,
+        )
+
+    async def poll_until_completed(
+        self,
+        id: str,
+        *,
+        poll_interval: float = 5.0,
+        max_attempts: int = 120,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Union[CompletedCheckoutIntent, FailedCheckoutIntent]:
+        """
+        A helper to poll a checkout intent until it reaches a completed state
+        (completed or failed).
+
+        Args:
+            id: The checkout intent ID to poll
+            poll_interval: The interval in seconds between polling attempts (default: 5.0)
+            max_attempts: The maximum number of polling attempts before timing out (default: 120)
+            extra_headers: Send extra headers
+            extra_query: Add additional query parameters to the request
+            extra_body: Add additional JSON properties to the request
+            timeout: Override the client-level default timeout for this request, in seconds
+
+        Returns:
+            The checkout intent once it reaches completed or failed state
+
+        Example:
+            ```python
+            checkout_intent = await client.checkout_intents.poll_until_completed("id")
+            if checkout_intent.state == "completed":
+                print("Order placed successfully!")
+            elif checkout_intent.state == "failed":
+                print("Order failed:", checkout_intent.failure_reason)
+            ```
+        """
+
+        def is_completed(
+            intent: CheckoutIntent,
+        ) -> TypeGuard[Union[CompletedCheckoutIntent, FailedCheckoutIntent]]:
+            return intent.state in ("completed", "failed")
+
+        return await self._poll_until(
+            id,
+            is_completed,
+            poll_interval=poll_interval,
+            max_attempts=max_attempts,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+
+    async def poll_until_awaiting_confirmation(
+        self,
+        id: str,
+        *,
+        poll_interval: float = 5.0,
+        max_attempts: int = 120,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Union[AwaitingConfirmationCheckoutIntent, FailedCheckoutIntent]:
+        """
+        A helper to poll a checkout intent until it's ready for confirmation
+        (awaiting_confirmation state) or has failed. This is typically used after
+        creating a checkout intent to wait for the offer to be retrieved from the merchant.
+
+        The intent can reach awaiting_confirmation (success - ready to confirm) or failed
+        (offer retrieval failed). Always check the state after polling.
+
+        Args:
+            id: The checkout intent ID to poll
+            poll_interval: The interval in seconds between polling attempts (default: 5.0)
+            max_attempts: The maximum number of polling attempts before timing out (default: 120)
+            extra_headers: Send extra headers
+            extra_query: Add additional query parameters to the request
+            extra_body: Add additional JSON properties to the request
+            timeout: Override the client-level default timeout for this request, in seconds
+
+        Returns:
+            The checkout intent once it reaches awaiting_confirmation or failed state
+
+        Example:
+            ```python
+            intent = await client.checkout_intents.poll_until_awaiting_confirmation("id")
+
+            if intent.state == "awaiting_confirmation":
+                # Review the offer before confirming
+                print("Total:", intent.offer.cost.total)
+            elif intent.state == "failed":
+                # Handle failure (e.g., offer retrieval failed, product out of stock)
+                print("Failed:", intent.failure_reason)
+            ```
+        """
+
+        def is_awaiting_confirmation(
+            intent: CheckoutIntent,
+        ) -> TypeGuard[Union[AwaitingConfirmationCheckoutIntent, FailedCheckoutIntent]]:
+            return intent.state in ("awaiting_confirmation", "failed")
+
+        return await self._poll_until(
+            id,
+            is_awaiting_confirmation,
+            poll_interval=poll_interval,
+            max_attempts=max_attempts,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+
+    async def create_and_poll(
+        self,
+        *,
+        buyer: BuyerParam,
+        product_url: str,
+        quantity: float,
+        variant_selections: Iterable[VariantSelectionParam] | Omit = omit,
+        poll_interval: float = 5.0,
+        max_attempts: int = 120,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Union[AwaitingConfirmationCheckoutIntent, FailedCheckoutIntent]:
+        """
+        A helper to create a checkout intent and poll until it's ready for confirmation.
+        This follows the Rye documented flow: create → poll until awaiting_confirmation.
+
+        After this method completes, you should review the offer (pricing, shipping, taxes)
+        with the user before calling confirm().
+
+        Args:
+            buyer: Buyer information
+            product_url: URL of the product to purchase
+            quantity: Quantity of the product
+            variant_selections: Product variant selections (optional)
+            poll_interval: The interval in seconds between polling attempts (default: 5.0)
+            max_attempts: The maximum number of polling attempts before timing out (default: 120)
+            extra_headers: Send extra headers
+            extra_query: Add additional query parameters to the request
+            extra_body: Add additional JSON properties to the request
+            timeout: Override the client-level default timeout for this request, in seconds
+
+        Returns:
+            The checkout intent once it reaches awaiting_confirmation or failed state
+
+        Example:
+            ```python
+            # Phase 1: Create and wait for offer
+            intent = await client.checkout_intents.create_and_poll(
+                buyer={
+                    "address1": "123 Main St",
+                    "city": "New York",
+                    "country": "United States",
+                    "email": "john.doe@example.com",
+                    "first_name": "John",
+                    "last_name": "Doe",
+                    "phone": "+1234567890",
+                    "postal_code": "10001",
+                    "province": "NY",
+                },
+                product_url="https://example.com/product",
+                quantity=1,
+            )
+
+            # Review the offer with the user
+            print("Total:", intent.offer.cost.total)
+
+            # Phase 2: Confirm with payment
+            completed = await client.checkout_intents.confirm_and_poll(
+                intent.id, payment_method={"type": "stripe_token", "stripe_token": "tok_visa"}
+            )
+            ```
+        """
+        intent = await self.create(
+            buyer=buyer,
+            product_url=product_url,
+            quantity=quantity,
+            variant_selections=variant_selections,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        return await self.poll_until_awaiting_confirmation(
+            intent.id,
+            poll_interval=poll_interval,
+            max_attempts=max_attempts,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+
+    async def confirm_and_poll(
+        self,
+        id: str,
+        *,
+        payment_method: PaymentMethodParam,
+        poll_interval: float = 5.0,
+        max_attempts: int = 120,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Union[CompletedCheckoutIntent, FailedCheckoutIntent]:
+        """
+        A helper to confirm a checkout intent and poll until it reaches a completed state
+        (completed or failed).
+
+        Args:
+            id: The checkout intent ID to confirm
+            payment_method: Payment method information
+            poll_interval: The interval in seconds between polling attempts (default: 5.0)
+            max_attempts: The maximum number of polling attempts before timing out (default: 120)
+            extra_headers: Send extra headers
+            extra_query: Add additional query parameters to the request
+            extra_body: Add additional JSON properties to the request
+            timeout: Override the client-level default timeout for this request, in seconds
+
+        Returns:
+            The checkout intent once it reaches completed or failed state
+
+        Example:
+            ```python
+            checkout_intent = await client.checkout_intents.confirm_and_poll(
+                "id",
+                payment_method={
+                    "stripe_token": "tok_1RkrWWHGDlstla3f1Fc7ZrhH",
+                    "type": "stripe_token",
+                },
+            )
+
+            if checkout_intent.state == "completed":
+                print("Order placed successfully!")
+            elif checkout_intent.state == "failed":
+                print("Order failed:", checkout_intent.failure_reason)
+            ```
+        """
+        intent = await self.confirm(
+            id,
+            payment_method=payment_method,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        return await self.poll_until_completed(
+            intent.id,
+            poll_interval=poll_interval,
+            max_attempts=max_attempts,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+
 
 class CheckoutIntentsResourceWithRawResponse:
     def __init__(self, checkout_intents: CheckoutIntentsResource) -> None:
@@ -424,6 +1154,18 @@ class CheckoutIntentsResourceWithRawResponse:
         self.confirm = to_raw_response_wrapper(
             checkout_intents.confirm,
         )
+        self.poll_until_completed = to_raw_response_wrapper(
+            checkout_intents.poll_until_completed,
+        )
+        self.poll_until_awaiting_confirmation = to_raw_response_wrapper(
+            checkout_intents.poll_until_awaiting_confirmation,
+        )
+        self.create_and_poll = to_raw_response_wrapper(
+            checkout_intents.create_and_poll,
+        )
+        self.confirm_and_poll = to_raw_response_wrapper(
+            checkout_intents.confirm_and_poll,
+        )
 
 
 class AsyncCheckoutIntentsResourceWithRawResponse:
@@ -442,6 +1184,18 @@ class AsyncCheckoutIntentsResourceWithRawResponse:
         self.confirm = async_to_raw_response_wrapper(
             checkout_intents.confirm,
         )
+        self.poll_until_completed = async_to_raw_response_wrapper(
+            checkout_intents.poll_until_completed,
+        )
+        self.poll_until_awaiting_confirmation = async_to_raw_response_wrapper(
+            checkout_intents.poll_until_awaiting_confirmation,
+        )
+        self.create_and_poll = async_to_raw_response_wrapper(
+            checkout_intents.create_and_poll,
+        )
+        self.confirm_and_poll = async_to_raw_response_wrapper(
+            checkout_intents.confirm_and_poll,
+        )
 
 
 class CheckoutIntentsResourceWithStreamingResponse:
@@ -460,6 +1214,18 @@ class CheckoutIntentsResourceWithStreamingResponse:
         self.confirm = to_streamed_response_wrapper(
             checkout_intents.confirm,
         )
+        self.poll_until_completed = to_streamed_response_wrapper(
+            checkout_intents.poll_until_completed,
+        )
+        self.poll_until_awaiting_confirmation = to_streamed_response_wrapper(
+            checkout_intents.poll_until_awaiting_confirmation,
+        )
+        self.create_and_poll = to_streamed_response_wrapper(
+            checkout_intents.create_and_poll,
+        )
+        self.confirm_and_poll = to_streamed_response_wrapper(
+            checkout_intents.confirm_and_poll,
+        )
 
 
 class AsyncCheckoutIntentsResourceWithStreamingResponse:
@@ -478,3 +1244,15 @@ class AsyncCheckoutIntentsResourceWithStreamingResponse:
         self.confirm = async_to_streamed_response_wrapper(
             checkout_intents.confirm,
         )
+        self.poll_until_completed = async_to_streamed_response_wrapper(
+            checkout_intents.poll_until_completed,
+        )
+        self.poll_until_awaiting_confirmation = async_to_streamed_response_wrapper(
+            checkout_intents.poll_until_awaiting_confirmation,
+        )
+        self.create_and_poll = async_to_streamed_response_wrapper(
+            checkout_intents.create_and_poll,
+        )
+        self.confirm_and_poll = async_to_streamed_response_wrapper(
+            checkout_intents.confirm_and_poll,
+        )

{checkout_intents-0.1.0.dist-info → checkout_intents-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: checkout-intents
-Version: 0.1.0
+Version: 0.2.0
 Summary: The official Python library for the Checkout Intents API
 Project-URL: Homepage, https://github.com/rye-com/checkout-intents-python
 Project-URL: Repository, https://github.com/rye-com/checkout-intents-python
@@ -88,6 +88,98 @@ we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
 to add `CHECKOUT_INTENTS_API_KEY="My API Key"` to your `.env` file
 so that your API Key is not stored in source control.
 
+### Polling Helpers
+
+This SDK includes helper methods for the asynchronous checkout flow. The recommended pattern follows Rye's two-phase checkout:
+
+```python
+from checkout_intents import CheckoutIntents
+
+client = CheckoutIntents()
+
+# Phase 1: Create and wait for offer
+intent = client.checkout_intents.create_and_poll(
+    buyer={
+        "address1": "123 Main St",
+        "city": "New York",
+        "country": "US",
+        "email": "john.doe@example.com",
+        "first_name": "John",
+        "last_name": "Doe",
+        "phone": "5555555555",
+        "postal_code": "10001",
+        "province": "NY",
+    },
+    product_url="https://example.com/product",
+    quantity=1,
+)
+
+# Handle failure during offer retrieval
+if intent.state == "failed":
+    print(f"Failed: {intent.failure_reason}")
+else:
+    # Review pricing with user
+    print(f"Total: {intent.offer.cost.total}")
+
+    # Phase 2: Confirm and wait for completion
+    completed = client.checkout_intents.confirm_and_poll(
+        intent.id,
+        payment_method={
+            "type": "stripe_token",
+            "stripe_token": "tok_visa",
+        },
+    )
+
+    print(f"Status: {completed.state}")
+```
+
+For more examples, see the [`examples/`](https://github.com/rye-com/checkout-intents-python/tree/main/./examples) directory:
+
+- [`complete-checkout-intent.py`](https://github.com/rye-com/checkout-intents-python/tree/main/./examples/complete-checkout-intent.py) - Recommended two-phase flow
+- [`error-handling.py`](https://github.com/rye-com/checkout-intents-python/tree/main/./examples/error-handling.py) - Timeout and error handling with `PollTimeoutError`
+
+Available polling methods:
+
+- `create_and_poll()` - Create and poll until offer is ready (awaiting_confirmation or failed)
+- `confirm_and_poll()` - Confirm and poll until completion (completed or failed)
+- `poll_until_completed()` - Poll until completed or failed
+- `poll_until_awaiting_confirmation()` - Poll until offer is ready or failed
+
+All polling methods support customizable timeouts:
+
+```python
+# Configure polling behavior
+intent = client.checkout_intents.poll_until_completed(
+    intent_id,
+    poll_interval=5.0,  # Poll every 5 seconds (default)
+    max_attempts=120,  # Try up to 120 times, ~10 minutes (default)
+)
+```
+
+#### Handling Polling Timeouts
+
+When polling operations exceed `max_attempts`, a `PollTimeoutError` is raised with helpful context:
+
+```python
+from checkout_intents import CheckoutIntents, PollTimeoutError
+
+client = CheckoutIntents()
+
+try:
+    intent = client.checkout_intents.poll_until_completed(
+        intent_id,
+        poll_interval=5.0,
+        max_attempts=60,
+    )
+except PollTimeoutError as e:
+    print(f"Polling timed out for intent: {e.intent_id}")
+    print(f"Attempted {e.attempts} times over {(e.attempts * e.poll_interval) / 1000}s")
+
+    # You can retrieve the current state manually
+    current_intent = client.checkout_intents.retrieve(e.intent_id)
+    print(f"Current state: {current_intent.state}")
+```
+
 ## Async usage
 
 Simply import `AsyncCheckoutIntents` instead of `CheckoutIntents` and use `await` with each API call:
@@ -258,6 +350,26 @@ Error codes are as follows:
 | 429         | `RateLimitError`           |
 | >=500       | `InternalServerError`      |
 | N/A         | `APIConnectionError`       |
+| N/A         | `PollTimeoutError`         |
+
+### Polling Timeout Errors
+
+When using polling helper methods, if the operation exceeds the configured `max_attempts`, a `PollTimeoutError` is raised. This error includes detailed context about the timeout:
+
+```python
+from checkout_intents import CheckoutIntents, PollTimeoutError
+
+try:
+    intent = client.checkout_intents.poll_until_completed("intent_id")
+except PollTimeoutError as e:
+    # Access timeout details
+    print(f"Intent ID: {e.intent_id}")
+    print(f"Attempts: {e.attempts}")
+    print(f"Poll interval: {e.poll_interval}s")
+    print(f"Max attempts: {e.max_attempts}")
+```
+
+See the [error-handling.py example](https://github.com/rye-com/checkout-intents-python/tree/main/./examples/error-handling.py) for more detailed timeout handling patterns.
 
 ### Retries
 

{checkout_intents-0.1.0.dist-info → checkout_intents-0.2.0.dist-info}/RECORD

@@ -1,20 +1,20 @@
-checkout_intents/__init__.py,sha256=_Y4Qxqr-oIONV3M6jqtFF1yMOaH_iOT7Em7EmCroKAY,2787
+checkout_intents/__init__.py,sha256=5m0_Ktnyya4CJ0vdWZbAv7qZMeR1VnXqN_MJtH3RJTM,2833
 checkout_intents/_base_client.py,sha256=eB43s-6F0_5tyH_e9uX-HAovJJu6D9DdMGVcI2zP4qc,67057
-checkout_intents/_client.py,sha256=jzpmFQeUmVwWQRYy5r2q77OAaO74BSghPPfR5FVrOPs,18814
+checkout_intents/_client.py,sha256=px36nDPT8_lNISKkVjZhI_AZvFJ5KwRyVjQjPycia0s,21798
 checkout_intents/_compat.py,sha256=DQBVORjFb33zch24jzkhM14msvnzY7mmSmgDLaVFUM8,6562
 checkout_intents/_constants.py,sha256=S14PFzyN9-I31wiV7SmIlL5Ga0MLHxdvegInGdXH7tM,462
-checkout_intents/_exceptions.py,sha256=hwQX-kTpgIyHAc2zsdnyNU1h8fxQN_O4nw5srxROooU,3238
+checkout_intents/_exceptions.py,sha256=oQn7Y6LzccgRDOtdg20l68bXtgf2tgVNKIrufJPDsuk,4252
 checkout_intents/_files.py,sha256=KnEzGi_O756MvKyJ4fOCW_u3JhOeWPQ4RsmDvqihDQU,3545
-checkout_intents/_models.py,sha256=_jpXNYoIJGzLCqeD4LcmiD4UgZKYMLg4cZ8TcWUn94I,30559
+checkout_intents/_models.py,sha256=m6hDet9vdfyY7TuzbLCBYhMPoIN6hddOZp9qDZ-zfVU,31995
 checkout_intents/_qs.py,sha256=craIKyvPktJ94cvf9zn8j8ekG9dWJzhWv0ob34lIOv4,4828
 checkout_intents/_resource.py,sha256=X-eWffEBAgzTZvakLqNUjwgidMKfBFRmCeeOiuko4lg,1154
 checkout_intents/_response.py,sha256=sLqxWBxzmVqPsdr2x5z6d87h8jb1U-Huvh2YFg-U6nE,28876
 checkout_intents/_streaming.py,sha256=XOY20ljJEmOSf-nT8_KvPZipmgllR5sO400ePyMVLIY,10185
 checkout_intents/_types.py,sha256=4l2pVH65co-2pua9stzq-WV2VcGg9Hl4nRHd0lz5cko,7246
-checkout_intents/_version.py,sha256=EAZcX0kAfIydwo7T3jYb_O2Svh_deoksAmQGQqT2ytw,168
+checkout_intents/_version.py,sha256=bLy0NHnQnIHbjqtwiAOnmDFC0CDZ2s-DkgnwlFLRcps,168
 checkout_intents/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 checkout_intents/_utils/__init__.py,sha256=7fch0GT9zpNnErbciSpUNa-SjTxxjY6kxHxKMOM4AGs,2305
-checkout_intents/_utils/_compat.py,sha256=D8gtAvjJQrDWt9upS0XaG9Rr5l1QhiAx_I_1utT_tt0,1195
+checkout_intents/_utils/_compat.py,sha256=rN17SSvjMoQE1GmKFTLniRuG1sKj2WAD5VjdLPeRlF0,1231
 checkout_intents/_utils/_datetime_parse.py,sha256=bABTs0Bc6rabdFvnIwXjEhWL15TcRgWZ_6XGTqN8xUk,4204
 checkout_intents/_utils/_logs.py,sha256=dw1slZVPfWp0Z_jBGEQvr8TDY0uu3V7pJuexM_MG4pk,804
 checkout_intents/_utils/_proxy.py,sha256=aglnj2yBTDyGX9Akk2crZHrl10oqRmceUy2Zp008XEs,1975
@@ -24,11 +24,11 @@ checkout_intents/_utils/_streams.py,sha256=SMC90diFFecpEg_zgDRVbdR3hSEIgVVij4taD
 checkout_intents/_utils/_sync.py,sha256=HBnZkkBnzxtwOZe0212C4EyoRvxhTVtTrLFDz2_xVCg,1589
 checkout_intents/_utils/_transform.py,sha256=NjCzmnfqYrsAikUHQig6N9QfuTVbKipuP3ur9mcNF-E,15951
 checkout_intents/_utils/_typing.py,sha256=N_5PPuFNsaygbtA_npZd98SVN1LQQvFTKL6bkWPBZGU,4786
-checkout_intents/_utils/_utils.py,sha256=ugfUaneOK7I8h9b3656flwf5u_kthY0gvNuqvgOLoSU,12252
+checkout_intents/_utils/_utils.py,sha256=g9ftElB09kVT6EVfCIlD_nUfANhDX5_vZO61FDWoIQI,12334
 checkout_intents/lib/.keep,sha256=wuNrz-5SXo3jJaJOJgz4vFHM41YH_g20F5cRQo0vLes,224
 checkout_intents/resources/__init__.py,sha256=sHRW0nwo1GnFBFPoTNohkEbvOk7au-R3MdfVn_yb8Ds,1120
 checkout_intents/resources/brands.py,sha256=LylMXefUeP4G540jtG8QHRAKwTMZHKI7vJhWnACS5Dc,6349
-checkout_intents/resources/checkout_intents.py,sha256=lqkOZkvAW-dMzcyReRaLllczKQG4WmIDCnZ9uTsUzH0,19054
+checkout_intents/resources/checkout_intents.py,sha256=Q8BIh96n3nh6DbcBW7tSmCrJv7wF12QOTxyoD9Dit8s,49522
 checkout_intents/types/__init__.py,sha256=QHuqIegrR01arvPOp6GI2C8VUw3o37KNxr2KDtjh0eE,1098
 checkout_intents/types/base_checkout_intent.py,sha256=56Qp3ssWYmcdu6A9Z0pvL3ewm1LTvQHiboiJ7Aogx2M,644
 checkout_intents/types/brand_retrieve_response.py,sha256=1Z7yjrXl3NO1u9NFO5lDBJ-sucpEH501MUfUS_XeqbY,550
@@ -44,7 +44,7 @@ checkout_intents/types/payment_method.py,sha256=Mw85dZNa0z7Sr5FoQ9_nOUOjjKEHoE2x
 checkout_intents/types/payment_method_param.py,sha256=jbqAao2w7wxEHd_nshOthmZ53Ww7I4EiFmddpa_ejis,437
 checkout_intents/types/variant_selection.py,sha256=M8O6CpcpIlFqfPlQW_wFcJ6rwt459n6dJkjLkLB1klk,493
 checkout_intents/types/variant_selection_param.py,sha256=CMz4y1bDpuHNpnUmCcyeiYs6uwLBS9CJwo9iSpGMu-Q,589
-checkout_intents-0.1.0.dist-info/METADATA,sha256=5IyIauLcYzfpz0EOC7OHMBCH2x-_F9lvP1o7wHWh6hM,17734
-checkout_intents-0.1.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-checkout_intents-0.1.0.dist-info/licenses/LICENSE,sha256=dRDmL6lFnLaphTaman8kAc21qY1IQ_qsAETk1F-b6jY,1056
-checkout_intents-0.1.0.dist-info/RECORD,,
+checkout_intents-0.2.0.dist-info/METADATA,sha256=YDQk64h64eqBFNJjfG3vO_O4HvHQ686OmaTnzjPcfAY,21534
+checkout_intents-0.2.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+checkout_intents-0.2.0.dist-info/licenses/LICENSE,sha256=dRDmL6lFnLaphTaman8kAc21qY1IQ_qsAETk1F-b6jY,1056
+checkout_intents-0.2.0.dist-info/RECORD,,