dodopayments 1.51.1__py3-none-any.whl → 1.56.5__py3-none-any.whl

dodopayments/types/meter.py

@@ -0,0 +1,40 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+
+from .._models import BaseModel
+from .meter_filter import MeterFilter
+from .meter_aggregation import MeterAggregation
+
+__all__ = ["Meter"]
+
+
+class Meter(BaseModel):
+    id: str
+
+    aggregation: MeterAggregation
+
+    business_id: str
+
+    created_at: datetime
+
+    event_name: str
+
+    measurement_unit: str
+
+    name: str
+
+    updated_at: datetime
+
+    description: Optional[str] = None
+
+    filter: Optional[MeterFilter] = None
+    """
+    A filter structure that combines multiple conditions with logical conjunctions
+    (AND/OR).
+
+    Supports up to 3 levels of nesting to create complex filter expressions. Each
+    filter has a conjunction (and/or) and clauses that can be either direct
+    conditions or nested filters.
+    """

dodopayments/types/meter_aggregation.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["MeterAggregation"]
+
+
+class MeterAggregation(BaseModel):
+    type: Literal["count", "sum", "max", "last"]
+    """Aggregation type for the meter"""
+
+    key: Optional[str] = None
+    """Required when type is not COUNT"""

dodopayments/types/meter_aggregation_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 Literal, Required, TypedDict
+
+__all__ = ["MeterAggregationParam"]
+
+
+class MeterAggregationParam(TypedDict, total=False):
+    type: Required[Literal["count", "sum", "max", "last"]]
+    """Aggregation type for the meter"""
+
+    key: Optional[str]
+    """Required when type is not COUNT"""

dodopayments/types/meter_create_params.py

@@ -0,0 +1,31 @@
+# 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
+
+from .meter_filter_param import MeterFilterParam
+from .meter_aggregation_param import MeterAggregationParam
+
+__all__ = ["MeterCreateParams"]
+
+
+class MeterCreateParams(TypedDict, total=False):
+    aggregation: Required[MeterAggregationParam]
+    """Aggregation configuration for the meter"""
+
+    event_name: Required[str]
+    """Event name to track"""
+
+    measurement_unit: Required[str]
+    """measurement unit"""
+
+    name: Required[str]
+    """Name of the meter"""
+
+    description: Optional[str]
+    """Optional description of the meter"""
+
+    filter: Optional[MeterFilterParam]
+    """Optional filter to apply to the meter"""

dodopayments/types/meter_filter.py

@@ -0,0 +1,131 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = [
+    "MeterFilter",
+    "ClausesDirectFilterCondition",
+    "ClausesNestedMeterFilter",
+    "ClausesNestedMeterFilterClausesLevel1FilterCondition",
+    "ClausesNestedMeterFilterClausesLevel1NestedFilter",
+    "ClausesNestedMeterFilterClausesLevel1NestedFilterClausesLevel2FilterCondition",
+    "ClausesNestedMeterFilterClausesLevel1NestedFilterClausesLevel2NestedFilter",
+    "ClausesNestedMeterFilterClausesLevel1NestedFilterClausesLevel2NestedFilterClause",
+]
+
+
+class ClausesDirectFilterCondition(BaseModel):
+    key: str
+    """Filter key to apply"""
+
+    operator: Literal[
+        "equals",
+        "not_equals",
+        "greater_than",
+        "greater_than_or_equals",
+        "less_than",
+        "less_than_or_equals",
+        "contains",
+        "does_not_contain",
+    ]
+
+    value: Union[str, float, bool]
+    """Filter value - can be string, number, or boolean"""
+
+
+class ClausesNestedMeterFilterClausesLevel1FilterCondition(BaseModel):
+    key: str
+    """Filter key to apply"""
+
+    operator: Literal[
+        "equals",
+        "not_equals",
+        "greater_than",
+        "greater_than_or_equals",
+        "less_than",
+        "less_than_or_equals",
+        "contains",
+        "does_not_contain",
+    ]
+
+    value: Union[str, float, bool]
+    """Filter value - can be string, number, or boolean"""
+
+
+class ClausesNestedMeterFilterClausesLevel1NestedFilterClausesLevel2FilterCondition(BaseModel):
+    key: str
+    """Filter key to apply"""
+
+    operator: Literal[
+        "equals",
+        "not_equals",
+        "greater_than",
+        "greater_than_or_equals",
+        "less_than",
+        "less_than_or_equals",
+        "contains",
+        "does_not_contain",
+    ]
+
+    value: Union[str, float, bool]
+    """Filter value - can be string, number, or boolean"""
+
+
+class ClausesNestedMeterFilterClausesLevel1NestedFilterClausesLevel2NestedFilterClause(BaseModel):
+    key: str
+    """Filter key to apply"""
+
+    operator: Literal[
+        "equals",
+        "not_equals",
+        "greater_than",
+        "greater_than_or_equals",
+        "less_than",
+        "less_than_or_equals",
+        "contains",
+        "does_not_contain",
+    ]
+
+    value: Union[str, float, bool]
+    """Filter value - can be string, number, or boolean"""
+
+
+class ClausesNestedMeterFilterClausesLevel1NestedFilterClausesLevel2NestedFilter(BaseModel):
+    clauses: List[ClausesNestedMeterFilterClausesLevel1NestedFilterClausesLevel2NestedFilterClause]
+    """Level 3: Filter conditions only (max depth reached)"""
+
+    conjunction: Literal["and", "or"]
+
+
+class ClausesNestedMeterFilterClausesLevel1NestedFilter(BaseModel):
+    clauses: Union[
+        List[ClausesNestedMeterFilterClausesLevel1NestedFilterClausesLevel2FilterCondition],
+        List[ClausesNestedMeterFilterClausesLevel1NestedFilterClausesLevel2NestedFilter],
+    ]
+    """Level 2: Can be conditions or nested filters (1 more level allowed)"""
+
+    conjunction: Literal["and", "or"]
+
+
+class ClausesNestedMeterFilter(BaseModel):
+    clauses: Union[
+        List[ClausesNestedMeterFilterClausesLevel1FilterCondition],
+        List[ClausesNestedMeterFilterClausesLevel1NestedFilter],
+    ]
+    """Level 1: Can be conditions or nested filters (2 more levels allowed)"""
+
+    conjunction: Literal["and", "or"]
+
+
+class MeterFilter(BaseModel):
+    clauses: Union[List[ClausesDirectFilterCondition], List[ClausesNestedMeterFilter]]
+    """
+    Filter clauses - can be direct conditions or nested filters (up to 3 levels
+    deep)
+    """
+
+    conjunction: Literal["and", "or"]
+    """Logical conjunction to apply between clauses (and/or)"""

