gr4vy 1.1.29__py3-none-any.whl → 1.10.9__py3-none-any.whl

gr4vy/models/reportspec.py

@@ -3,10 +3,8 @@
 from __future__ import annotations
 from .reportspecmodel import ReportSpecModel
 from gr4vy.types import BaseModel
-from gr4vy.utils import validate_open_enum
-from pydantic.functional_validators import PlainValidator
 from typing import Any, Dict
-from typing_extensions import Annotated, TypedDict
+from typing_extensions import TypedDict
 
 
 class ReportSpecTypedDict(TypedDict):
@@ -16,7 +14,7 @@ class ReportSpecTypedDict(TypedDict):
 
 
 class ReportSpec(BaseModel):
-    model: Annotated[ReportSpecModel, PlainValidator(validate_open_enum(False))]
+    model: ReportSpecModel
 
     params: Dict[str, Any]
     r"""The parameters for the report model."""

gr4vy/models/reportsummary.py

@@ -3,10 +3,10 @@
 from __future__ import annotations
 from .reportcreatortype import ReportCreatorType
 from gr4vy.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
-from gr4vy.utils import validate_const, validate_open_enum
+from gr4vy.utils import validate_const
 import pydantic
 from pydantic import model_serializer
-from pydantic.functional_validators import AfterValidator, PlainValidator
+from pydantic.functional_validators import AfterValidator
 from typing import Literal, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
@@ -52,9 +52,7 @@ class ReportSummary(BaseModel):
     creator_display_name: OptionalNullable[str] = UNSET
     r"""The display name of the report creator."""
 
-    creator_type: Annotated[
-        OptionalNullable[ReportCreatorType], PlainValidator(validate_open_enum(False))
-    ] = UNSET
+    creator_type: OptionalNullable[ReportCreatorType] = UNSET
     r"""The type of the report creator."""
 
     @model_serializer(mode="wrap")

gr4vy/models/settlement.py

@@ -15,21 +15,21 @@ class SettlementTypedDict(TypedDict):
     r"""A settlement record for a transaction."""
 
     id: str
-    r"""The unique identifier for the settlement."""
+    r"""The unique identifier for the record."""
     merchant_account_id: str
-    r"""The merchant account this settlement belongs to."""
+    r"""The merchant account this record belongs to."""
     created_at: datetime
-    r"""The date and time the settlement was created, in ISO 8601 format."""
+    r"""The date and time the record was created, in ISO 8601 format."""
     updated_at: datetime
-    r"""The date and time the settlement was last updated, in ISO 8601 format."""
+    r"""The date and time the record was last updated, in ISO 8601 format."""
     posted_at: datetime
-    r"""The date and time the settlement was posted, in ISO 8601 format."""
+    r"""The date and time the record was posted, in ISO 8601 format."""
     ingested_at: datetime
-    r"""The date and time the settlement was ingested, in ISO 8601 format."""
+    r"""The date and time the record was ingested, in ISO 8601 format."""
     currency: str
-    r"""ISO 4217 currency code for the settlement."""
+    r"""ISO 4217 currency code."""
     amount: int
-    r"""The total settled amount in the smallest currency unit (e.g. cents)."""
+    r"""The total amount in the smallest currency unit (e.g. cents)."""
     commission: int
     r"""The commission amount deducted in the smallest currency unit."""
     payment_service_report_id: str
@@ -37,45 +37,45 @@ class SettlementTypedDict(TypedDict):
     payment_service_report_file_ids: List[str]
     r"""List of file IDs for the payment service report."""
     transaction_id: str
-    r"""The transaction this settlement is associated with."""
-    type: Literal["settlement"]
-    r"""Always 'settlement'."""
+    r"""The transaction this record is associated with."""
     exchange_rate: NotRequired[Nullable[float]]
-    r"""The exchange rate used for settlement, if applicable."""
+    r"""The exchange rate, if applicable."""
     interchange: NotRequired[Nullable[int]]
     r"""The interchange fee, if applicable, in the smallest currency unit."""
     markup: NotRequired[Nullable[int]]
     r"""The markup fee, if applicable, in the smallest currency unit."""
     scheme_fee: NotRequired[Nullable[int]]
     r"""The scheme fee, if applicable, in the smallest currency unit."""
