216 lines
8.0 KiB
Python
216 lines
8.0 KiB
Python
# -*- coding: utf-8 -*-
|
|
# File generated from our OpenAPI spec
|
|
from stripe._expandable_field import ExpandableField
|
|
from stripe._list_object import ListObject
|
|
from stripe._listable_api_resource import ListableAPIResource
|
|
from stripe._request_options import RequestOptions
|
|
from stripe._stripe_object import StripeObject
|
|
from typing import ClassVar, List, Optional
|
|
from typing_extensions import (
|
|
Literal,
|
|
NotRequired,
|
|
TypedDict,
|
|
Unpack,
|
|
TYPE_CHECKING,
|
|
)
|
|
|
|
if TYPE_CHECKING:
|
|
from stripe._charge import Charge
|
|
from stripe._invoice import Invoice
|
|
from stripe._payment_intent import PaymentIntent
|
|
|
|
|
|
class InvoicePayment(ListableAPIResource["InvoicePayment"]):
|
|
"""
|
|
Invoice Payments represent payments made against invoices. Invoice Payments can
|
|
be accessed in two ways:
|
|
1. By expanding the `payments` field on the [Invoice](https://stripe.com/docs/api#invoice) resource.
|
|
2. By using the Invoice Payment retrieve and list endpoints.
|
|
|
|
Invoice Payments include the mapping between payment objects, such as Payment Intent, and Invoices.
|
|
This resource and its endpoints allows you to easily track if a payment is associated with a specific invoice and
|
|
monitor the allocation details of the payments.
|
|
"""
|
|
|
|
OBJECT_NAME: ClassVar[Literal["invoice_payment"]] = "invoice_payment"
|
|
|
|
class Payment(StripeObject):
|
|
charge: Optional[ExpandableField["Charge"]]
|
|
"""
|
|
ID of the successful charge for this payment when `type` is `charge`.Note: charge is only surfaced if the charge object is not associated with a payment intent. If the charge object does have a payment intent, the Invoice Payment surfaces the payment intent instead.
|
|
"""
|
|
payment_intent: Optional[ExpandableField["PaymentIntent"]]
|
|
"""
|
|
ID of the PaymentIntent associated with this payment when `type` is `payment_intent`. Note: This property is only populated for invoices finalized on or after March 15th, 2019.
|
|
"""
|
|
type: Literal["charge", "payment_intent"]
|
|
"""
|
|
Type of payment object associated with this invoice payment.
|
|
"""
|
|
|
|
class StatusTransitions(StripeObject):
|
|
canceled_at: Optional[int]
|
|
"""
|
|
The time that the payment was canceled.
|
|
"""
|
|
paid_at: Optional[int]
|
|
"""
|
|
The time that the payment succeeded.
|
|
"""
|
|
|
|
class ListParams(RequestOptions):
|
|
ending_before: NotRequired[str]
|
|
"""
|
|
A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with `obj_bar`, your subsequent call can include `ending_before=obj_bar` in order to fetch the previous page of the list.
|
|
"""
|
|
expand: NotRequired[List[str]]
|
|
"""
|
|
Specifies which fields in the response should be expanded.
|
|
"""
|
|
invoice: NotRequired[str]
|
|
"""
|
|
The identifier of the invoice whose payments to return.
|
|
"""
|
|
limit: NotRequired[int]
|
|
"""
|
|
A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
|
|
"""
|
|
payment: NotRequired["InvoicePayment.ListParamsPayment"]
|
|
"""
|
|
The payment details of the invoice payments to return.
|
|
"""
|
|
starting_after: NotRequired[str]
|
|
"""
|
|
A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with `obj_foo`, your subsequent call can include `starting_after=obj_foo` in order to fetch the next page of the list.
|
|
"""
|
|
status: NotRequired[Literal["canceled", "open", "paid"]]
|
|
"""
|
|
The status of the invoice payments to return.
|
|
"""
|
|
|
|
class ListParamsPayment(TypedDict):
|
|
payment_intent: NotRequired[str]
|
|
"""
|
|
Only return invoice payments associated by this payment intent ID.
|
|
"""
|
|
type: Literal["payment_intent"]
|
|
"""
|
|
Only return invoice payments associated by this payment type.
|
|
"""
|
|
|
|
class RetrieveParams(RequestOptions):
|
|
expand: NotRequired[List[str]]
|
|
"""
|
|
Specifies which fields in the response should be expanded.
|
|
"""
|
|
|
|
amount_paid: Optional[int]
|
|
"""
|
|
Amount that was actually paid for this invoice, in cents (or local equivalent). This field is null until the payment is `paid`. This amount can be less than the `amount_requested` if the PaymentIntent's `amount_received` is not sufficient to pay all of the invoices that it is attached to.
|
|
"""
|
|
amount_requested: int
|
|
"""
|
|
Amount intended to be paid toward this invoice, in cents (or local equivalent)
|
|
"""
|
|
created: int
|
|
"""
|
|
Time at which the object was created. Measured in seconds since the Unix epoch.
|
|
"""
|
|
currency: str
|
|
"""
|
|
Three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html), in lowercase. Must be a [supported currency](https://stripe.com/docs/currencies).
|
|
"""
|
|
id: str
|
|
"""
|
|
Unique identifier for the object.
|
|
"""
|
|
invoice: ExpandableField["Invoice"]
|
|
"""
|
|
The invoice that was paid.
|
|
"""
|
|
is_default: bool
|
|
"""
|
|
Stripe automatically creates a default InvoicePayment when the invoice is finalized, and keeps it synchronized with the invoice's `amount_remaining`. The PaymentIntent associated with the default payment can't be edited or canceled directly.
|
|
"""
|
|
livemode: bool
|
|
"""
|
|
Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
|
|
"""
|
|
object: Literal["invoice_payment"]
|
|
"""
|
|
String representing the object's type. Objects of the same type share the same value.
|
|
"""
|
|
payment: Payment
|
|
status: str
|
|
"""
|
|
The status of the payment, one of `open`, `paid`, or `canceled`.
|
|
"""
|
|
status_transitions: StatusTransitions
|
|
|
|
@classmethod
|
|
def list(
|
|
cls, **params: Unpack["InvoicePayment.ListParams"]
|
|
) -> ListObject["InvoicePayment"]:
|
|
"""
|
|
When retrieving an invoice, there is an includable payments property containing the first handful of those items. There is also a URL where you can retrieve the full (paginated) list of payments.
|
|
"""
|
|
result = cls._static_request(
|
|
"get",
|
|
cls.class_url(),
|
|
params=params,
|
|
)
|
|
if not isinstance(result, ListObject):
|
|
raise TypeError(
|
|
"Expected list object from API, got %s"
|
|
% (type(result).__name__)
|
|
)
|
|
|
|
return result
|
|
|
|
@classmethod
|
|
async def list_async(
|
|
cls, **params: Unpack["InvoicePayment.ListParams"]
|
|
) -> ListObject["InvoicePayment"]:
|
|
"""
|
|
When retrieving an invoice, there is an includable payments property containing the first handful of those items. There is also a URL where you can retrieve the full (paginated) list of payments.
|
|
"""
|
|
result = await cls._static_request_async(
|
|
"get",
|
|
cls.class_url(),
|
|
params=params,
|
|
)
|
|
if not isinstance(result, ListObject):
|
|
raise TypeError(
|
|
"Expected list object from API, got %s"
|
|
% (type(result).__name__)
|
|
)
|
|
|
|
return result
|
|
|
|
@classmethod
|
|
def retrieve(
|
|
cls, id: str, **params: Unpack["InvoicePayment.RetrieveParams"]
|
|
) -> "InvoicePayment":
|
|
"""
|
|
Retrieves the invoice payment with the given ID.
|
|
"""
|
|
instance = cls(id, **params)
|
|
instance.refresh()
|
|
return instance
|
|
|
|
@classmethod
|
|
async def retrieve_async(
|
|
cls, id: str, **params: Unpack["InvoicePayment.RetrieveParams"]
|
|
) -> "InvoicePayment":
|
|
"""
|
|
Retrieves the invoice payment with the given ID.
|
|
"""
|
|
instance = cls(id, **params)
|
|
await instance.refresh_async()
|
|
return instance
|
|
|
|
_inner_class_types = {
|
|
"payment": Payment,
|
|
"status_transitions": StatusTransitions,
|
|
}
|