paddle-python-sdk 0.1.0__py3-none-any.whl

paddle_billing/Entities/Shared/__init__.py

@@ -0,0 +1,56 @@
+from paddle_billing.Entities.Shared.Action                          import Action
+from paddle_billing.Entities.Shared.AddressPreview                  import AddressPreview
+from paddle_billing.Entities.Shared.AdjustmentItemTotals            import AdjustmentItemTotals
+from paddle_billing.Entities.Shared.AdjustmentProration             import AdjustmentProration
+from paddle_billing.Entities.Shared.AdjustmentStatus                import AdjustmentStatus
+from paddle_billing.Entities.Shared.AdjustmentTimePeriod            import AdjustmentTimePeriod
+from paddle_billing.Entities.Shared.AdjustmentTotals                import AdjustmentTotals
+from paddle_billing.Entities.Shared.AdjustmentType                  import AdjustmentType
+from paddle_billing.Entities.Shared.AvailablePaymentMethods         import AvailablePaymentMethods
+from paddle_billing.Entities.Shared.BillingDetails                  import BillingDetails
+from paddle_billing.Entities.Shared.BillingDetailsUpdate            import BillingDetailsUpdate
+from paddle_billing.Entities.Shared.Card                            import Card
+from paddle_billing.Entities.Shared.CatalogType                     import CatalogType
+from paddle_billing.Entities.Shared.ChargebackFee                   import ChargebackFee
+from paddle_billing.Entities.Shared.Checkout                        import Checkout
+from paddle_billing.Entities.Shared.CollectionMode                  import CollectionMode
+from paddle_billing.Entities.Shared.Contacts                        import Contacts
+from paddle_billing.Entities.Shared.CountryCode                     import CountryCode
+from paddle_billing.Entities.Shared.CurrencyCode                    import CurrencyCode
+from paddle_billing.Entities.Shared.CurrencyCodeAdjustments         import CurrencyCodeAdjustments
+from paddle_billing.Entities.Shared.CurrencyCodePayouts             import CurrencyCodePayouts
+from paddle_billing.Entities.Shared.CustomData                      import CustomData
+from paddle_billing.Entities.Shared.Data                            import Data
+from paddle_billing.Entities.Shared.ErrorCode                       import ErrorCode
+from paddle_billing.Entities.Shared.ImportMeta                      import ImportMeta
+from paddle_billing.Entities.Shared.Interval                        import Interval
+from paddle_billing.Entities.Shared.Meta                            import Meta
+from paddle_billing.Entities.Shared.MetaPaginated                   import MetaPaginated
+from paddle_billing.Entities.Shared.MethodDetails                   import MethodDetails
+from paddle_billing.Entities.Shared.Money                           import Money
+from paddle_billing.Entities.Shared.Original                        import Original
+from paddle_billing.Entities.Shared.Pagination                      import Pagination
+from paddle_billing.Entities.Shared.PaymentAttemptStatus            import PaymentAttemptStatus
+from paddle_billing.Entities.Shared.PaymentMethodType               import PaymentMethodType
+from paddle_billing.Entities.Shared.PayoutTotalsAdjustment          import PayoutTotalsAdjustment
+from paddle_billing.Entities.Shared.PriceQuantity                   import PriceQuantity
+from paddle_billing.Entities.Shared.Status                          import Status
+from paddle_billing.Entities.Shared.TransactionStatus               import TransactionStatus
+from paddle_billing.Entities.Shared.TaxCategory                     import TaxCategory
+from paddle_billing.Entities.Shared.TaxMode                         import TaxMode
+from paddle_billing.Entities.Shared.TaxRatesUsed                    import TaxRatesUsed
+from paddle_billing.Entities.Shared.TimePeriod                      import TimePeriod
+from paddle_billing.Entities.Shared.Totals                          import Totals
+from paddle_billing.Entities.Shared.TransactionOrigin               import TransactionOrigin
+from paddle_billing.Entities.Shared.TransactionPaymentAttempt       import TransactionPaymentAttempt
+from paddle_billing.Entities.Shared.TransactionPayoutTotals         import TransactionPayoutTotals
+from paddle_billing.Entities.Shared.TransactionPayoutTotalsAdjusted import TransactionPayoutTotalsAdjusted
+from paddle_billing.Entities.Shared.TransactionTotals               import TransactionTotals
+from paddle_billing.Entities.Shared.TransactionTotalsAdjusted       import TransactionTotalsAdjusted
+from paddle_billing.Entities.Shared.UnitPriceOverride               import UnitPriceOverride
+from paddle_billing.Entities.Shared.UnitTotals                      import UnitTotals
+
+
+# These two cause circular imports
+# from paddle_billing.Entities.Shared.TransactionDetailsPreview  import TransactionDetailsPreview
+# from paddle_billing.Entities.Shared.TransactionLineItemPreview import TransactionLineItemPreview