dodopayments/types/meter_filter_param.py

@@ -0,0 +1,143 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Iterable
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = [
+    "MeterFilterParam",
+    "ClausesDirectFilterCondition",
+    "ClausesNestedMeterFilter",
+    "ClausesNestedMeterFilterClausesLevel1FilterCondition",
+    "ClausesNestedMeterFilterClausesLevel1NestedFilter",
+    "ClausesNestedMeterFilterClausesLevel1NestedFilterClausesLevel2FilterCondition",
+    "ClausesNestedMeterFilterClausesLevel1NestedFilterClausesLevel2NestedFilter",
+    "ClausesNestedMeterFilterClausesLevel1NestedFilterClausesLevel2NestedFilterClause",
+]
+
+
+class ClausesDirectFilterCondition(TypedDict, total=False):
+    key: Required[str]
+    """Filter key to apply"""
+
+    operator: Required[
+        Literal[
+            "equals",
+            "not_equals",
+            "greater_than",
+            "greater_than_or_equals",
+            "less_than",
+            "less_than_or_equals",
+            "contains",
+            "does_not_contain",
+        ]
+    ]
+
+    value: Required[Union[str, float, bool]]
+    """Filter value - can be string, number, or boolean"""
+
+
+class ClausesNestedMeterFilterClausesLevel1FilterCondition(TypedDict, total=False):
+    key: Required[str]
+    """Filter key to apply"""
+
+    operator: Required[
+        Literal[
+            "equals",
+            "not_equals",
+            "greater_than",
+            "greater_than_or_equals",
+            "less_than",
+            "less_than_or_equals",
+            "contains",
+            "does_not_contain",
+        ]
+    ]
+
+    value: Required[Union[str, float, bool]]
+    """Filter value - can be string, number, or boolean"""
+
+
+class ClausesNestedMeterFilterClausesLevel1NestedFilterClausesLevel2FilterCondition(TypedDict, total=False):
+    key: Required[str]
+    """Filter key to apply"""
+
+    operator: Required[
+        Literal[
+            "equals",
+            "not_equals",
+            "greater_than",
+            "greater_than_or_equals",
+            "less_than",
+            "less_than_or_equals",
+            "contains",
+            "does_not_contain",
+        ]
+    ]
+
+    value: Required[Union[str, float, bool]]
+    """Filter value - can be string, number, or boolean"""
+
+
+class ClausesNestedMeterFilterClausesLevel1NestedFilterClausesLevel2NestedFilterClause(TypedDict, total=False):
+    key: Required[str]
+    """Filter key to apply"""
+
+    operator: Required[
+        Literal[
+            "equals",
+            "not_equals",
+            "greater_than",
+            "greater_than_or_equals",
+            "less_than",
+            "less_than_or_equals",
+            "contains",
+            "does_not_contain",
+        ]
+    ]
+
+    value: Required[Union[str, float, bool]]
+    """Filter value - can be string, number, or boolean"""
+
+
+class ClausesNestedMeterFilterClausesLevel1NestedFilterClausesLevel2NestedFilter(TypedDict, total=False):
+    clauses: Required[Iterable[ClausesNestedMeterFilterClausesLevel1NestedFilterClausesLevel2NestedFilterClause]]
+    """Level 3: Filter conditions only (max depth reached)"""
+
+    conjunction: Required[Literal["and", "or"]]
+
+
+class ClausesNestedMeterFilterClausesLevel1NestedFilter(TypedDict, total=False):
+    clauses: Required[
+        Union[
+            Iterable[ClausesNestedMeterFilterClausesLevel1NestedFilterClausesLevel2FilterCondition],
+            Iterable[ClausesNestedMeterFilterClausesLevel1NestedFilterClausesLevel2NestedFilter],
+        ]
+    ]
+    """Level 2: Can be conditions or nested filters (1 more level allowed)"""
+
+    conjunction: Required[Literal["and", "or"]]
+
+
+class ClausesNestedMeterFilter(TypedDict, total=False):
+    clauses: Required[
+        Union[
+            Iterable[ClausesNestedMeterFilterClausesLevel1FilterCondition],
+            Iterable[ClausesNestedMeterFilterClausesLevel1NestedFilter],
+        ]
+    ]
+    """Level 1: Can be conditions or nested filters (2 more levels allowed)"""
+
+    conjunction: Required[Literal["and", "or"]]
+
+
+class MeterFilterParam(TypedDict, total=False):
+    clauses: Required[Union[Iterable[ClausesDirectFilterCondition], Iterable[ClausesNestedMeterFilter]]]
+    """
+    Filter clauses - can be direct conditions or nested filters (up to 3 levels
+    deep)
+    """
+
+    conjunction: Required[Literal["and", "or"]]
+    """Logical conjunction to apply between clauses (and/or)"""