+    type: Literal["settlement"]
+    r"""Always `settlement`."""
 
 
 class Settlement(BaseModel):
     r"""A settlement record for a transaction."""
 
     id: str
-    r"""The unique identifier for the settlement."""
+    r"""The unique identifier for the record."""
 
     merchant_account_id: str
-    r"""The merchant account this settlement belongs to."""
+    r"""The merchant account this record belongs to."""
 
     created_at: datetime
-    r"""The date and time the settlement was created, in ISO 8601 format."""
+    r"""The date and time the record was created, in ISO 8601 format."""
 
     updated_at: datetime
-    r"""The date and time the settlement was last updated, in ISO 8601 format."""
+    r"""The date and time the record was last updated, in ISO 8601 format."""
 
     posted_at: datetime
-    r"""The date and time the settlement was posted, in ISO 8601 format."""
+    r"""The date and time the record was posted, in ISO 8601 format."""
 
     ingested_at: datetime
-    r"""The date and time the settlement was ingested, in ISO 8601 format."""
+    r"""The date and time the record was ingested, in ISO 8601 format."""
 
     currency: str
-    r"""ISO 4217 currency code for the settlement."""
+    r"""ISO 4217 currency code."""
 
     amount: int
-    r"""The total settled amount in the smallest currency unit (e.g. cents)."""
+    r"""The total amount in the smallest currency unit (e.g. cents)."""
 
     commission: int
     r"""The commission amount deducted in the smallest currency unit."""
@@ -87,19 +87,10 @@ class Settlement(BaseModel):
     r"""List of file IDs for the payment service report."""
 
     transaction_id: str
-    r"""The transaction this settlement is associated with."""
-
-    TYPE: Annotated[
-        Annotated[
-            Optional[Literal["settlement"]],
-            AfterValidator(validate_const("settlement")),
-        ],
-        pydantic.Field(alias="type"),
-    ] = "settlement"
-    r"""Always 'settlement'."""
+    r"""The transaction this record is associated with."""
 
     exchange_rate: OptionalNullable[float] = UNSET
-    r"""The exchange rate used for settlement, if applicable."""
+    r"""The exchange rate, if applicable."""
 
     interchange: OptionalNullable[int] = UNSET
     r"""The interchange fee, if applicable, in the smallest currency unit."""
@@ -110,14 +101,23 @@ class Settlement(BaseModel):
     scheme_fee: OptionalNullable[int] = UNSET
     r"""The scheme fee, if applicable, in the smallest currency unit."""
 
+    TYPE: Annotated[
+        Annotated[
+            Optional[Literal["settlement"]],
+            AfterValidator(validate_const("settlement")),
+        ],
+        pydantic.Field(alias="type"),
+    ] = "settlement"
+    r"""Always `settlement`."""
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = [
-            "type",
             "exchange_rate",
             "interchange",
             "markup",
             "scheme_fee",
+            "type",
         ]
         nullable_fields = ["exchange_rate", "interchange", "markup", "scheme_fee"]
         null_default_fields = []

gr4vy/models/statementdescriptor.py

@@ -21,6 +21,8 @@ class StatementDescriptorTypedDict(TypedDict):
     r"""The value in the phone number field of a customer's statement which should be formatted according to the E164 number standard."""
     url: NotRequired[Nullable[str]]
     r"""The merchant's URL to be displayed in a statement descriptor."""
+    postal_code: NotRequired[Nullable[str]]
+    r"""The merchant's postal code or zip code."""
 
 
 class StatementDescriptor(BaseModel):
@@ -44,6 +46,9 @@ class StatementDescriptor(BaseModel):
     url: OptionalNullable[str] = UNSET
     r"""The merchant's URL to be displayed in a statement descriptor."""
 
+    postal_code: OptionalNullable[str] = UNSET
+    r"""The merchant's postal code or zip code."""
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = [
@@ -53,6 +58,7 @@ class StatementDescriptor(BaseModel):
             "country",
             "phone_number",
             "url",
+            "postal_code",
         ]
         nullable_fields = [
             "name",
@@ -61,6 +67,7 @@ class StatementDescriptor(BaseModel):
             "country",
             "phone_number",
             "url",
+            "postal_code",
         ]
         null_default_fields = []
 

gr4vy/models/stripeconnectoptions.py

