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

paddle_billing/Entities/Subscriptions/SubscriptionPrice.py

@@ -0,0 +1,28 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared import Money, TaxMode, TimePeriod
+
+
+@dataclass
+class SubscriptionPrice:
+    id:            str
+    description:   str
+    product_id:    str
+    billing_cycle: TimePeriod | None
+    trial_period:  TimePeriod | None
+    tax_mode:      TaxMode
+    unit_price:    Money
+
+
+    @staticmethod
+    def from_dict(data: dict) -> SubscriptionPrice:
+        return SubscriptionPrice(
+            id            = data['id'],
+            description   = data['description'],
+            product_id    = data['product_id'],
+            tax_mode      = TaxMode(data['tax_mode']),
+            unit_price    = Money.from_dict(data['unit_price']),
+            billing_cycle = TimePeriod.from_dict(data['billing_cycle']) if data.get('billing_cycle') else None,
+            trial_period  = TimePeriod.from_dict(data['trial_period'])  if data.get('trial_period')  else None,
+        )

paddle_billing/Entities/Subscriptions/SubscriptionProration.py

@@ -0,0 +1,18 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Subscriptions.SubscriptionTimePeriod import SubscriptionTimePeriod
+
+
+@dataclass
+class SubscriptionProration:
+    rate:           str
+    billing_period: SubscriptionTimePeriod
+
+
+    @staticmethod
+    def from_dict(data: dict) -> SubscriptionProration:
+        return SubscriptionProration(
+            rate           = data['rate'],
+            billing_period = SubscriptionTimePeriod.from_dict(data['billing_period']),
+        )

paddle_billing/Entities/Subscriptions/SubscriptionProrationBillingMode.py

@@ -0,0 +1,9 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class SubscriptionProrationBillingMode(PaddleStrEnum):
+    ProratedImmediately       = 'prorated_immediately'
+    ProratedNextBillingPeriod = 'prorated_next_billing_period'
+    FullImmediately           = 'full_immediately'
+    FullNextBillingPeriod     = 'full_next_billing_period'
+    DoNotBill                 = 'do_not_bill'

paddle_billing/Entities/Subscriptions/SubscriptionResult.py

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

paddle_billing/Entities/Subscriptions/SubscriptionResultAction.py

@@ -0,0 +1,6 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class SubscriptionResultAction(PaddleStrEnum):
+    Credit = 'credit'
+    Charge = 'charge'

paddle_billing/Entities/Subscriptions/SubscriptionResumeEffectiveFrom.py

@@ -0,0 +1,5 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class SubscriptionResumeEffectiveFrom(PaddleStrEnum):
+    Immediately       = 'immediately'

paddle_billing/Entities/Subscriptions/SubscriptionScheduledChange.py

@@ -0,0 +1,21 @@
+from __future__  import annotations
+from dataclasses import dataclass
+from datetime    import datetime
+
+from paddle_billing.Entities.Subscriptions.SubscriptionScheduledChangeAction import SubscriptionScheduledChangeAction
+
+
+@dataclass
+class SubscriptionScheduledChange:
+    action:       SubscriptionScheduledChangeAction
+    effective_at: datetime
+    resume_at:    datetime | None
+
+
+    @staticmethod
+    def from_dict(data: dict) -> SubscriptionScheduledChange:
+        return SubscriptionScheduledChange(
+            action       = SubscriptionScheduledChangeAction(data['action']),
+            effective_at = datetime.fromisoformat(data['effective_at']),
+            resume_at    = datetime.fromisoformat(data['resume_at']) if data.get('resume_at') else None,
+        )

paddle_billing/Entities/Subscriptions/SubscriptionScheduledChangeAction.py

@@ -0,0 +1,7 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class SubscriptionScheduledChangeAction(PaddleStrEnum):
+    Cancel = 'cancel'
+    Pause  = 'pause'
+    Resume = 'resume'

paddle_billing/Entities/Subscriptions/SubscriptionStatus.py

@@ -0,0 +1,10 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class SubscriptionStatus(PaddleStrEnum):
+    Active   = 'active'
+    Canceled = 'canceled'
+    PastDue  = 'past_due'
+    Paused   = 'paused'
+    Trialing = 'trialing'
+    Inactive = 'inactive'