paddle_billing/Entities/Subscription.py

@@ -0,0 +1,86 @@
+from __future__  import annotations
+from dataclasses import dataclass
+from datetime    import datetime
+
+from paddle_billing.Entities.Entity import Entity
+
+from paddle_billing.Entities.Shared.TransactionDetailsPreview import TransactionDetailsPreview
+from paddle_billing.Entities.Shared import (
+    BillingDetails,
+    CollectionMode,
+    CurrencyCode,
+    CustomData,
+    ImportMeta,
+    TimePeriod,
+)
+
+from paddle_billing.Entities.Subscriptions import (
+    SubscriptionDiscount,
+    SubscriptionItem,
+    SubscriptionManagementUrls,
+    SubscriptionNextTransaction,
+    SubscriptionScheduledChange,
+    SubscriptionStatus,
+    SubscriptionTimePeriod,
+)
+
+
+@dataclass
+class Subscription(Entity):
+    id:                            str
+    status:                        SubscriptionStatus
+    customer_id:                   str
+    address_id:                    str
+    business_id:                   str | None
+    currency_code:                 CurrencyCode
+    created_at:                    datetime
+    updated_at:                    datetime
+    started_at:                    datetime             | None
+    first_billed_at:               datetime             | None
+    next_billed_at:                datetime             | None
+    paused_at:                     datetime             | None
+    canceled_at:                   datetime             | None
+    discount:                      SubscriptionDiscount | None
+    collection_mode:               CollectionMode
+    billing_details:               BillingDetails         | None
+    current_billing_period:        SubscriptionTimePeriod | None
+    billing_cycle:                 TimePeriod
+    scheduled_change:              SubscriptionScheduledChange | None
+    management_urls:               SubscriptionManagementUrls  | None
+    items:                         list[SubscriptionItem]
+    next_transaction:              SubscriptionNextTransaction | None
+    recurring_transaction_details: TransactionDetailsPreview   | None
+    import_meta:                   ImportMeta                  | None = None
+    custom_data:                   CustomData                  | None = None
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Subscription:
+        return Subscription(
+            id                     = data['id'],
+            status                 = SubscriptionStatus(data['status']),
+            customer_id            = data['customer_id'],
+            address_id             = data['address_id'],
+            business_id            = data.get('business_id'),
+            currency_code          = CurrencyCode(data['currency_code']),
+            created_at             = datetime.fromisoformat(data['created_at']),
+            updated_at             = datetime.fromisoformat(data['updated_at']),
+            collection_mode        = CollectionMode(data['collection_mode']),
+            billing_cycle          = TimePeriod.from_dict(data['billing_cycle']),
+            items                  = [SubscriptionItem.from_dict(item) for item in data['items']],
+            current_billing_period = SubscriptionTimePeriod.from_dict(data['current_billing_period']) if data.get('current_billing_period') else None,
+            management_urls        = SubscriptionManagementUrls.from_dict(data['management_urls'])    if data.get('management_urls')        else None,
+            started_at             = datetime.fromisoformat(data['started_at'])                       if data.get('started_at')             else None,
+            first_billed_at        = datetime.fromisoformat(data['first_billed_at'])                  if data.get('first_billed_at')        else None,
+            next_billed_at         = datetime.fromisoformat(data['next_billed_at'])                   if data.get('next_billed_at')         else None,
+            paused_at              = datetime.fromisoformat(data['paused_at'])                        if data.get('paused_at')              else None,
+            canceled_at            = datetime.fromisoformat(data['canceled_at'])                      if data.get('canceled_at')            else None,
+            discount               = SubscriptionDiscount.from_dict(data['discount'])                 if data.get('discount')               else None,
+            billing_details        = BillingDetails.from_dict(data['billing_details'])                if data.get('billing_details')        else None,
+            scheduled_change       = SubscriptionScheduledChange.from_dict(data['scheduled_change'])  if data.get('scheduled_change')       else None,
+            custom_data            = CustomData(data['custom_data'])                                  if data.get('custom_data')            else None,
+            import_meta            = ImportMeta.from_dict(data['import_meta'])                        if data.get('import_meta')            else None,
+            next_transaction       = SubscriptionNextTransaction.from_dict(data['next_transaction'])  if data.get('next_transaction')       else None,
+
+            recurring_transaction_details = TransactionDetailsPreview.from_dict(data['recurring_transaction_details']) if data.get('recurring_transaction_details') else None,
+        )

