dodopayments 1.51.0__py3-none-any.whl → 1.52.4__py3-none-any.whl

dodopayments/types/add_meter_to_price_param.py

@@ -0,0 +1,30 @@
+# 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__ = ["AddMeterToPriceParam"]
+
+
+class AddMeterToPriceParam(TypedDict, total=False):
+    meter_id: Required[str]
+
+    price_per_unit: Required[str]
+    """The price per unit in lowest denomination.
+
+    Must be greater than zero. Supports up to 5 digits before decimal point and 12
+    decimal places.
+    """
+
+    description: Optional[str]
+    """Meter description. Will ignored on Request, but will be shown in response"""
+
+    free_threshold: Optional[int]
+
+    measurement_unit: Optional[str]
+    """Meter measurement unit. Will ignored on Request, but will be shown in response"""
+
+    name: Optional[str]
+    """Meter name. Will ignored on Request, but will be shown in response"""

dodopayments/types/discount_create_params.py

@@ -2,10 +2,11 @@
 
 from __future__ import annotations
 
-from typing import List, Union, Optional
+from typing import Union, Optional
 from datetime import datetime
 from typing_extensions import Required, Annotated, TypedDict
 
+from .._types import SequenceNotStr
 from .._utils import PropertyInfo
 from .discount_type import DiscountType
 
@@ -39,7 +40,7 @@ class DiscountCreateParams(TypedDict, total=False):
 
     name: Optional[str]
 
-    restricted_to: Optional[List[str]]
+    restricted_to: Optional[SequenceNotStr[str]]
     """List of product IDs to restrict usage (if any)."""
 
     subscription_cycles: Optional[int]

dodopayments/types/discount_update_params.py

@@ -2,10 +2,11 @@
 
 from __future__ import annotations
 
-from typing import List, Union, Optional
+from typing import Union, Optional
 from datetime import datetime
 from typing_extensions import Annotated, TypedDict
 
+from .._types import SequenceNotStr
 from .._utils import PropertyInfo
 from .discount_type import DiscountType
 
@@ -30,7 +31,7 @@ class DiscountUpdateParams(TypedDict, total=False):
 
     name: Optional[str]
 
-    restricted_to: Optional[List[str]]
+    restricted_to: Optional[SequenceNotStr[str]]
     """
     If present, replaces all restricted product IDs with this new set. To remove all
     restrictions, send empty array

dodopayments/types/event.py

@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Union, Optional
+from datetime import datetime
+
+from .._models import BaseModel
+
+__all__ = ["Event"]
+
+
+class Event(BaseModel):
+    business_id: str
+
+    customer_id: str
+
+    event_id: str
+
+    event_name: str
+
+    timestamp: datetime
+
+    metadata: Optional[Dict[str, Union[str, float, bool]]] = None
+    """Arbitrary key-value metadata.
+
+    Values can be string, integer, number, or boolean.
+    """

dodopayments/types/event_input_param.py

@@ -0,0 +1,38 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union, Optional
+from datetime import datetime
+from typing_extensions import Required, Annotated, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["EventInputParam"]
+
+
+class EventInputParam(TypedDict, total=False):
+    customer_id: Required[str]
+    """customer_id of the customer whose usage needs to be tracked"""
+
+    event_id: Required[str]
+    """Event Id acts as an idempotency key.
+
+    Any subsequent requests with the same event_id will be ignored
+    """
+
+    event_name: Required[str]
+    """Name of the event"""
+
+    metadata: Optional[Dict[str, Union[str, float, bool]]]
+    """Custom metadata.
+
+    Only key value pairs are accepted, objects or arrays submitted will be rejected.
+    """
+
+    timestamp: Annotated[Union[str, datetime, None], PropertyInfo(format="iso8601")]
+    """Custom Timestamp.
+
+    Defaults to current timestamp in UTC. Timestamps that are older that 1 hour or
+    after 5 mins, from current timestamp, will be rejected.
+    """

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/payment.py

@@ -87,6 +87,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/price.py

@@ -1,20 +1,21 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from typing import Union, Optional
+from typing import List, Union, Optional
 from typing_extensions import Literal, TypeAlias
 
 from .._models import BaseModel
 from .currency import Currency
 from .time_interval import TimeInterval
+from .add_meter_to_price import AddMeterToPrice
 
-__all__ = ["Price", "OneTimePrice", "RecurringPrice"]
+__all__ = ["Price", "OneTimePrice", "RecurringPrice", "UsageBasedPrice"]
 
 
 class OneTimePrice(BaseModel):
     currency: Currency
     """The currency in which the payment is made."""
 
-    discount: float
+    discount: int
     """Discount applied to the price, represented as a percentage (0 to 100)."""
 
     price: int
@@ -55,7 +56,7 @@ class RecurringPrice(BaseModel):
     currency: Currency
     """The currency in which the payment is made."""
 
-    discount: float
+    discount: int
     """Discount applied to the price, represented as a percentage (0 to 100)."""
 
     payment_frequency_count: int
@@ -98,4 +99,50 @@ class RecurringPrice(BaseModel):
     """Number of days for the trial period. A value of `0` indicates no trial period."""
 
 
-Price: TypeAlias = Union[OneTimePrice, RecurringPrice]
+class UsageBasedPrice(BaseModel):
+    currency: Currency
+    """The currency in which the payment is made."""
+
+    discount: int
+    """Discount applied to the price, represented as a percentage (0 to 100)."""
+
+    fixed_price: int
+    """The fixed payment amount.
+
+    Represented in the lowest denomination of the currency (e.g., cents for USD).
+    For example, to charge $1.00, pass `100`.
+    """
+
+    payment_frequency_count: int
+    """
+    Number of units for the payment frequency. For example, a value of `1` with a
+    `payment_frequency_interval` of `month` represents monthly payments.
+    """
+
+    payment_frequency_interval: TimeInterval
+    """The time interval for the payment frequency (e.g., day, month, year)."""
+
+    purchasing_power_parity: bool
+    """
+    Indicates if purchasing power parity adjustments are applied to the price.
+    Purchasing power parity feature is not available as of now
+    """
+
+    subscription_period_count: int
+    """
+    Number of units for the subscription period. For example, a value of `12` with a
+    `subscription_period_interval` of `month` represents a one-year subscription.
+    """
+
+    subscription_period_interval: TimeInterval
+    """The time interval for the subscription period (e.g., day, month, year)."""
+
+    type: Literal["usage_based_price"]
+
+    meters: Optional[List[AddMeterToPrice]] = None
+
+    tax_inclusive: Optional[bool] = None
+    """Indicates if the price is tax inclusive"""
+
+
+Price: TypeAlias = Union[OneTimePrice, RecurringPrice, UsageBasedPrice]