paddle_billing/Entities/Subscriptions/SubscriptionTimePeriod.py

@@ -0,0 +1,17 @@
+from __future__  import annotations
+from dataclasses import dataclass
+from datetime    import datetime
+
+
+@dataclass
+class SubscriptionTimePeriod:
+    starts_at: datetime
+    ends_at:   datetime
+
+
+    @staticmethod
+    def from_dict(data: dict) -> SubscriptionTimePeriod:
+        return SubscriptionTimePeriod(
+            starts_at = datetime.fromisoformat(data['starts_at']),
+            ends_at   = datetime.fromisoformat(data['ends_at']),
+        )

paddle_billing/Entities/Subscriptions/SubscriptionTransactionItem.py

@@ -0,0 +1,23 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Price                               import Price
+from paddle_billing.Entities.Subscriptions.SubscriptionProration import SubscriptionProration
+
+
+@dataclass
+class SubscriptionTransactionItem:
+    price_id:  str
+    price:     Price
+    quantity:  int
+    proration: SubscriptionProration
+
+
+    @staticmethod
+    def from_dict(data: dict) -> SubscriptionTransactionItem:
+        return SubscriptionTransactionItem(
+            price_id  = data['price_id'],
+            price     = Price.from_dict(data['price']),
+            quantity  = data['quantity'],
+            proration = SubscriptionProration.from_dict(data['proration']),
+        )

paddle_billing/Entities/Subscriptions/SubscriptionTransactionLineItem.py

@@ -0,0 +1,33 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Product import Product
+from paddle_billing.Entities.Shared  import Totals, UnitTotals
+
+from paddle_billing.Entities.Subscriptions.SubscriptionProration import SubscriptionProration
+
+
+@dataclass
+class SubscriptionTransactionLineItem:
+    id:          str
+    price_id:    str
+    quantity:    int
+    proration:   SubscriptionProration
+    tax_rate:    str
+    unit_totals: UnitTotals
+    totals:      Totals
+    product:     Product
+
+
+    @staticmethod
+    def from_dict(data: dict) -> SubscriptionTransactionLineItem:
+        return SubscriptionTransactionLineItem(
+            id          = data['id'],
+            price_id    = data['price_id'],
+            quantity    = data['quantity'],
+            proration   = SubscriptionProration.from_dict(data['proration']),
+            tax_rate    = data['tax_rate'],
+            unit_totals = UnitTotals.from_dict(data['unit_totals']),
+            totals      = Totals.from_dict(data['totals']),
+            product     = Product.from_dict(data['product']),
+        )

paddle_billing/Entities/Subscriptions/SubscriptionUpdateItem.py

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

paddle_billing/Entities/Subscriptions/__init__.py