paddle_billing/Entities/SubscriptionPreview.py

@@ -0,0 +1,79 @@
+from __future__  import annotations
+from dataclasses import dataclass
+from datetime    import datetime
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Shared import BillingDetails, CollectionMode, CurrencyCode, CustomData, TimePeriod
+
+from paddle_billing.Entities.Shared.TransactionDetailsPreview import TransactionDetailsPreview
+
+from paddle_billing.Entities.Subscriptions import (
+    SubscriptionDiscount,
+    SubscriptionItem,
+    SubscriptionManagementUrls,
+    SubscriptionNextTransaction,
+    SubscriptionPreviewSubscriptionUpdateSummary,
+    SubscriptionScheduledChange,
+    SubscriptionStatus,
+    SubscriptionTimePeriod,
+)
+
+
+@dataclass
+class SubscriptionPreview(Entity):
+    status:                        SubscriptionStatus
+    customer_id:                   str
+    address_id:                    str
+    business_id:                   str | None
+    currency_code:                 CurrencyCode
+    created_at:                    datetime
+    updated_at:                    datetime
+    started_at:                    datetime | None
+    first_billed_at:               datetime | None
+    next_billed_at:                datetime | None
+    paused_at:                     datetime | None
+    canceled_at:                   datetime | None
+    discount:                      SubscriptionDiscount | None
+    collection_mode:               CollectionMode
+    billing_details:               BillingDetails | None
+    current_billing_period:        SubscriptionTimePeriod | None
+    billing_cycle:                 TimePeriod
+    scheduled_change:              SubscriptionScheduledChange | None
+    management_urls:               SubscriptionManagementUrls
+    items:                         list[SubscriptionItem]
+    custom_data:                   CustomData | None
+    immediate_transaction:         SubscriptionNextTransaction | None
+    next_transaction:              SubscriptionNextTransaction | None
+    recurring_transaction_details: TransactionDetailsPreview   | None
+    update_summary:                SubscriptionPreviewSubscriptionUpdateSummary | None
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> SubscriptionPreview:
+        return SubscriptionPreview(
+            status                        = SubscriptionStatus(data['status']),
+            customer_id                   = data['customer_id'],
+            address_id                    = data['address_id'],
+            business_id                   = data.get('business_id'),
+            currency_code                 = CurrencyCode(data['currency_code']),
+            created_at                    = datetime.fromisoformat(data['created_at']),
+            updated_at                    = datetime.fromisoformat(data['updated_at']),
+            collection_mode               = CollectionMode(data['collection_mode']),
+            billing_cycle                 = TimePeriod.from_dict(data['billing_cycle']),
+            items                         = [SubscriptionItem.from_dict(item) for item in data['items']],
+            started_at                    = datetime.fromisoformat(data['started_at'])                                     if data.get('started_at')                    else None,
+            first_billed_at               = datetime.fromisoformat(data['first_billed_at'])                                if data.get('first_billed_at')               else None,
+            next_billed_at                = datetime.fromisoformat(data['next_billed_at'])                                 if data.get('next_billed_at')                else None,
+            paused_at                     = datetime.fromisoformat(data['paused_at'])                                      if data.get('paused_at')                     else None,
+            canceled_at                   = datetime.fromisoformat(data['canceled_at'])                                    if data.get('canceled_at')                   else None,
+            discount                      = SubscriptionDiscount.from_dict(data['discount'])                               if data.get('discount')                      else None,
+            billing_details               = BillingDetails.from_dict(data['billing_details'])                              if data.get('billing_details')               else None,
+            current_billing_period        = SubscriptionTimePeriod.from_dict(data['current_billing_period'])               if data.get('current_billing_period')        else None,
+            scheduled_change              = SubscriptionScheduledChange.from_dict(data['scheduled_change'])                if data.get('scheduled_change')              else None,
+            management_urls               = SubscriptionManagementUrls.from_dict(data['management_urls'])                  if data.get('management_urls')               else None,
+            custom_data                   = CustomData(data['custom_data'])                                                if data.get('custom_data')                   else None,
+            immediate_transaction         = SubscriptionNextTransaction.from_dict(data['immediate_transaction'])           if data.get('immediate_transaction')         else None,
+            next_transaction              = SubscriptionNextTransaction.from_dict(data['next_transaction'])                if data.get('next_transaction')              else None,
+            recurring_transaction_details = TransactionDetailsPreview.from_dict(data['recurring_transaction_details'])     if data.get('recurring_transaction_details') else None,
+            update_summary                = SubscriptionPreviewSubscriptionUpdateSummary.from_dict(data['update_summary']) if data.get('update_summary')                else None,
+        )

