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

paddle_billing/Notifications/Entities/Shared/TransactionPayoutTotals.py

@@ -0,0 +1,36 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Notifications.Entities.Shared.CurrencyCodePayouts import CurrencyCodePayouts
+
+
+@dataclass
+class TransactionPayoutTotals:
+    subtotal:          str
+    discount:          str
+    tax:               str
+    total:             str
+    credit:            str
+    balance:           str
+    grand_total:       str
+    fee:               str | None
+    earnings:          str | None
+    currency_code:     CurrencyCodePayouts
+    credit_to_balance: str
+
+
+    @staticmethod
+    def from_dict(data: dict) -> TransactionPayoutTotals:
+        return TransactionPayoutTotals(
+            subtotal          = data['subtotal'],
+            discount          = data['discount'],
+            tax               = data['tax'],
+            total             = data['total'],
+            credit            = data['credit'],
+            balance           = data['balance'],
+            grand_total       = data['grand_total'],
+            fee               = data.get('fee'),
+            earnings          = data.get('earnings'),
+            currency_code     = CurrencyCodePayouts(data['currency_code']),
+            credit_to_balance = data['credit_to_balance'],
+        )

paddle_billing/Notifications/Entities/Shared/TransactionPayoutTotalsAdjusted.py

@@ -0,0 +1,29 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Notifications.Entities.Shared.ChargebackFee       import ChargebackFee
+from paddle_billing.Notifications.Entities.Shared.CurrencyCodePayouts import CurrencyCodePayouts
+
+
+@dataclass
+class TransactionPayoutTotalsAdjusted:
+    subtotal:       str
+    tax:            str
+    total:          str
+    fee:            str
+    chargeback_fee: ChargebackFee
+    earnings:       str
+    currency_code:  CurrencyCodePayouts
+
+
+    @staticmethod
+    def from_dict(data: dict) -> TransactionPayoutTotalsAdjusted:
+        return TransactionPayoutTotalsAdjusted(
+            subtotal       = data['subtotal'],
+            tax            = data['tax'],
+            total          = data['total'],
+            fee            = data['fee'],
+            chargeback_fee = ChargebackFee.from_dict(data['chargeback_fee']),
+            earnings       = data['earnings'],
+            currency_code  = CurrencyCodePayouts(data['currency_code']),
+        )

paddle_billing/Notifications/Entities/Shared/TransactionStatus.py

@@ -0,0 +1,11 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class TransactionStatus(PaddleStrEnum):
+    Draft     = 'draft'
+    Ready     = 'ready'
+    Billed    = 'billed'
+    Paid      = 'paid'
+    Completed = 'completed'
+    Canceled  = 'canceled'
+    PastDue   = 'past_due'

paddle_billing/Notifications/Entities/Shared/TransactionTotals.py

@@ -0,0 +1,36 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Notifications.Entities.Shared.CurrencyCode import CurrencyCode
+
+
+@dataclass
+class TransactionTotals:
+    subtotal:          str
+    discount:          str
+    tax:               str
+    total:             str
+    credit:            str
+    balance:           str
+    grand_total:       str | None
+    fee:               str | None
+    earnings:          str | None
+    currency_code:     CurrencyCode
+    credit_to_balance: str
+
+
+    @staticmethod
+    def from_dict(data: dict) -> TransactionTotals:
+        return TransactionTotals(
+            subtotal          = data['subtotal'],
+            discount          = data['discount'],
+            tax               = data['tax'],
+            total             = data['total'],
+            credit            = data['credit'],
+            balance           = data['balance'],
+            grand_total       = data.get('grand_total'),
+            fee               = data.get('fee'),
+            earnings          = data.get('earnings'),
+            currency_code     = CurrencyCode(data['currency_code']),
+            credit_to_balance = data['credit_to_balance'],
+        )

paddle_billing/Notifications/Entities/Shared/TransactionTotalsAdjusted.py

@@ -0,0 +1,28 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Notifications.Entities.Shared.CurrencyCode import CurrencyCode
+
+
+@dataclass
+class TransactionTotalsAdjusted:
+    subtotal:      str
+    tax:           str
+    total:         str
+    grand_total:   str
+    fee:           str | None
+    earnings:      str | None
+    currency_code: CurrencyCode
+
+
+    @staticmethod
+    def from_dict(data: dict) -> TransactionTotalsAdjusted:
+        return TransactionTotalsAdjusted(
+            subtotal      = data['subtotal'],
+            tax           = data['tax'],
+            total         = data['total'],
+            grand_total   = data['grand_total'],
+            fee           = data.get('fee'),
+            earnings      = data.get('earnings'),
+            currency_code = CurrencyCode(data['currency_code']),
+        )