@@ -0,0 +1,31 @@
+from paddle_billing.Entities.Subscriptions.SubscriptionAdjustmentItem                   import SubscriptionAdjustmentItem
+from paddle_billing.Entities.Subscriptions.SubscriptionAdjustmentPreview                import SubscriptionAdjustmentPreview
+from paddle_billing.Entities.Subscriptions.SubscriptionCharge                           import SubscriptionCharge
+from paddle_billing.Entities.Subscriptions.SubscriptionCredit                           import SubscriptionCredit
+from paddle_billing.Entities.Subscriptions.SubscriptionDetails                          import SubscriptionDetails
+from paddle_billing.Entities.Subscriptions.SubscriptionDiscount                         import SubscriptionDiscount
+from paddle_billing.Entities.Subscriptions.SubscriptionEffectiveFrom                    import SubscriptionEffectiveFrom
+from paddle_billing.Entities.Subscriptions.SubscriptionItem                             import SubscriptionItem
+from paddle_billing.Entities.Subscriptions.SubscriptionItemStatus                       import SubscriptionItemStatus
+from paddle_billing.Entities.Subscriptions.SubscriptionItems                            import SubscriptionItems
+from paddle_billing.Entities.Subscriptions.SubscriptionItemsWithPrice                   import SubscriptionItemsWithPrice
+from paddle_billing.Entities.Subscriptions.SubscriptionManagementUrls                   import SubscriptionManagementUrls
+from paddle_billing.Entities.Subscriptions.SubscriptionNextTransaction                  import SubscriptionNextTransaction
+from paddle_billing.Entities.Subscriptions.SubscriptionNonCatalogPrice                  import SubscriptionNonCatalogPrice
+from paddle_billing.Entities.Subscriptions.SubscriptionNonCatalogPriceWithProduct       import SubscriptionNonCatalogPriceWithProduct
+from paddle_billing.Entities.Subscriptions.SubscriptionNonCatalogProduct                import SubscriptionNonCatalogProduct
+from paddle_billing.Entities.Subscriptions.SubscriptionOnPaymentFailure                 import SubscriptionOnPaymentFailure
+from paddle_billing.Entities.Subscriptions.SubscriptionPreviewSubscriptionUpdateSummary import SubscriptionPreviewSubscriptionUpdateSummary
+from paddle_billing.Entities.Subscriptions.SubscriptionPrice                            import SubscriptionPrice
+from paddle_billing.Entities.Subscriptions.SubscriptionProration                        import SubscriptionProration
+from paddle_billing.Entities.Subscriptions.SubscriptionProrationBillingMode             import SubscriptionProrationBillingMode
+from paddle_billing.Entities.Subscriptions.SubscriptionResult                           import SubscriptionResult
+from paddle_billing.Entities.Subscriptions.SubscriptionResultAction                     import SubscriptionResultAction
+from paddle_billing.Entities.Subscriptions.SubscriptionResumeEffectiveFrom              import SubscriptionResumeEffectiveFrom
+from paddle_billing.Entities.Subscriptions.SubscriptionScheduledChange                  import SubscriptionScheduledChange
+from paddle_billing.Entities.Subscriptions.SubscriptionScheduledChangeAction            import SubscriptionScheduledChangeAction
+from paddle_billing.Entities.Subscriptions.SubscriptionStatus                           import SubscriptionStatus
+from paddle_billing.Entities.Subscriptions.SubscriptionTimePeriod                       import SubscriptionTimePeriod
+from paddle_billing.Entities.Subscriptions.SubscriptionTransactionItem                  import SubscriptionTransactionItem
+from paddle_billing.Entities.Subscriptions.SubscriptionTransactionLineItem              import SubscriptionTransactionLineItem
+from paddle_billing.Entities.Subscriptions.SubscriptionUpdateItem                       import SubscriptionUpdateItem

paddle_billing/Entities/Transaction.py