@@ -15,6 +15,8 @@ class StripeConnectOptionsTypedDict(TypedDict):
     r"""The Stripe Connect account to target using the `on_behalf_of` request parameter."""
     transfer_data_destination: NotRequired[Nullable[str]]
     r"""The Stripe Connect account to target using the `transfer_data.destination` request parameter."""
+    transfer_group: NotRequired[Nullable[str]]
+    r"""A string that identifies the payment as part of a group."""
 
 
 class StripeConnectOptions(BaseModel):
@@ -30,6 +32,9 @@ class StripeConnectOptions(BaseModel):
     transfer_data_destination: OptionalNullable[str] = UNSET
     r"""The Stripe Connect account to target using the `transfer_data.destination` request parameter."""
 
+    transfer_group: OptionalNullable[str] = UNSET
+    r"""A string that identifies the payment as part of a group."""
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = [
@@ -37,12 +42,14 @@ class StripeConnectOptions(BaseModel):
             "application_fee_amount",
             "on_behalf_of",
             "transfer_data_destination",
+            "transfer_group",
         ]
         nullable_fields = [
             "stripe_account",
             "application_fee_amount",
             "on_behalf_of",
             "transfer_data_destination",
+            "transfer_group",
         ]
         null_default_fields = []
 

gr4vy/models/taxid.py

@@ -3,9 +3,7 @@
 from __future__ import annotations
 from .taxidkind import TaxIDKind
 from gr4vy.types import BaseModel
-from gr4vy.utils import validate_open_enum
-from pydantic.functional_validators import PlainValidator
-from typing_extensions import Annotated, TypedDict
+from typing_extensions import TypedDict
 
 
 class TaxIDTypedDict(TypedDict):
@@ -18,4 +16,4 @@ class TaxID(BaseModel):
     value: str
     r"""The tax ID for the buyer."""
 
-    kind: Annotated[TaxIDKind, PlainValidator(validate_open_enum(False))]
+    kind: TaxIDKind

gr4vy/models/taxidkind.py