paddle_billing/Notifications/Entities/Shared/UnitPriceOverride.py

@@ -0,0 +1,19 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Notifications.Entities.Shared.CountryCode import CountryCode
+from paddle_billing.Notifications.Entities.Shared.Money       import Money
+
+
+@dataclass
+class UnitPriceOverride:
+    country_codes: list[CountryCode]
+    unit_price:    Money
+
+
+    @staticmethod
+    def from_dict(data: dict) -> UnitPriceOverride:
+        return UnitPriceOverride(
+            country_codes = [CountryCode(code) for code in data['country_codes']],
+            unit_price    = Money.from_dict(data['unit_price'])
+        )

paddle_billing/Notifications/Entities/Shared/UnitTotals.py

@@ -0,0 +1,20 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+
+@dataclass
+class UnitTotals:
+    subtotal: str
+    discount: str
+    tax:      str
+    total:    str
+
+
+    @staticmethod
+    def from_dict(data: dict) -> UnitTotals:
+        return UnitTotals(
+            subtotal = data['subtotal'],
+            discount = data['discount'],
+            tax      = data['tax'],
+            total    = data['total'],
+        )

paddle_billing/Notifications/Entities/Shared/__init__.py

@@ -0,0 +1,46 @@
+from paddle_billing.Notifications.Entities.Shared.Action                          import Action
+from paddle_billing.Notifications.Entities.Shared.AddressPreview                  import AddressPreview
+from paddle_billing.Notifications.Entities.Shared.AdjustmentItemTotals            import AdjustmentItemTotals
+from paddle_billing.Notifications.Entities.Shared.AdjustmentProration             import AdjustmentProration
+from paddle_billing.Notifications.Entities.Shared.AdjustmentStatus                import AdjustmentStatus
+from paddle_billing.Notifications.Entities.Shared.AdjustmentTimePeriod            import AdjustmentTimePeriod
+from paddle_billing.Notifications.Entities.Shared.AdjustmentTotals                import AdjustmentTotals
+from paddle_billing.Notifications.Entities.Shared.AdjustmentType                  import AdjustmentType
+from paddle_billing.Notifications.Entities.Shared.AvailablePaymentMethods         import AvailablePaymentMethods
+from paddle_billing.Notifications.Entities.Shared.BillingDetails                  import BillingDetails
+from paddle_billing.Notifications.Entities.Shared.Card                            import Card
+from paddle_billing.Notifications.Entities.Shared.CatalogType                     import CatalogType
+from paddle_billing.Notifications.Entities.Shared.ChargebackFee                   import ChargebackFee
+from paddle_billing.Notifications.Entities.Shared.Checkout                        import Checkout
+from paddle_billing.Notifications.Entities.Shared.CollectionMode                  import CollectionMode
+from paddle_billing.Notifications.Entities.Shared.CountryCode                     import CountryCode
+from paddle_billing.Notifications.Entities.Shared.CurrencyCode                    import CurrencyCode
+from paddle_billing.Notifications.Entities.Shared.CurrencyCodeAdjustments         import CurrencyCodeAdjustments
+from paddle_billing.Notifications.Entities.Shared.CurrencyCodePayouts             import CurrencyCodePayouts
+from paddle_billing.Notifications.Entities.Shared.CustomData                      import CustomData
+from paddle_billing.Notifications.Entities.Shared.Data                            import Data
+from paddle_billing.Notifications.Entities.Shared.ErrorCode                       import ErrorCode
+from paddle_billing.Notifications.Entities.Shared.ImportMeta                      import ImportMeta
+from paddle_billing.Notifications.Entities.Shared.Interval                        import Interval
+from paddle_billing.Notifications.Entities.Shared.MethodDetails                   import MethodDetails
+from paddle_billing.Notifications.Entities.Shared.Money                           import Money
+from paddle_billing.Notifications.Entities.Shared.Original                        import Original
+from paddle_billing.Notifications.Entities.Shared.PaymentAttemptStatus            import PaymentAttemptStatus
+from paddle_billing.Notifications.Entities.Shared.PaymentMethodType               import PaymentMethodType
+from paddle_billing.Notifications.Entities.Shared.PayoutTotalsAdjustment          import PayoutTotalsAdjustment
+from paddle_billing.Notifications.Entities.Shared.PriceQuantity                   import PriceQuantity
+from paddle_billing.Notifications.Entities.Shared.Status                          import Status
+from paddle_billing.Notifications.Entities.Shared.TransactionStatus               import TransactionStatus
+from paddle_billing.Notifications.Entities.Shared.TaxCategory                     import TaxCategory
+from paddle_billing.Notifications.Entities.Shared.TaxMode                         import TaxMode
+from paddle_billing.Notifications.Entities.Shared.TaxRatesUsed                    import TaxRatesUsed
+from paddle_billing.Notifications.Entities.Shared.TimePeriod                      import TimePeriod
+from paddle_billing.Notifications.Entities.Shared.Totals                          import Totals
+from paddle_billing.Notifications.Entities.Shared.TransactionOrigin               import TransactionOrigin
+from paddle_billing.Notifications.Entities.Shared.TransactionPaymentAttempt       import TransactionPaymentAttempt
+from paddle_billing.Notifications.Entities.Shared.TransactionPayoutTotals         import TransactionPayoutTotals
+from paddle_billing.Notifications.Entities.Shared.TransactionPayoutTotalsAdjusted import TransactionPayoutTotalsAdjusted
+from paddle_billing.Notifications.Entities.Shared.TransactionTotals               import TransactionTotals
+from paddle_billing.Notifications.Entities.Shared.TransactionTotalsAdjusted       import TransactionTotalsAdjusted
+from paddle_billing.Notifications.Entities.Shared.UnitPriceOverride               import UnitPriceOverride
+from paddle_billing.Notifications.Entities.Shared.UnitTotals                      import UnitTotals

