dodopayments 1.44.0__py3-none-any.whl → 1.47.0__py3-none-any.whl

dodopayments/resources/your_webhook_url.py

@@ -0,0 +1,224 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from datetime import datetime
+
+import httpx
+
+from ..types import WebhookEventType, your_webhook_url_create_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NoneType, NotGiven
+from .._utils import maybe_transform, async_maybe_transform
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from .._base_client import make_request_options
+from ..types.webhook_event_type import WebhookEventType
+
+__all__ = ["YourWebhookURLResource", "AsyncYourWebhookURLResource"]
+
+
+class YourWebhookURLResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> YourWebhookURLResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/dodopayments/dodopayments-python#accessing-raw-response-data-eg-headers
+        """
+        return YourWebhookURLResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> YourWebhookURLResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/dodopayments/dodopayments-python#with_streaming_response
+        """
+        return YourWebhookURLResourceWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        business_id: str,
+        data: Union[
+            your_webhook_url_create_params.DataPayment,
+            your_webhook_url_create_params.DataSubscription,
+            your_webhook_url_create_params.DataRefund,
+            your_webhook_url_create_params.DataDispute,
+            your_webhook_url_create_params.DataLicenseKey,
+        ],
+        timestamp: Union[str, datetime],
+        type: WebhookEventType,
+        webhook_id: str,
+        webhook_signature: str,
+        webhook_timestamp: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> None:
+        """
+        Args:
+          data: The latest data at the time of delivery attempt
+
+          timestamp: The timestamp of when the event occurred (not necessarily the same of when it
+              was delivered)
+
+          type: Event types for Dodo events
+
+          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
+        """
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        extra_headers.update(
+            {"webhook-id": webhook_id, "webhook-signature": webhook_signature, "webhook-timestamp": webhook_timestamp}
+        )
+        return self._post(
+            "/your-webhook-url",
+            body=maybe_transform(
+                {
+                    "business_id": business_id,
+                    "data": data,
+                    "timestamp": timestamp,
+                    "type": type,
+                },
+                your_webhook_url_create_params.YourWebhookURLCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class AsyncYourWebhookURLResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncYourWebhookURLResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/dodopayments/dodopayments-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncYourWebhookURLResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncYourWebhookURLResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/dodopayments/dodopayments-python#with_streaming_response
+        """
+        return AsyncYourWebhookURLResourceWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        business_id: str,
+        data: Union[
+            your_webhook_url_create_params.DataPayment,
+            your_webhook_url_create_params.DataSubscription,
+            your_webhook_url_create_params.DataRefund,
+            your_webhook_url_create_params.DataDispute,
+            your_webhook_url_create_params.DataLicenseKey,
+        ],
+        timestamp: Union[str, datetime],
+        type: WebhookEventType,
+        webhook_id: str,
+        webhook_signature: str,
+        webhook_timestamp: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> None:
+        """
+        Args:
+          data: The latest data at the time of delivery attempt
+
+          timestamp: The timestamp of when the event occurred (not necessarily the same of when it
+              was delivered)
+
+          type: Event types for Dodo events
+
+          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
+        """
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        extra_headers.update(
+            {"webhook-id": webhook_id, "webhook-signature": webhook_signature, "webhook-timestamp": webhook_timestamp}
+        )
+        return await self._post(
+            "/your-webhook-url",
+            body=await async_maybe_transform(
+                {
+                    "business_id": business_id,
+                    "data": data,
+                    "timestamp": timestamp,
+                    "type": type,
+                },
+                your_webhook_url_create_params.YourWebhookURLCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class YourWebhookURLResourceWithRawResponse:
+    def __init__(self, your_webhook_url: YourWebhookURLResource) -> None:
+        self._your_webhook_url = your_webhook_url
+
+        self.create = to_raw_response_wrapper(
+            your_webhook_url.create,
+        )
+
+
+class AsyncYourWebhookURLResourceWithRawResponse:
+    def __init__(self, your_webhook_url: AsyncYourWebhookURLResource) -> None:
+        self._your_webhook_url = your_webhook_url
+
+        self.create = async_to_raw_response_wrapper(
+            your_webhook_url.create,
+        )
+
+
+class YourWebhookURLResourceWithStreamingResponse:
+    def __init__(self, your_webhook_url: YourWebhookURLResource) -> None:
+        self._your_webhook_url = your_webhook_url
+
+        self.create = to_streamed_response_wrapper(
+            your_webhook_url.create,
+        )
+
+
+class AsyncYourWebhookURLResourceWithStreamingResponse:
+    def __init__(self, your_webhook_url: AsyncYourWebhookURLResource) -> None:
+        self._your_webhook_url = your_webhook_url
+
+        self.create = async_to_streamed_response_wrapper(
+            your_webhook_url.create,
+        )

dodopayments/types/__init__.py

@@ -15,21 +15,28 @@ from .get_dispute import GetDispute as GetDispute
 from .license_key import LicenseKey as LicenseKey
 from .price_param import PriceParam as PriceParam
 from .country_code import CountryCode as CountryCode
+from .refund_param import RefundParam as RefundParam
 from .subscription import Subscription as Subscription
 from .tax_category import TaxCategory as TaxCategory
 from .discount_type import DiscountType as DiscountType
+from .dispute_param import DisputeParam as DisputeParam
 from .dispute_stage import DisputeStage as DisputeStage
 from .intent_status import IntentStatus as IntentStatus
+from .payment_param import PaymentParam as PaymentParam
 from .refund_status import RefundStatus as RefundStatus
 from .time_interval import TimeInterval as TimeInterval
 from .addon_response import AddonResponse as AddonResponse
 from .dispute_status import DisputeStatus as DisputeStatus
 from .billing_address import BillingAddress as BillingAddress
 from .addon_list_params import AddonListParams as AddonListParams
+from .get_dispute_param import GetDisputeParam as GetDisputeParam
+from .license_key_param import LicenseKeyParam as LicenseKeyParam
 from .attach_addon_param import AttachAddonParam as AttachAddonParam
 from .license_key_status import LicenseKeyStatus as LicenseKeyStatus
+from .new_customer_param import NewCustomerParam as NewCustomerParam
 from .payout_list_params import PayoutListParams as PayoutListParams
 from .refund_list_params import RefundListParams as RefundListParams
+from .subscription_param import SubscriptionParam as SubscriptionParam
 from .webhook_event_type import WebhookEventType as WebhookEventType
 from .addon_create_params import AddonCreateParams as AddonCreateParams
 from .addon_update_params import AddonUpdateParams as AddonUpdateParams
@@ -40,6 +47,7 @@ from .dispute_list_params import DisputeListParams as DisputeListParams
 from .payment_list_params import PaymentListParams as PaymentListParams
 from .product_list_params import ProductListParams as ProductListParams
 from .subscription_status import SubscriptionStatus as SubscriptionStatus
+from .webhook_list_params import WebhookListParams as WebhookListParams
 from .customer_list_params import CustomerListParams as CustomerListParams
 from .discount_list_params import DiscountListParams as DiscountListParams
 from .license_key_duration import LicenseKeyDuration as LicenseKeyDuration
@@ -54,6 +62,9 @@ from .payment_list_response import PaymentListResponse as PaymentListResponse
 from .product_create_params import ProductCreateParams as ProductCreateParams
 from .product_list_response import ProductListResponse as ProductListResponse
 from .product_update_params import ProductUpdateParams as ProductUpdateParams
+from .webhook_create_params import WebhookCreateParams as WebhookCreateParams
+from .webhook_list_response import WebhookListResponse as WebhookListResponse
+from .webhook_update_params import WebhookUpdateParams as WebhookUpdateParams
 from .customer_create_params import CustomerCreateParams as CustomerCreateParams
 from .customer_request_param import CustomerRequestParam as CustomerRequestParam
 from .customer_update_params import CustomerUpdateParams as CustomerUpdateParams
@@ -64,13 +75,15 @@ from .license_activate_params import LicenseActivateParams as LicenseActivatePar
 from .license_key_list_params import LicenseKeyListParams as LicenseKeyListParams
 from .license_validate_params import LicenseValidateParams as LicenseValidateParams
 from .payment_create_response import PaymentCreateResponse as PaymentCreateResponse
+from .webhook_create_response import WebhookCreateResponse as WebhookCreateResponse
+from .webhook_update_response import WebhookUpdateResponse as WebhookUpdateResponse
 from .addon_cart_response_item import AddonCartResponseItem as AddonCartResponseItem
 from .customer_limited_details import CustomerLimitedDetails as CustomerLimitedDetails
 from .subscription_list_params import SubscriptionListParams as SubscriptionListParams
-from .create_new_customer_param import CreateNewCustomerParam as CreateNewCustomerParam
 from .license_deactivate_params import LicenseDeactivateParams as LicenseDeactivateParams
 from .license_key_update_params import LicenseKeyUpdateParams as LicenseKeyUpdateParams
 from .license_validate_response import LicenseValidateResponse as LicenseValidateResponse
+from .webhook_retrieve_response import WebhookRetrieveResponse as WebhookRetrieveResponse
 from .license_key_duration_param import LicenseKeyDurationParam as LicenseKeyDurationParam
 from .one_time_product_cart_item import OneTimeProductCartItem as OneTimeProductCartItem
 from .subscription_charge_params import SubscriptionChargeParams as SubscriptionChargeParams
@@ -83,7 +96,10 @@ from .brand_update_images_response import BrandUpdateImagesResponse as BrandUpda
 from .subscription_charge_response import SubscriptionChargeResponse as SubscriptionChargeResponse
 from .subscription_create_response import SubscriptionCreateResponse as SubscriptionCreateResponse
 from .product_update_files_response import ProductUpdateFilesResponse as ProductUpdateFilesResponse
+from .addon_cart_response_item_param import AddonCartResponseItemParam as AddonCartResponseItemParam
 from .attach_existing_customer_param import AttachExistingCustomerParam as AttachExistingCustomerParam
+from .customer_limited_details_param import CustomerLimitedDetailsParam as CustomerLimitedDetailsParam
+from .your_webhook_url_create_params import YourWebhookURLCreateParams as YourWebhookURLCreateParams
 from .subscription_change_plan_params import SubscriptionChangePlanParams as SubscriptionChangePlanParams
 from .license_key_instance_list_params import LicenseKeyInstanceListParams as LicenseKeyInstanceListParams
 from .one_time_product_cart_item_param import OneTimeProductCartItemParam as OneTimeProductCartItemParam

dodopayments/types/addon_cart_response_item_param.py

@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["AddonCartResponseItemParam"]
+
+
+class AddonCartResponseItemParam(TypedDict, total=False):
+    addon_id: Required[str]
+
+    quantity: Required[int]

dodopayments/types/customer_limited_details_param.py

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["CustomerLimitedDetailsParam"]
+
+
+class CustomerLimitedDetailsParam(TypedDict, total=False):
+    customer_id: Required[str]
+    """Unique identifier for the customer"""
+
+    email: Required[str]
+    """Email address of the customer"""
+
+    name: Required[str]
+    """Full name of the customer"""

dodopayments/types/customer_request_param.py

@@ -5,9 +5,9 @@ from __future__ import annotations
 from typing import Union
 from typing_extensions import TypeAlias
 
-from .create_new_customer_param import CreateNewCustomerParam
+from .new_customer_param import NewCustomerParam
 from .attach_existing_customer_param import AttachExistingCustomerParam
 
 __all__ = ["CustomerRequestParam"]
 
-CustomerRequestParam: TypeAlias = Union[AttachExistingCustomerParam, CreateNewCustomerParam]
+CustomerRequestParam: TypeAlias = Union[AttachExistingCustomerParam, NewCustomerParam]

dodopayments/types/discount.py

@@ -45,5 +45,12 @@ class Discount(BaseModel):
     name: Optional[str] = None
     """Name for the Discount"""
 
+    subscription_cycles: Optional[int] = None
+    """
+    Number of subscription billing cycles this discount is valid for. If not
+    provided, the discount will be applied indefinitely to all recurring payments
+    related to the subscription.
+    """
+
     usage_limit: Optional[int] = None
     """Usage limit for this discount, if any."""

dodopayments/types/discount_create_params.py

@@ -42,5 +42,12 @@ class DiscountCreateParams(TypedDict, total=False):
     restricted_to: Optional[List[str]]
     """List of product IDs to restrict usage (if any)."""
 
+    subscription_cycles: Optional[int]
+    """
+    Number of subscription billing cycles this discount is valid for. If not
+    provided, the discount will be applied indefinitely to all recurring payments
+    related to the subscription.
+    """
+
     usage_limit: Optional[int]
     """How many times this discount can be used (if any). Must be >= 1 if provided."""

dodopayments/types/discount_update_params.py

@@ -36,6 +36,13 @@ class DiscountUpdateParams(TypedDict, total=False):
     restrictions, send empty array
     """
 
+    subscription_cycles: Optional[int]
+    """
+    Number of subscription billing cycles this discount is valid for. If not
+    provided, the discount will be applied indefinitely to all recurring payments
+    related to the subscription.
+    """
+
     type: Optional[DiscountType]
     """If present, update the discount type."""
 

dodopayments/types/dispute_param.py

@@ -0,0 +1,45 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Optional
+from datetime import datetime
+from typing_extensions import Required, Annotated, TypedDict
+
+from .._utils import PropertyInfo
+from .dispute_stage import DisputeStage
+from .dispute_status import DisputeStatus
+
+__all__ = ["DisputeParam"]
+
+
+class DisputeParam(TypedDict, total=False):
+    amount: Required[str]
+    """
+    The amount involved in the dispute, represented as a string to accommodate
+    precision.
+    """
+
+    business_id: Required[str]
+    """The unique identifier of the business involved in the dispute."""
+
+    created_at: Required[Annotated[Union[str, datetime], PropertyInfo(format="iso8601")]]
+    """The timestamp of when the dispute was created, in UTC."""
+
+    currency: Required[str]
+    """The currency of the disputed amount, represented as an ISO 4217 currency code."""
+
+    dispute_id: Required[str]
+    """The unique identifier of the dispute."""
+
+    dispute_stage: Required[DisputeStage]
+    """The current stage of the dispute process."""
+
+    dispute_status: Required[DisputeStatus]
+    """The current status of the dispute."""
+
+    payment_id: Required[str]
+    """The unique identifier of the payment associated with the dispute."""
+
+    remarks: Optional[str]
+    """Remarks"""

dodopayments/types/get_dispute_param.py

@@ -0,0 +1,52 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Optional
+from datetime import datetime
+from typing_extensions import Required, Annotated, TypedDict
+
+from .._utils import PropertyInfo
+from .dispute_stage import DisputeStage
+from .dispute_status import DisputeStatus
+from .customer_limited_details_param import CustomerLimitedDetailsParam
+
+__all__ = ["GetDisputeParam"]
+
+
+class GetDisputeParam(TypedDict, total=False):
+    amount: Required[str]
+    """
+    The amount involved in the dispute, represented as a string to accommodate
+    precision.
+    """
+
+    business_id: Required[str]
+    """The unique identifier of the business involved in the dispute."""
+
+    created_at: Required[Annotated[Union[str, datetime], PropertyInfo(format="iso8601")]]
+    """The timestamp of when the dispute was created, in UTC."""
+
+    currency: Required[str]
+    """The currency of the disputed amount, represented as an ISO 4217 currency code."""
+
+    customer: Required[CustomerLimitedDetailsParam]
+    """The customer who filed the dispute"""
+
+    dispute_id: Required[str]
+    """The unique identifier of the dispute."""
+
+    dispute_stage: Required[DisputeStage]
+    """The current stage of the dispute process."""
+
+    dispute_status: Required[DisputeStatus]
+    """The current status of the dispute."""
+
+    payment_id: Required[str]
+    """The unique identifier of the payment associated with the dispute."""
+
+    reason: Optional[str]
+    """Reason for the dispute"""
+
+    remarks: Optional[str]
+    """Remarks"""

dodopayments/types/license_key_param.py

@@ -0,0 +1,53 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Optional
+from datetime import datetime
+from typing_extensions import Required, Annotated, TypedDict
+
+from .._utils import PropertyInfo
+from .license_key_status import LicenseKeyStatus
+
+__all__ = ["LicenseKeyParam"]
+
+
+class LicenseKeyParam(TypedDict, total=False):
+    id: Required[str]
+    """The unique identifier of the license key."""
+
+    business_id: Required[str]
+    """The unique identifier of the business associated with the license key."""
+
+    created_at: Required[Annotated[Union[str, datetime], PropertyInfo(format="iso8601")]]
+    """The timestamp indicating when the license key was created, in UTC."""
+
+    customer_id: Required[str]
+    """The unique identifier of the customer associated with the license key."""
+
+    instances_count: Required[int]
+    """The current number of instances activated for this license key."""
+
+    key: Required[str]
+    """The license key string."""
+
+    payment_id: Required[str]
+    """The unique identifier of the payment associated with the license key."""
+
+    product_id: Required[str]
+    """The unique identifier of the product associated with the license key."""
+
+    status: Required[LicenseKeyStatus]
+    """The current status of the license key (e.g., active, inactive, expired)."""
+
+    activations_limit: Optional[int]
+    """The maximum number of activations allowed for this license key."""
+
+    expires_at: Annotated[Union[str, datetime, None], PropertyInfo(format="iso8601")]
+    """The timestamp indicating when the license key expires, in UTC."""
+
+    subscription_id: Optional[str]
+    """
+    The unique identifier of the subscription associated with the license key, if
+    any.
+    """

dodopayments/types/new_customer_param.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Required, TypedDict
+
+__all__ = ["NewCustomerParam"]
+
+
+class NewCustomerParam(TypedDict, total=False):
+    email: Required[str]
+
+    name: Required[str]
+
+    phone_number: Optional[str]