paddle_billing/Entities/Subscriptions/SubscriptionAdjustmentItem.py

@@ -0,0 +1,24 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared import AdjustmentItemTotals, AdjustmentProration, AdjustmentType
+
+
+@dataclass
+class SubscriptionAdjustmentItem:
+    item_id:   str
+    type:      AdjustmentType
+    amount:    str | None
+    proration: AdjustmentProration
+    totals:    AdjustmentItemTotals
+
+
+    @staticmethod
+    def from_dict(data: dict) -> SubscriptionAdjustmentItem:
+        return SubscriptionAdjustmentItem(
+            item_id   = data['item_id'],
+            type      = AdjustmentType(data['type']),
+            amount    = data.get('amount'),
+            proration = AdjustmentProration.from_dict(data['proration']),
+            totals    = AdjustmentItemTotals.from_dict(data['totals']),
+        )

paddle_billing/Entities/Subscriptions/SubscriptionAdjustmentPreview.py

@@ -0,0 +1,22 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared import AdjustmentTotals
+
+from paddle_billing.Entities.Subscriptions.SubscriptionAdjustmentItem import SubscriptionAdjustmentItem
+
+
+@dataclass
+class SubscriptionAdjustmentPreview:
+    transaction_id: str
+    items:          list[SubscriptionAdjustmentItem]
+    totals:         AdjustmentTotals
+
+
+    @staticmethod
+    def from_dict(data: dict) -> SubscriptionAdjustmentPreview:
+        return SubscriptionAdjustmentPreview(
+            transaction_id = data['transaction_id'],
+            items          = [SubscriptionAdjustmentItem.from_dict(item) for item in data['items']],
+            totals         = AdjustmentTotals.from_dict(data['totals']),
+        )

paddle_billing/Entities/Subscriptions/SubscriptionCharge.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared import CurrencyCode
+
+
+@dataclass
+class SubscriptionCharge:
+    amount:        str
+    currency_code: CurrencyCode
+
+
+    @staticmethod
+    def from_dict(data: dict) -> SubscriptionCharge:
+        return SubscriptionCharge(
+            amount        = data['amount'],
+            currency_code = CurrencyCode(data['currency_code']),
+        )

paddle_billing/Entities/Subscriptions/SubscriptionCredit.py

@@ -0,0 +1,18 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared import CurrencyCode
+
+
+@dataclass
+class SubscriptionCredit:
+    amount:        str
+    currency_code: CurrencyCode
+
+
+    @staticmethod
+    def from_dict(data: dict) -> SubscriptionCredit:
+        return SubscriptionCredit(
+            amount        = data['amount'],
+            currency_code = CurrencyCode(data['currency_code']),
+        )

paddle_billing/Entities/Subscriptions/SubscriptionDetails.py