paddle_billing/Notifications/Entities/Subscription.py

@@ -0,0 +1,76 @@
+from __future__  import annotations
+from dataclasses import dataclass
+from datetime    import datetime
+
+from paddle_billing.Notifications.Entities.Entity import Entity
+from paddle_billing.Notifications.Entities.Shared import (
+    BillingDetails,
+    CollectionMode,
+    CurrencyCode,
+    CustomData,
+    ImportMeta,
+    TimePeriod
+)
+from paddle_billing.Notifications.Entities.Subscriptions import (
+    SubscriptionDiscount,
+    SubscriptionItem,
+    SubscriptionScheduledChange,
+    SubscriptionStatus,
+    SubscriptionTimePeriod,
+)
+
+
+@dataclass
+class Subscription(Entity):
+    address_id:             str
+    billing_cycle:          TimePeriod
+    collection_mode:        CollectionMode
+    created_at:             datetime
+    currency_code:          CurrencyCode
+    customer_id:            str
+    id:                     str
+    items:                  list[SubscriptionItem]
+    status:                 SubscriptionStatus
+    updated_at:             datetime
+    billing_details:        BillingDetails              | None = None
+    business_id:            str                         | None = None
+    canceled_at:            datetime                    | None = None
+    current_billing_period: SubscriptionTimePeriod      | None = None
+    custom_data:            CustomData                  | None = None
+    discount:               SubscriptionDiscount        | None = None
+    import_meta:            ImportMeta                  | None = None
+    first_billed_at:        datetime                    | None = None
+    next_billed_at:         datetime                    | None = None
+    paused_at:              datetime                    | None = None
+    scheduled_change:       SubscriptionScheduledChange | None = None
+    started_at:             datetime                    | None = None
+    transaction_id:         str                         | None = None  # Only provided by subscription.created
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Subscription:
+        return Subscription(
+            id                     = data['id'],
+            transaction_id         = data.get('transaction_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']],
+            billing_details        = BillingDetails.from_dict(data['billing_details']) if data.get('billing_details') else None,
+            canceled_at            = datetime.fromisoformat(data['canceled_at'])       if data.get('canceled_at')     else None,
+            custom_data            = CustomData(data['custom_data'])                   if data.get('custom_data')     else None,
+            discount               = SubscriptionDiscount.from_dict(data['discount'])  if data.get('discount')        else None,
+            first_billed_at        = datetime.fromisoformat(data['first_billed_at'])   if data.get('first_billed_at') else None,
+            import_meta            = ImportMeta.from_dict(data['import_meta'])         if data.get('import_meta')     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,
+            started_at             = datetime.fromisoformat(data['started_at'])        if data.get('started_at')      else None,
+            current_billing_period = SubscriptionTimePeriod.from_dict(data['current_billing_period']) if data.get('billing_details')  else None,
+            scheduled_change       = SubscriptionScheduledChange.from_dict(data['scheduled_change'])  if data.get('scheduled_change') else None,
+        )