@@ -0,0 +1,98 @@
+from __future__  import annotations
+from dataclasses import dataclass
+from datetime    import datetime
+
+from paddle_billing.Entities.Adjustment import Adjustment
+from paddle_billing.Entities.Entity     import Entity
+from paddle_billing.Entities.Address    import Address
+from paddle_billing.Entities.Business   import Business
+from paddle_billing.Entities.Customer   import Customer
+from paddle_billing.Entities.Discount   import Discount
+
+from paddle_billing.Entities.Shared import (
+    AvailablePaymentMethods,
+    BillingDetails,
+    Checkout,
+    CollectionMode,
+    CurrencyCode,
+    CustomData,
+    TransactionOrigin,
+    TransactionPaymentAttempt,
+    TransactionStatus,
+)
+
+from paddle_billing.Entities.Transactions.TransactionAdjustmentsTotals import TransactionAdjustmentsTotals
+from paddle_billing.Entities.Transactions.TransactionDetails           import TransactionDetails
+from paddle_billing.Entities.Transactions.TransactionItem              import TransactionItem
+from paddle_billing.Entities.Transactions.TransactionTimePeriod        import TransactionTimePeriod
+
+
+@dataclass
+class Transaction(Entity):
+    id:                        str
+    status:                    TransactionStatus
+    customer_id:               str        | None
+    address_id:                str        | None
+    business_id:               str        | None
+    custom_data:               CustomData | None
+    currency_code:             CurrencyCode
+    origin:                    TransactionOrigin
+    subscription_id:           str | None
+    invoice_id:                str | None
+    invoice_number:            str | None
+    collection_mode:           CollectionMode
+    discount_id:               str                   | None
+    billing_details:           BillingDetails        | None
+    billing_period:            TransactionTimePeriod | None
+    items:                     list[TransactionItem]
+    details:                   TransactionDetails
+    payments:                  list[TransactionPaymentAttempt]
+    checkout:                  Checkout | None
+    created_at:                datetime
+    updated_at:                datetime
+    billed_at:                 datetime                           | None
+    address:                   Address                            | None = None
+    adjustments:               list[Adjustment]                   | None = None
+    adjustment_totals:         list[TransactionAdjustmentsTotals] | None = None
+    business:                  Business                           | None = None
+    customer:                  Customer                           | None = None
+    discount:                  Discount                           | None = None
+    available_payment_methods: list[AvailablePaymentMethods]      | None = None
+    receipt_data:              str                                | None = None
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Transaction:
+        return Transaction(
+            address_id      = data.get('address_id'),
+            business_id     = data.get('business_id'),
+            collection_mode = CollectionMode(data['collection_mode']),
+            created_at      = datetime.fromisoformat(data['created_at']),
+            currency_code   = CurrencyCode(data['currency_code']),
+            customer_id     = data.get('customer_id'),
+            details         = TransactionDetails.from_dict(data['details']),
+            discount_id     = data.get('discount_id'),
+            id              = data['id'],
+            invoice_id      = data.get('invoice_id'),
+            invoice_number  = data.get('invoice_number'),
+            origin          = TransactionOrigin(data['origin']),
+            receipt_data    = data.get('receipt_data'),
+            status          = TransactionStatus(data['status']),
+            subscription_id = data.get('subscription_id'),
+            updated_at      = datetime.fromisoformat(data['updated_at']),
+            items           = [TransactionItem.from_dict(item)           for item in data.get('items',       [])],
+            payments        = [TransactionPaymentAttempt.from_dict(item) for item in data.get('payments',    [])],
+            adjustments     = [Adjustment.from_dict(item)                for item in data.get('adjustments', [])],
+            address         = Address.from_dict(data['address'])                      if data.get('address')         else None,
+            billed_at       = datetime.fromisoformat(data['billed_at'])               if data.get('billed_at')       else None,
+            billing_details = BillingDetails.from_dict(data['billing_details'])       if data.get('billing_details') else None,
+            billing_period  = TransactionTimePeriod.from_dict(data['billing_period']) if data.get('billing_period')  else None,
+            business        = Business.from_dict(data['business'])                    if data.get('business')        else None,
+            custom_data     = CustomData(data['custom_data'])                         if data.get('custom_data')     else None,
+            checkout        = Checkout.from_dict(data['checkout'])                    if data.get('checkout')        else None,
+            customer        = Customer.from_dict(data['customer'])                    if data.get('customer')        else None,
+            discount        = Discount.from_dict(data['discount'])                    if data.get('discount')        else None,
+
+            available_payment_methods = [AvailablePaymentMethods(item) for item    in data.get('available_payment_methods', [])],
+            adjustment_totals         = TransactionAdjustmentsTotals.from_dict(data['adjustment_totals']) if data.get('adjustment_totals') else None,
+        )

paddle_billing/Entities/TransactionData.py

@@ -0,0 +1,15 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Entity import Entity
+
+
+@dataclass
+class TransactionData(Entity):
+    url: str
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> TransactionData:
+        return TransactionData(data['url'])
+

paddle_billing/Entities/TransactionPreview.py