@@ -24,6 +24,12 @@ TaxIDKind = Union[
         "cl.tin",
         "co.itin",
         "co.nit",
+        "co.cc",
+        "co.ce",
+        "co.de",
+        "co.rc",
+        "co.ti",
+        "co.passport",
         "es.cif",
         "eu.vat",
         "gb.vat",
@@ -31,6 +37,7 @@ TaxIDKind = Union[
         "id.nik",
         "id.npwp",
         "in.gst",
+        "in.pan",
         "jp.cn",
         "jp.rn",
         "kr.brn",

gr4vy/models/threedsecuredatav1.py

@@ -3,10 +3,8 @@
 from __future__ import annotations
 from .cardscheme import CardScheme
 from gr4vy.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
-from gr4vy.utils import validate_open_enum
 from pydantic import model_serializer
-from pydantic.functional_validators import PlainValidator
-from typing_extensions import Annotated, NotRequired, TypedDict
+from typing_extensions import NotRequired, TypedDict
 
 
 class ThreeDSecureDataV1TypedDict(TypedDict):
@@ -50,9 +48,7 @@ class ThreeDSecureDataV1(BaseModel):
     xid: str
     r"""The transaction identifier."""
 
-    scheme: Annotated[
-        OptionalNullable[CardScheme], PlainValidator(validate_open_enum(False))
-    ] = UNSET
+    scheme: OptionalNullable[CardScheme] = UNSET
     r"""The scheme/brand of the card that is used for 3-D Secure."""
 
     @model_serializer(mode="wrap")

gr4vy/models/threedsecuredatav2.py

@@ -3,10 +3,8 @@
 from __future__ import annotations
 from .cardscheme import CardScheme
 from gr4vy.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
-from gr4vy.utils import validate_open_enum
 from pydantic import model_serializer
-from pydantic.functional_validators import PlainValidator
-from typing_extensions import Annotated, NotRequired, TypedDict
+from typing_extensions import NotRequired, TypedDict
 
 
 class ThreeDSecureDataV2TypedDict(TypedDict):
@@ -42,9 +40,7 @@ class ThreeDSecureDataV2(BaseModel):
     directory_transaction_id: str
     r"""The transaction identifier."""
 
-    scheme: Annotated[
-        OptionalNullable[CardScheme], PlainValidator(validate_open_enum(False))
-    ] = UNSET
+    scheme: OptionalNullable[CardScheme] = UNSET
     r"""The scheme/brand of the card that is used for 3-D Secure."""
 
     authentication_response: OptionalNullable[str] = UNSET

gr4vy/models/threedsecuremethod.py

@@ -5,4 +5,10 @@ from gr4vy.types import UnrecognizedStr
 from typing import Literal, Union
 
 
-ThreeDSecureMethod = Union[Literal["challenge", "frictionless"], UnrecognizedStr]
+ThreeDSecureMethod = Union[
+    Literal[
+        "challenge",
+        "frictionless",
+    ],
+    UnrecognizedStr,
+]

gr4vy/models/threedsecurestatus.py

@@ -6,6 +6,12 @@ from typing import Literal, Union
 
 
 ThreeDSecureStatus = Union[
-    Literal["setup_error", "error", "declined", "cancelled", "complete"],
+    Literal[
+        "setup_error",
+        "error",
+        "declined",
+        "cancelled",
+        "complete",
+    ],
     UnrecognizedStr,
 ]

gr4vy/models/transaction.py

@@ -32,10 +32,10 @@ from .transactionthreedsecuresummary import (
 )
 from datetime import datetime
 from gr4vy.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
-from gr4vy.utils import validate_const, validate_open_enum
+from gr4vy.utils import validate_const
 import pydantic
 from pydantic import model_serializer
-from pydantic.functional_validators import AfterValidator, PlainValidator
+from pydantic.functional_validators import AfterValidator
 from typing import Dict, List, Literal, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
@@ -71,6 +71,8 @@ class TransactionTypedDict(TypedDict):
     r"""The date and time when the transaction was created, in ISO 8601 format."""
     updated_at: datetime
     r"""The date and time when the transaction was last updated, in ISO 8601 format."""
+    disputed: bool
+    r"""Indicates whether this transaction has been disputed."""
     payment_source: TransactionPaymentSource
     r"""The way payment method information made it to this transaction."""
     merchant_initiated: bool
@@ -144,6 +146,8 @@ class TransactionTypedDict(TypedDict):
     r"""The date this transaction was captured at."""
     voided_at: NotRequired[Nullable[datetime]]
     r"""The date this transaction was voided at."""
+    canceled_at: NotRequired[Nullable[datetime]]
+    r"""The date this transaction was canceled at."""
     approval_expires_at: NotRequired[Nullable[datetime]]
     r"""The date this transaction's approval URL will expire at."""
     buyer_approval_timedout_at: NotRequired[Nullable[datetime]]
@@ -154,6 +158,24 @@ class TransactionTypedDict(TypedDict):
     r"""An optional merchant advice code which provides insight into the type of transaction or reason why the payment failed."""
     installment_count: NotRequired[Nullable[int]]
     r"""The number of installments for this transaction, if applicable."""
+    session_token: NotRequired[Nullable[str]]
+    r"""A session token that can be used to fetch session data for direct client integrations."""
+    tax_amount: NotRequired[Nullable[int]]
+    r"""The sales tax amount for this transaction, represented as a monetary amount in the smallest currency unit for the given currency, for example `1299` cents to create an authorization for `$12.99`"""
+    merchant_tax_id: NotRequired[Nullable[str]]
+    r"""Merchant tax ID (for example, EIN or VAT number)."""
+    purchase_order_number: NotRequired[Nullable[str]]
+    r"""Invoice number or Purchase Order number."""
+    customer_reference_number: NotRequired[Nullable[str]]
+    r"""Customer code or reference."""
+    amount_includes_tax: NotRequired[Nullable[bool]]
+    r"""Whether the tax is included in the amount."""
+    supplier_order_number: NotRequired[Nullable[str]]
+    r"""The merchant's unique identifier for the sales order or invoice."""
+    duty_amount: NotRequired[Nullable[int]]
+    r"""Total charges for import/export duties."""
+    shipping_amount: NotRequired[Nullable[int]]
+    r"""Total shipping amount."""
 
 
 class Transaction(BaseModel):
@@ -174,7 +196,7 @@ class Transaction(BaseModel):
     amount: int
     r"""The total amount for this transaction across all funding sources including gift cards."""
 
-    status: Annotated[TransactionStatus, PlainValidator(validate_open_enum(False))]
+    status: TransactionStatus
 
     authorized_amount: int
     r"""The amount for this transaction that has been authorized for the `payment_method`. This can be less than the `amount` if gift cards were used."""
@@ -191,7 +213,7 @@ class Transaction(BaseModel):
     settled: bool
     r"""Indicates whether this transaction has been settled."""
 
-    intent: Annotated[TransactionIntent, PlainValidator(validate_open_enum(False))]
+    intent: TransactionIntent
 
     gift_card_redemptions: List[GiftCardRedemption]
     r"""The gift cards redeemed for this transaction."""
@@ -202,9 +224,10 @@ class Transaction(BaseModel):
     updated_at: datetime
     r"""The date and time when the transaction was last updated, in ISO 8601 format."""
 
-    payment_source: Annotated[
-        TransactionPaymentSource, PlainValidator(validate_open_enum(False))
-    ]
+    disputed: bool
+    r"""Indicates whether this transaction has been disputed."""
+
+    payment_source: TransactionPaymentSource
     r"""The way payment method information made it to this transaction."""
 
     merchant_initiated: bool
@@ -213,9 +236,7 @@ class Transaction(BaseModel):
     is_subsequent_payment: bool
     r"""Indicates whether the transaction represents a subsequent payment or an initial one."""
 
-    intent_outcome: Annotated[
-        TransactionIntentOutcome, PlainValidator(validate_open_enum(False))
-    ]
+    intent_outcome: TransactionIntentOutcome
 
     multi_tender: bool
     r"""The outcome of the original intent of a transaction. This allows you to understand if the intent of the transaction (e.g. `capture` or `authorize`) has been achieved when dealing with multiple payment instruments."""
@@ -244,14 +265,10 @@ class Transaction(BaseModel):
     payment_method: OptionalNullable[TransactionPaymentMethod] = UNSET
     r"""The payment method used for this transaction."""
 
-    method: Annotated[
-        OptionalNullable[Method], PlainValidator(validate_open_enum(False))
-    ] = UNSET
+    method: OptionalNullable[Method] = UNSET
     r"""The method used for the transaction."""
 
-    instrument_type: Annotated[
-        OptionalNullable[InstrumentType], PlainValidator(validate_open_enum(False))
-    ] = UNSET
+    instrument_type: OptionalNullable[InstrumentType] = UNSET
     r"""The name of the instrument used to process the transaction."""
 
     error_code: OptionalNullable[str] = UNSET
@@ -287,19 +304,13 @@ class Transaction(BaseModel):
     auth_response_code: OptionalNullable[str] = UNSET
     r"""This is the response description received from the processor."""
 
-    avs_response_code: Annotated[
-        OptionalNullable[AVSResponseCode], PlainValidator(validate_open_enum(False))
-    ] = UNSET
+    avs_response_code: OptionalNullable[AVSResponseCode] = UNSET
     r"""The response code received from the payment service for the Address Verification Check (AVS). This code is mapped to a standardized Gr4vy AVS response code."""
 
-    cvv_response_code: Annotated[
-        OptionalNullable[CVVResponseCode], PlainValidator(validate_open_enum(False))
-    ] = UNSET
+    cvv_response_code: OptionalNullable[CVVResponseCode] = UNSET
     r"""The response code received from the payment service for the Card Verification Value (CVV). This code is mapped to a standardized Gr4vy CVV response code."""
 
-    anti_fraud_decision: Annotated[
-        OptionalNullable[AntiFraudDecision], PlainValidator(validate_open_enum(False))
-    ] = UNSET
+    anti_fraud_decision: OptionalNullable[AntiFraudDecision] = UNSET
     r"""The mapped decision received from the anti-fraud service. In case of a review decision this field is not updated once the review is resolved."""
 
     cart_items: OptionalNullable[List[CartItem]] = UNSET
@@ -332,6 +343,9 @@ class Transaction(BaseModel):
     voided_at: OptionalNullable[datetime] = UNSET
     r"""The date this transaction was voided at."""
 
+    canceled_at: OptionalNullable[datetime] = UNSET
+    r"""The date this transaction was canceled at."""
+
     approval_expires_at: OptionalNullable[datetime] = UNSET
     r"""The date this transaction's approval URL will expire at."""
 
@@ -347,6 +361,33 @@ class Transaction(BaseModel):
     installment_count: OptionalNullable[int] = UNSET
     r"""The number of installments for this transaction, if applicable."""
 
+    session_token: OptionalNullable[str] = UNSET
+    r"""A session token that can be used to fetch session data for direct client integrations."""
+
+    tax_amount: OptionalNullable[int] = UNSET
+    r"""The sales tax amount for this transaction, represented as a monetary amount in the smallest currency unit for the given currency, for example `1299` cents to create an authorization for `$12.99`"""
+
+    merchant_tax_id: OptionalNullable[str] = UNSET
+    r"""Merchant tax ID (for example, EIN or VAT number)."""
+
+    purchase_order_number: OptionalNullable[str] = UNSET
+    r"""Invoice number or Purchase Order number."""
+
+    customer_reference_number: OptionalNullable[str] = UNSET
+    r"""Customer code or reference."""
+
+    amount_includes_tax: OptionalNullable[bool] = UNSET
+    r"""Whether the tax is included in the amount."""
+
+    supplier_order_number: OptionalNullable[str] = UNSET
+    r"""The merchant's unique identifier for the sales order or invoice."""
+
+    duty_amount: OptionalNullable[int] = UNSET
+    r"""Total charges for import/export duties."""
+
+    shipping_amount: OptionalNullable[int] = UNSET
+    r"""Total shipping amount."""
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = [
@@ -381,11 +422,21 @@ class Transaction(BaseModel):
             "authorized_at",
             "captured_at",
             "voided_at",
+            "canceled_at",
             "approval_expires_at",
             "buyer_approval_timedout_at",
             "recipient",
             "merchant_advice_code",
             "installment_count",
+            "session_token",
+            "tax_amount",
+            "merchant_tax_id",
+            "purchase_order_number",
+            "customer_reference_number",
+            "amount_includes_tax",
+            "supplier_order_number",
+            "duty_amount",
+            "shipping_amount",
         ]
         nullable_fields = [
             "settled_currency",
@@ -416,11 +467,21 @@ class Transaction(BaseModel):
             "authorized_at",
             "captured_at",
             "voided_at",
+            "canceled_at",
             "approval_expires_at",
             "buyer_approval_timedout_at",
             "recipient",
             "merchant_advice_code",
             "installment_count",
+            "session_token",
+            "tax_amount",
+            "merchant_tax_id",
+            "purchase_order_number",
+            "customer_reference_number",
+            "amount_includes_tax",
+            "supplier_order_number",
+            "duty_amount",
+            "shipping_amount",
         ]
         null_default_fields = []
 

gr4vy/models/transactionaction.py

@@ -0,0 +1,48 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .flow import Flow
+from .flowaction import FlowAction
+from datetime import datetime
+from gr4vy.types import BaseModel
+from gr4vy.utils import validate_const
+import pydantic
+from pydantic.functional_validators import AfterValidator
+from typing import Any, Dict, Literal, Optional
+from typing_extensions import Annotated, TypedDict
+
+
+class TransactionActionTypedDict(TypedDict):
+    id: FlowAction
+    flow: Flow
+    rule_id: str
+    r"""The ID of the rule that triggered this action."""
+    created_at: datetime
+    r"""The date this action was created at."""
+    outcome: Dict[str, Any]
+    r"""The outcome of the action."""
+    type: Literal["action"]
+    r"""Always `action`."""
+
+
+class TransactionAction(BaseModel):
+    id: FlowAction
+
+    flow: Flow
+
+    rule_id: str
+    r"""The ID of the rule that triggered this action."""
+
+    created_at: datetime
+    r"""The date this action was created at."""
+
+    outcome: Dict[str, Any]
+    r"""The outcome of the action."""
+
+    TYPE: Annotated[
+        Annotated[
+            Optional[Literal["action"]], AfterValidator(validate_const("action"))
+        ],
+        pydantic.Field(alias="type"),
+    ] = "action"
+    r"""Always `action`."""

gr4vy/models/transactionactions.py

@@ -0,0 +1,17 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .transactionaction import TransactionAction, TransactionActionTypedDict
+from gr4vy.types import BaseModel
+from typing import List
+from typing_extensions import TypedDict
+
+
+class TransactionActionsTypedDict(TypedDict):
+    items: List[TransactionActionTypedDict]
+    r"""The list of actions triggered for a transaction."""
+
+
+class TransactionActions(BaseModel):
+    items: List[TransactionAction]
+    r"""The list of actions triggered for a transaction."""