@@ -0,0 +1,34 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared import (
+    TaxRatesUsed,
+    TransactionPayoutTotals,
+    TransactionPayoutTotalsAdjusted,
+    TransactionTotals,
+    TransactionTotalsAdjusted
+)
+
+from paddle_billing.Entities.Subscriptions import SubscriptionTransactionLineItem
+
+
+@dataclass
+class SubscriptionDetails:
+    tax_rates_used:         list[TaxRatesUsed]
+    totals:                 TransactionTotals
+    adjusted_totals:        TransactionTotalsAdjusted
+    payout_totals:          TransactionPayoutTotals
+    adjusted_payout_totals: TransactionPayoutTotalsAdjusted
+    line_items:             list[SubscriptionTransactionLineItem]
+
+
+    @staticmethod
+    def from_dict(data: dict) -> SubscriptionDetails:
+        return SubscriptionDetails(
+            totals                 = TransactionTotals.from_dict(data['totals']),
+            adjusted_totals        = TransactionTotalsAdjusted.from_dict(data['adjusted_totals']),
+            payout_totals          = TransactionPayoutTotals.from_dict(data['payout_totals']),
+            adjusted_payout_totals = TransactionPayoutTotalsAdjusted.from_dict(data['adjusted_payout_totals']),
+            tax_rates_used         = [TaxRatesUsed.from_dict(tax_rate)                for tax_rate in data.get('tax_rates_used', [])],
+            line_items             = [SubscriptionTransactionLineItem.from_dict(item) for item     in data.get('line_items',     [])],
+        )

paddle_billing/Entities/Subscriptions/SubscriptionDiscount.py

@@ -0,0 +1,19 @@
+from __future__  import annotations
+from dataclasses import dataclass
+from datetime    import datetime
+
+
+@dataclass
+class SubscriptionDiscount:
+    id:        str
+    starts_at: datetime
+    ends_at:   datetime
+
+
+    @staticmethod
+    def from_dict(data: dict) -> SubscriptionDiscount:
+        return SubscriptionDiscount(
+            id        = data['id'],
+            starts_at = datetime.fromisoformat(data['starts_at']),
+            ends_at   = datetime.fromisoformat(data['ends_at']) if data.get('ends_at') else None,
+        )

paddle_billing/Entities/Subscriptions/SubscriptionEffectiveFrom.py

@@ -0,0 +1,6 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class SubscriptionEffectiveFrom(PaddleStrEnum):
+    NextBillingPeriod = 'next_billing_period'
+    Immediately       = 'immediately'

paddle_billing/Entities/Subscriptions/SubscriptionItem.py

@@ -0,0 +1,35 @@
+from __future__  import annotations
+from dataclasses import dataclass
+from datetime    import datetime
+
+from paddle_billing.Entities.Subscriptions.SubscriptionItemStatus import SubscriptionItemStatus
+from paddle_billing.Entities.Subscriptions.SubscriptionPrice      import SubscriptionPrice
+from paddle_billing.Entities.Subscriptions.SubscriptionTimePeriod import SubscriptionTimePeriod
+
+
+@dataclass
+class SubscriptionItem:
+    status:               SubscriptionItemStatus
+    quantity:             int
+    recurring:            bool
+    created_at:           datetime
+    updated_at:           datetime
+    previously_billed_at: datetime | None
+    next_billed_at:       datetime | None
+    trial_dates:          SubscriptionTimePeriod | None
+    price:                SubscriptionPrice
+
+
+    @staticmethod
+    def from_dict(data: dict) -> SubscriptionItem:
+        return SubscriptionItem(
+            status               = SubscriptionItemStatus(data['status']),
+            quantity             = data['quantity'],
+            recurring            = data['recurring'],
+            created_at           = datetime.fromisoformat(data['created_at']),
+            updated_at           = datetime.fromisoformat(data['updated_at']),
+            price                = SubscriptionPrice.from_dict(data['price']),
+            previously_billed_at = datetime.fromisoformat(data['previously_billed_at'])  if data.get('previously_billed_at') else None,
+            next_billed_at       = datetime.fromisoformat(data['next_billed_at'])        if data.get('next_billed_at')       else None,
+            trial_dates          = SubscriptionTimePeriod.from_dict(data['trial_dates']) if data.get('trial_dates')          else None,
+        )