dodopayments/types/meter_list_params.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 TypedDict
+
+__all__ = ["MeterListParams"]
+
+
+class MeterListParams(TypedDict, total=False):
+    archived: bool
+    """List archived meters"""
+
+    page_number: int
+    """Page number default is 0"""
+
+    page_size: int
+    """Page size default is 10 max is 100"""

dodopayments/types/new_customer_param.py

@@ -10,7 +10,13 @@ __all__ = ["NewCustomerParam"]
 
 class NewCustomerParam(TypedDict, total=False):
     email: Required[str]
+    """Email is required for creating a new customer"""
 
-    name: Required[str]
+    name: Optional[str]
+    """Optional full name of the customer.
+
+    If provided during session creation, it is persisted and becomes immutable for
+    the session. If omitted here, it can be provided later via the confirm API.
+    """
 
     phone_number: Optional[str]

dodopayments/types/payment.py

@@ -3,16 +3,45 @@
 from typing import Dict, List, Optional
 from datetime import datetime
 
-from .refund import Refund
 from .dispute import Dispute
 from .._models import BaseModel
 from .currency import Currency
 from .country_code import CountryCode
 from .intent_status import IntentStatus
+from .refund_status import RefundStatus
 from .billing_address import BillingAddress
 from .customer_limited_details import CustomerLimitedDetails
 
-__all__ = ["Payment", "ProductCart"]
+__all__ = ["Payment", "Refund", "ProductCart"]
+
+
+class Refund(BaseModel):
+    business_id: str
+    """The unique identifier of the business issuing the refund."""
+
+    created_at: datetime
+    """The timestamp of when the refund was created in UTC."""
+
+    is_partial: bool
+    """If true the refund is a partial refund"""
+
+    payment_id: str
+    """The unique identifier of the payment associated with the refund."""
+
+    refund_id: str
+    """The unique identifier of the refund."""
+
+    status: RefundStatus
+    """The current status of the refund."""
+
+    amount: Optional[int] = None
+    """The refunded amount."""
+
+    currency: Optional[Currency] = None
+    """The currency of the refund, represented as an ISO 4217 currency code."""
+
+    reason: Optional[str] = None
+    """The reason provided for the refund, if any. Optional."""
 
 
 class ProductCart(BaseModel):
@@ -87,6 +116,12 @@ class Payment(BaseModel):
     card_type: Optional[str] = None
     """The type of card DEBIT or CREDIT"""
 
+    checkout_session_id: Optional[str] = None
+    """
+    If payment is made using a checkout session, this field is set to the id of the
+    session.
+    """
+
     discount_id: Optional[str] = None
     """The discount id if discount is applied"""
 