paddle_billing/Notifications/Entities/Subscriptions/SubscriptionAdjustmentItem.py

@@ -0,0 +1,24 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Notifications.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/Notifications/Entities/Subscriptions/SubscriptionCharge.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Notifications.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/Notifications/Entities/Subscriptions/SubscriptionCredit.py

@@ -0,0 +1,18 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Notifications.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/Notifications/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/Notifications/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/Notifications/Entities/Subscriptions/SubscriptionItem.py

@@ -0,0 +1,35 @@
+from __future__  import annotations
+from dataclasses import dataclass
+from datetime    import datetime
+
+from paddle_billing.Notifications.Entities.Subscriptions.SubscriptionItemStatus import SubscriptionItemStatus
+from paddle_billing.Notifications.Entities.Subscriptions.SubscriptionPrice      import SubscriptionPrice
+from paddle_billing.Notifications.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/Notifications/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/Notifications/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/Notifications/Entities/Subscriptions/SubscriptionPrice.py

@@ -0,0 +1,28 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Notifications.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/Notifications/Entities/Subscriptions/SubscriptionScheduledChange.py

@@ -0,0 +1,21 @@
+from __future__  import annotations
+from dataclasses import dataclass
+from datetime    import datetime
+
+from paddle_billing.Notifications.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/Notifications/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/Notifications/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/Notifications/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/Notifications/Entities/Subscriptions/__init__.py

@@ -0,0 +1,13 @@
+from paddle_billing.Notifications.Entities.Subscriptions.SubscriptionAdjustmentItem        import SubscriptionAdjustmentItem
+from paddle_billing.Notifications.Entities.Subscriptions.SubscriptionCharge                import SubscriptionCharge
+from paddle_billing.Notifications.Entities.Subscriptions.SubscriptionCredit                import SubscriptionCredit
+from paddle_billing.Notifications.Entities.Subscriptions.SubscriptionDiscount              import SubscriptionDiscount
+from paddle_billing.Notifications.Entities.Subscriptions.SubscriptionEffectiveFrom         import SubscriptionEffectiveFrom
+from paddle_billing.Notifications.Entities.Subscriptions.SubscriptionItem                  import SubscriptionItem
+from paddle_billing.Notifications.Entities.Subscriptions.SubscriptionItemStatus            import SubscriptionItemStatus
+from paddle_billing.Notifications.Entities.Subscriptions.SubscriptionOnPaymentFailure      import SubscriptionOnPaymentFailure
+from paddle_billing.Notifications.Entities.Subscriptions.SubscriptionPrice                 import SubscriptionPrice
+from paddle_billing.Notifications.Entities.Subscriptions.SubscriptionScheduledChange       import SubscriptionScheduledChange
+from paddle_billing.Notifications.Entities.Subscriptions.SubscriptionScheduledChangeAction import SubscriptionScheduledChangeAction
+from paddle_billing.Notifications.Entities.Subscriptions.SubscriptionStatus                import SubscriptionStatus
+from paddle_billing.Notifications.Entities.Subscriptions.SubscriptionTimePeriod            import SubscriptionTimePeriod

paddle_billing/Notifications/Entities/Transaction.py

@@ -0,0 +1,75 @@
+from __future__  import annotations
+from dataclasses import dataclass
+from datetime    import datetime
+
+from paddle_billing.Notifications.Entities.Entity import Entity
+from paddle_billing.Notifications.Entities.Shared import (
+    BillingDetails,
+    Checkout,
+    CollectionMode,
+    CurrencyCode,
+    CustomData,
+    TransactionOrigin,
+    TransactionPaymentAttempt,
+    TransactionStatus,
+)
+
+from paddle_billing.Notifications.Entities.Transactions.TransactionDetails    import TransactionDetails
+from paddle_billing.Notifications.Entities.Transactions.TransactionItem       import TransactionItem
+from paddle_billing.Notifications.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
+    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',    [])],
+            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,
+            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,
+        )