paddle_billing/Entities/Subscriptions/SubscriptionItemStatus.py

@@ -0,0 +1,7 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class SubscriptionItemStatus(PaddleStrEnum):
+    Active   = 'active'
+    Inactive = 'inactive'
+    Trialing = 'trialing'

paddle_billing/Entities/Subscriptions/SubscriptionItems.py

@@ -0,0 +1,20 @@
+from __future__  import annotations
+from dataclasses import asdict, dataclass
+
+
+@dataclass
+class SubscriptionItems:
+    price_id: str
+    quantity: int
+
+
+    @staticmethod
+    def from_dict(data: dict) -> SubscriptionItems:
+        return SubscriptionItems(
+            price_id = data['price_id'],
+            quantity = data['quantity'],
+        )
+
+
+    def get_parameters(self) -> dict:
+        return asdict(self)

paddle_billing/Entities/Subscriptions/SubscriptionItemsWithPrice.py

@@ -0,0 +1,19 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Subscriptions.SubscriptionNonCatalogPrice            import SubscriptionNonCatalogPrice
+from paddle_billing.Entities.Subscriptions.SubscriptionNonCatalogPriceWithProduct import SubscriptionNonCatalogPriceWithProduct
+
+
+@dataclass
+class SubscriptionItemsWithPrice:
+    price:    SubscriptionNonCatalogPrice | SubscriptionNonCatalogPriceWithProduct
+    quantity: int
+
+
+    @staticmethod
+    def from_dict(data: dict) -> SubscriptionItemsWithPrice:
+        return SubscriptionItemsWithPrice(
+            price    = data['price'],
+            quantity = data['quantity'],
+        )

paddle_billing/Entities/Subscriptions/SubscriptionManagementUrls.py

@@ -0,0 +1,16 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+
+@dataclass
+class SubscriptionManagementUrls:
+    update_payment_method: str | None
+    cancel:                str
+
+
+    @staticmethod
+    def from_dict(data: dict) -> SubscriptionManagementUrls:
+        return SubscriptionManagementUrls(
+            update_payment_method = data.get('update_payment_method'),
+            cancel                = data['cancel'],
+        )

paddle_billing/Entities/Subscriptions/SubscriptionNextTransaction.py

@@ -0,0 +1,23 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared.TransactionDetailsPreview import TransactionDetailsPreview
+
+from paddle_billing.Entities.Subscriptions.SubscriptionTimePeriod        import SubscriptionTimePeriod
+from paddle_billing.Entities.Subscriptions.SubscriptionAdjustmentPreview import SubscriptionAdjustmentPreview
+
+
+@dataclass
+class SubscriptionNextTransaction:
+    billing_period: SubscriptionTimePeriod
+    details:        TransactionDetailsPreview
+    adjustments:    list[SubscriptionAdjustmentPreview]
+
+
+    @staticmethod
+    def from_dict(data: dict) -> SubscriptionNextTransaction:
+        return SubscriptionNextTransaction(
+            billing_period = SubscriptionTimePeriod.from_dict(data['billing_period']),
+            details        = TransactionDetailsPreview.from_dict(data['details']),
+            adjustments    = [SubscriptionAdjustmentPreview.from_dict(adj) for adj in data.get('adjustments', [])],
+        )

paddle_billing/Entities/Subscriptions/SubscriptionNonCatalogPrice.py

@@ -0,0 +1,30 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared import CustomData, Money, PriceQuantity, TaxMode, UnitPriceOverride
+
+
+@dataclass
+class SubscriptionNonCatalogPrice:
+    description:          str
+    name:                 str | None
+    product_id:           str
+    tax_mode:             TaxMode
+    unit_price:           Money
+    unit_price_overrides: list[UnitPriceOverride]
+    quantity:             PriceQuantity
+    custom_data:          CustomData | None
+
+
+    @staticmethod
+    def from_dict(data: dict) -> SubscriptionNonCatalogPrice:
+        return SubscriptionNonCatalogPrice(
+            description          = data['description'],
+            name                 = data.get('name'),
+            product_id           = data['product_id'],
+            tax_mode             = TaxMode(data['tax_mode']),
+            unit_price           = Money.from_dict(data['unit_price']),
+            unit_price_overrides = [UnitPriceOverride.from_dict(override) for override in data['unit_price_overrides']],
+            quantity             = PriceQuantity.from_dict(data['quantity']),
+            custom_data          = CustomData(data['custom_data']) if data.get('custom_data') else None,
+        )