dodopayments/types/payment_cancelled_webhook_event.py

@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from .payment import Payment
+from .._models import BaseModel
+
+__all__ = ["PaymentCancelledWebhookEvent", "Data"]
+
+
+class Data(Payment):
+    payload_type: Optional[Literal["Payment"]] = None
+    """The type of payload in the data field"""
+
+
+class PaymentCancelledWebhookEvent(BaseModel):
+    business_id: str
+    """The business identifier"""
+
+    data: Data
+    """Event-specific data"""
+
+    timestamp: datetime
+    """The timestamp of when the event occurred"""
+
+    type: Literal["payment.cancelled"]
+    """The event type"""

dodopayments/types/payment_cancelled_webhook_event1.py

@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from .payment import Payment
+from .._models import BaseModel
+
+__all__ = ["PaymentCancelledWebhookEvent", "Data"]
+
+
+class Data(Payment):
+    payload_type: Optional[Literal["Payment"]] = None
+    """The type of payload in the data field"""
+
+
+class PaymentCancelledWebhookEvent(BaseModel):
+    business_id: str
+    """The business identifier"""
+
+    data: Data
+    """Event-specific data"""
+
+    timestamp: datetime
+    """The timestamp of when the event occurred"""
+
+    type: Literal["payment.cancelled"]
+    """The event type"""

dodopayments/types/payment_create_params.py

@@ -42,6 +42,9 @@ class PaymentCreateParams(TypedDict, total=False):
     discount_code: Optional[str]
     """Discount Code to apply to the transaction"""
 
+    force_3ds: Optional[bool]
+    """Override merchant default 3DS behaviour for this payment"""
+
     metadata: Dict[str, str]
     """
     Additional metadata associated with the payment. Defaults to empty if not

dodopayments/types/payment_failed_webhook_event.py

@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from .payment import Payment
+from .._models import BaseModel
+
+__all__ = ["PaymentFailedWebhookEvent", "Data"]
+
+
+class Data(Payment):
+    payload_type: Optional[Literal["Payment"]] = None
+    """The type of payload in the data field"""
+
+
+class PaymentFailedWebhookEvent(BaseModel):
+    business_id: str
+    """The business identifier"""
+
+    data: Data
+    """Event-specific data"""
+
+    timestamp: datetime
+    """The timestamp of when the event occurred"""
+
+    type: Literal["payment.failed"]
+    """The event type"""

dodopayments/types/payment_failed_webhook_event1.py

@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from .payment import Payment
+from .._models import BaseModel
+
+__all__ = ["PaymentFailedWebhookEvent", "Data"]
+
+
+class Data(Payment):
+    payload_type: Optional[Literal["Payment"]] = None
+    """The type of payload in the data field"""
+
+
+class PaymentFailedWebhookEvent(BaseModel):
+    business_id: str
+    """The business identifier"""
+
+    data: Data
+    """Event-specific data"""
+
+    timestamp: datetime
+    """The timestamp of when the event occurred"""
+
+    type: Literal["payment.failed"]
+    """The event type"""

dodopayments/types/payment_method_types.py

@@ -17,6 +17,7 @@ PaymentMethodTypes: TypeAlias = Literal[
     "eps",
     "ideal",
     "przelewy24",
+    "paypal",
     "affirm",
     "klarna",
     "sepa",

dodopayments/types/payment_processing_webhook_event.py

@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from .payment import Payment
+from .._models import BaseModel
+
+__all__ = ["PaymentProcessingWebhookEvent", "Data"]
+
+
+class Data(Payment):
+    payload_type: Optional[Literal["Payment"]] = None
+    """The type of payload in the data field"""
+
+
+class PaymentProcessingWebhookEvent(BaseModel):
+    business_id: str
+    """The business identifier"""
+
+    data: Data
+    """Event-specific data"""
+
+    timestamp: datetime
+    """The timestamp of when the event occurred"""
+
+    type: Literal["payment.processing"]
+    """The event type"""

dodopayments/types/payment_processing_webhook_event1.py

@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from .payment import Payment
+from .._models import BaseModel
+
+__all__ = ["PaymentProcessingWebhookEvent", "Data"]
+
+
+class Data(Payment):
+    payload_type: Optional[Literal["Payment"]] = None
+    """The type of payload in the data field"""
+
+
+class PaymentProcessingWebhookEvent(BaseModel):
+    business_id: str
+    """The business identifier"""
+
+    data: Data
+    """Event-specific data"""
+
+    timestamp: datetime
+    """The timestamp of when the event occurred"""
+
+    type: Literal["payment.processing"]
+    """The event type"""