@@ -0,0 +1,40 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Shared import AddressPreview, AvailablePaymentMethods, CurrencyCode
+
+from paddle_billing.Entities.Shared.TransactionDetailsPreview             import TransactionDetailsPreview
+from paddle_billing.Entities.Transactions.TransactionItemPreviewWithPrice import TransactionItemPreviewWithPrice
+
+
+@dataclass
+class TransactionPreview(Entity):
+    customer_id:               str | None
+    address_id:                str | None
+    business_id:               str | None
+    currency_code:             CurrencyCode
+    discount_id:               str | None
+    customer_ip_address:       str | None
+    address:                   AddressPreview | None
+    ignore_trials:             bool
+    items:                     list[TransactionItemPreviewWithPrice]
+    details:                   TransactionDetailsPreview
+    available_payment_methods: list[AvailablePaymentMethods]
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> TransactionPreview:
+        return TransactionPreview(
+            customer_id               = data.get('customer_id'),
+            address_id                = data.get('address_id'),
+            business_id               = data.get('business_id'),
+            currency_code             = CurrencyCode(data['currency_code']),
+            discount_id               = data.get('discount_id'),
+            customer_ip_address       = data.get('customer_ip_address'),
+            ignore_trials             = data['ignore_trials'],
+            details                   = TransactionDetailsPreview.from_dict(data['details']),
+            items                     = [TransactionItemPreviewWithPrice.from_dict(item) for item   in data['items']],
+            available_payment_methods = [AvailablePaymentMethods(method)                 for method in data['available_payment_methods']],
+            address                   = AddressPreview.from_dict(data['address']) if data.get('address') else None,
+        )

paddle_billing/Entities/Transactions/TransactionAdjustmentsTotals.py

@@ -0,0 +1,30 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared.CurrencyCode import CurrencyCode
+
+from paddle_billing.Entities.Transactions.TransactionBreakdown import TransactionBreakdown
+
+
+@dataclass
+class TransactionAdjustmentsTotals:
+    subtotal:      str
+    tax:           str
+    total:         str
+    fee:           str
+    earnings:      str
+    breakdown:     TransactionBreakdown
+    currency_code: CurrencyCode
+
+
+    @staticmethod
+    def from_dict(data: dict) -> TransactionAdjustmentsTotals:
+        return TransactionAdjustmentsTotals(
+            subtotal      = data['subtotal'],
+            tax           = data['tax'],
+            total         = data['total'],
+            fee           = data['fee'],
+            earnings      = data['earnings'],
+            breakdown     = TransactionBreakdown.from_dict(data['breakdown']),
+            currency_code = CurrencyCode(data['currency_code']),
+        )

paddle_billing/Entities/Transactions/TransactionBreakdown.py

@@ -0,0 +1,18 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+
+@dataclass
+class TransactionBreakdown:
+    credit:     str
+    refund:     str
+    chargeback: str
+
+
+    @staticmethod
+    def from_dict(data: dict) -> TransactionBreakdown:
+        return TransactionBreakdown(
+            credit     = data['credit'],
+            refund     = data['refund'],
+            chargeback = data['chargeback'],
+        )

paddle_billing/Entities/Transactions/TransactionCardType.py

@@ -0,0 +1,14 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class TransactionCardType(PaddleStrEnum):
+    AmericanExpress = 'american_express'
+    DinersClub      = 'diners_club'
+    Discover        = 'discover'
+    Jcb             = 'jcb'
+    Mada            = 'mada'
+    Maestro         = 'maestro'
+    Mastercard      = 'mastercard'
+    UnionPay        = 'union_pay'
+    Unknown         = 'unknown'
+    Visa            = 'visa'

paddle_billing/Entities/Transactions/TransactionCreateItem.py

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

paddle_billing/Entities/Transactions/TransactionCreateItemWithPrice.py

@@ -0,0 +1,11 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Transactions.TransactionNonCatalogPrice            import TransactionNonCatalogPrice
+from paddle_billing.Entities.Transactions.TransactionNonCatalogPriceWithProduct import TransactionNonCatalogPriceWithProduct
+
+
+@dataclass
+class TransactionCreateItemWithPrice:
+    price:    TransactionNonCatalogPrice | TransactionNonCatalogPriceWithProduct
+    quantity: int

paddle_billing/Entities/Transactions/TransactionDetails.py