paddle_billing/Entities/Subscriptions/SubscriptionNonCatalogPriceWithProduct.py

@@ -0,0 +1,32 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared import CustomData, Money, PriceQuantity, TaxMode, UnitPriceOverride
+
+from paddle_billing.Entities.Subscriptions.SubscriptionNonCatalogProduct import SubscriptionNonCatalogProduct
+
+
+@dataclass
+class SubscriptionNonCatalogPriceWithProduct:
+    description:          str
+    name:                 str | None
+    product:              SubscriptionNonCatalogProduct
+    tax_mode:             TaxMode
+    unit_price:           Money
+    unit_price_overrides: list[UnitPriceOverride]
+    quantity:             PriceQuantity
+    custom_data:          CustomData | None
+
+
+    @staticmethod
+    def from_dict(data: dict) -> SubscriptionNonCatalogPriceWithProduct:
+        return SubscriptionNonCatalogPriceWithProduct(
+            description          = data['description'],
+            name                 = data.get('name'),
+            product              = SubscriptionNonCatalogProduct.from_dict(data['product']),
+            tax_mode             = TaxMode(data['tax_mode']),
+            unit_price           = Money.from_dict(data['unit_price']),
+            unit_price_overrides = [UnitPriceOverride.from_dict(override) for override in data['unit_price_overrides']],
+            quantity             = PriceQuantity.from_dict(data['quantity']),
+            custom_data          = CustomData(data['custom_data']) if data.get('custom_data') else None,
+        )

paddle_billing/Entities/Subscriptions/SubscriptionNonCatalogProduct.py

@@ -0,0 +1,26 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared import CatalogType, CustomData, TaxCategory
+
+
+@dataclass
+class SubscriptionNonCatalogProduct:
+    name:         str
+    description:  str         | None
+    type:         CatalogType | None
+    tax_category: TaxCategory
+    image_url:    str        | None
+    custom_data:  CustomData | None
+
+
+    @staticmethod
+    def from_dict(data: dict) -> SubscriptionNonCatalogProduct:
+        return SubscriptionNonCatalogProduct(
+            name         = data['name'],
+            description  = data.get('description'),
+            tax_category = TaxCategory(data['tax_category']),
+            image_url    = data.get('image_url'),
+            type         = CatalogType(data['type'])       if data.get('type')        else None,
+            custom_data  = CustomData(data['custom_data']) if data.get('custom_data') else None,
+        )

paddle_billing/Entities/Subscriptions/SubscriptionOnPaymentFailure.py

@@ -0,0 +1,6 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class SubscriptionOnPaymentFailure(PaddleStrEnum):
+    PreventChange = 'prevent_change'
+    ApplyChange   = 'apply_change'

paddle_billing/Entities/Subscriptions/SubscriptionPreviewSubscriptionUpdateSummary.py

@@ -0,0 +1,22 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Subscriptions.SubscriptionCharge import SubscriptionCharge
+from paddle_billing.Entities.Subscriptions.SubscriptionCredit import SubscriptionCredit
+from paddle_billing.Entities.Subscriptions.SubscriptionResult import SubscriptionResult
+
+
+@dataclass
+class SubscriptionPreviewSubscriptionUpdateSummary:
+    credit: SubscriptionCredit
+    charge: SubscriptionCharge
+    result: SubscriptionResult
+
+
+    @staticmethod
+    def from_dict(data: dict) -> SubscriptionPreviewSubscriptionUpdateSummary:
+        return SubscriptionPreviewSubscriptionUpdateSummary(
+            credit = SubscriptionCredit.from_dict(data['credit']),
+            charge = SubscriptionCharge.from_dict(data['charge']),
+            result = SubscriptionResult.from_dict(data['result']),
+        )