@@ -0,0 +1,32 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared.TaxRatesUsed                    import TaxRatesUsed
+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.Transactions.TransactionLineItem import TransactionLineItem
+
+
+@dataclass
+class TransactionDetails:
+    tax_rates_used:         list[TaxRatesUsed]
+    totals:                 TransactionTotals
+    adjusted_totals:        TransactionTotalsAdjusted       | None
+    payout_totals:          TransactionPayoutTotals         | None
+    adjusted_payout_totals: TransactionPayoutTotalsAdjusted | None
+    lineItems:              list[TransactionLineItem]
+
+
+    @staticmethod
+    def from_dict(data: dict) -> TransactionDetails:
+        return TransactionDetails(
+            totals                 = TransactionTotals.from_dict(data['totals']),
+            tax_rates_used         = [TaxRatesUsed.from_dict(tax_rate_used)    for tax_rate_used in data['tax_rates_used']],
+            lineItems              = [TransactionLineItem.from_dict(line_item) for line_item     in data['line_items']],
+            adjusted_totals        = TransactionTotalsAdjusted.from_dict(data['adjusted_totals'])              if data.get('adjusted_totals')        else None,
+            payout_totals          = TransactionPayoutTotals.from_dict(data['payout_totals'])                  if data.get('payout_totals')          else None,
+            adjusted_payout_totals = TransactionPayoutTotalsAdjusted.from_dict(data['adjusted_payout_totals']) if data.get('adjusted_payout_totals') else None,
+        )

paddle_billing/Entities/Transactions/TransactionItem.py

@@ -0,0 +1,24 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Price import Price
+
+from paddle_billing.Entities.Transactions.TransactionProration import TransactionProration
+
+
+@dataclass
+class TransactionItem:
+    price_id:  str | None
+    price:     Price
+    quantity:  int
+    proration: TransactionProration | None
+
+
+    @staticmethod
+    def from_dict(data: dict) -> TransactionItem:
+        return TransactionItem(
+            price_id  = data.get('price_id'),
+            price     = Price.from_dict(data['price']),
+            quantity  = data['quantity'],
+            proration = TransactionProration.from_dict(data['proration']) if data.get('proration') else None,
+        )

paddle_billing/Entities/Transactions/TransactionItemPreviewWithNonCatalogPrice.py

@@ -0,0 +1,21 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Transactions.TransactionNonCatalogPrice            import TransactionNonCatalogPrice
+from paddle_billing.Entities.Transactions.TransactionNonCatalogPriceWithProduct import TransactionNonCatalogPriceWithProduct
+
+
+@dataclass
+class TransactionItemPreviewWithNonCatalogPrice:
+    price:             TransactionNonCatalogPrice | TransactionNonCatalogPriceWithProduct
+    quantity:          int
+    include_in_totals: bool | None
+
+
+    @staticmethod
+    def from_dict(data: dict) -> TransactionItemPreviewWithNonCatalogPrice:
+        return TransactionItemPreviewWithNonCatalogPrice(
+            price             = data['price'],
+            quantity          = data['quantity'],
+            include_in_totals = data.get('include_in_totals'),
+        )

paddle_billing/Entities/Transactions/TransactionItemPreviewWithPrice.py

@@ -0,0 +1,24 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Price import Price
+
+from paddle_billing.Entities.Transactions.TransactionProration import TransactionProration
+
+
+@dataclass
+class TransactionItemPreviewWithPrice:
+    price:             Price
+    quantity:          int
+    include_in_totals: bool
+    proration:         TransactionProration | None
+
+
+    @staticmethod
+    def from_dict(data: dict) -> TransactionItemPreviewWithPrice:
+        return TransactionItemPreviewWithPrice(
+            price             = Price.from_dict(data['price']),
+            quantity          = data['quantity'],
+            include_in_totals = data['include_in_totals'],
+            proration         = TransactionProration.from_dict(data['proration']) if data.get('proration') else None,
+        )

paddle_billing/Entities/Transactions/TransactionItemPreviewWithPriceId.py

@@ -0,0 +1,18 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+
+@dataclass
+class TransactionItemPreviewWithPriceId:
+    price_id:          str
+    quantity:          int
+    include_in_totals: bool | None
+
+
+    @staticmethod
+    def from_dict(data: dict) -> TransactionItemPreviewWithPriceId:
+        return TransactionItemPreviewWithPriceId(
+            price_id          = data['price_id'],
+            quantity          = data['quantity'],
+            include_in_totals = data.get('include_in_totals'),
+        )