@type amount_details() :: %{
  optional(:discount_amount) => integer() | nil,
  optional(:error) => amount_details_error() | nil,
  optional(:line_items) => amount_details_line_items() | nil,
  optional(:shipping) => amount_details_shipping() | nil,
  optional(:tax) => amount_details_tax() | nil,
  optional(:tip) => amount_details_tip() | nil,
  optional(String.t()) => term()
}

• discount_amount - The total discount applied on the transaction represented in the smallest currency unit. An integer greater than 0.

This field is mutually exclusive with the amount_details[line_items][#][discount_amount] field.

• error
• line_items - A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 200 line items.
• shipping
• tax
• tip

@type amount_details_error() :: %{
  optional(:code) => String.t() | nil,
  optional(:message) => String.t() | nil,
  optional(String.t()) => term()
}

• code - The code of the error that occurred when validating the current amount details. Possible values: amount_details_amount_mismatch, amount_details_tax_shipping_discount_greater_than_amount. Nullable.
• message - A message providing more details about the error. Max length: 5000. Nullable.

@type amount_details_line_items() :: %{
  optional(:data) =>
    [Stripe.Resources.PaymentIntentAmountDetailsLineItem.t()] | nil,
  optional(:has_more) => boolean() | nil,
  optional(:object) => String.t() | nil,
  optional(:url) => String.t() | nil,
  optional(String.t()) => term()
}

• data - Details about each object.
• has_more - True if this list has another page of items after this one that can be fetched.
• object - String representing the object's type. Objects of the same type share the same value. Always has the value list. Possible values: list.
• url - The URL where this list can be accessed. Max length: 5000.

@type amount_details_shipping() :: %{
  optional(:amount) => integer() | nil,
  optional(:from_postal_code) => String.t() | nil,
  optional(:to_postal_code) => String.t() | nil,
  optional(String.t()) => term()
}

• amount - If a physical good is being shipped, the cost of shipping represented in the smallest currency unit. An integer greater than or equal to 0. Nullable.
• from_postal_code - If a physical good is being shipped, the postal code of where it is being shipped from. At most 10 alphanumeric characters long, hyphens are allowed. Max length: 5000. Nullable.
• to_postal_code - If a physical good is being shipped, the postal code of where it is being shipped to. At most 10 alphanumeric characters long, hyphens are allowed. Max length: 5000. Nullable.

@type amount_details_tax() :: %{
  optional(:total_tax_amount) => integer() | nil,
  optional(String.t()) => term()
}

• total_tax_amount - The total amount of tax on the transaction represented in the smallest currency unit. Required for L2 rates. An integer greater than or equal to 0.

This field is mutually exclusive with the amount_details[line_items][#][tax][total_tax_amount] field. Nullable.

@type amount_details_tip() :: %{
  optional(:amount) => integer() | nil,
  optional(String.t()) => term()
}

• amount - Portion of the amount that corresponds to a tip.

@type automatic_payment_methods() :: %{
  optional(:allow_redirects) => String.t() | nil,
  optional(:enabled) => boolean() | nil,
  optional(String.t()) => term()
}

• allow_redirects - Controls whether this PaymentIntent will accept redirect-based payment methods.

Redirect-based payment methods may require your customer to be redirected to a payment method's app or site for authentication or additional steps. To confirm this PaymentIntent, you may be required to provide a return_url to redirect customers back to your site after they authenticate or complete the payment. Possible values: always, never.

• enabled - Automatically calculates compatible payment methods

@type hooks() :: %{
  optional(:inputs) => hooks_inputs() | nil,
  optional(String.t()) => term()
}

• inputs

@type hooks_inputs() :: %{
  optional(:tax) => hooks_inputs_tax() | nil,
  optional(String.t()) => term()
}

• tax

@type hooks_inputs_tax() :: %{
  optional(:calculation) => String.t() | nil,
  optional(String.t()) => term()
}

• calculation - The TaxCalculation id Max length: 5000.

@type next_action() :: %{
  optional(:alipay_handle_redirect) =>
    Stripe.Resources.NextActionAlipayHandleRedirect.t() | nil,
  optional(:boleto_display_details) =>
    Stripe.Resources.NextActionDisplayBoletoDetails.t() | nil,
  optional(:card_await_notification) =>
    Stripe.Resources.NextActionCardAwaitNotification.t() | nil,
  optional(:cashapp_handle_redirect_or_display_qr_code) =>
    Stripe.Resources.CashappHandleRedirectOrDisplayQrCode.t() | nil,
  optional(:display_bank_transfer_instructions) =>
    Stripe.Resources.NextActionDisplayBankTransferInstructions.t() | nil,
  optional(:konbini_display_details) =>
    Stripe.Resources.NextActionKonbiniDisplayDetails.t() | nil,
  optional(:multibanco_display_details) =>
    Stripe.Resources.NextActionMultibancoDisplayDetails.t() | nil,
  optional(:oxxo_display_details) =>
    Stripe.Resources.NextActionOxxoDisplayDetails.t() | nil,
  optional(:paynow_display_qr_code) =>
    Stripe.Resources.PaynowDisplayQrCode.t() | nil,
  optional(:pix_display_qr_code) => Stripe.Resources.PixDisplayQrCode.t() | nil,
  optional(:promptpay_display_qr_code) =>
    Stripe.Resources.PromptpayDisplayQrCode.t() | nil,
  optional(:redirect_to_url) =>
    Stripe.Resources.NextActionRedirectToUrl.t() | nil,
  optional(:swish_handle_redirect_or_display_qr_code) =>
    Stripe.Resources.SwishHandleRedirectOrDisplayQrCode.t() | nil,
  optional(:type) => String.t() | nil,
  optional(:use_stripe_sdk) => map() | nil,
  optional(:verify_with_microdeposits) =>
    next_action_verify_with_microdeposits() | nil,
  optional(:wechat_pay_display_qr_code) =>
    Stripe.Resources.WechatPayDisplayQrCode.t() | nil,
  optional(:wechat_pay_redirect_to_android_app) =>
    Stripe.Resources.WechatPayRedirectToAndroidApp.t() | nil,
  optional(:wechat_pay_redirect_to_ios_app) =>
    Stripe.Resources.WechatPayRedirectToIosApp.t() | nil,
  optional(String.t()) => term()
}

• alipay_handle_redirect
• boleto_display_details
• card_await_notification
• cashapp_handle_redirect_or_display_qr_code
• display_bank_transfer_instructions
• konbini_display_details
• multibanco_display_details
• oxxo_display_details
• paynow_display_qr_code
• pix_display_qr_code
• promptpay_display_qr_code
• redirect_to_url
• swish_handle_redirect_or_display_qr_code
• type - Type of the next action to perform. Refer to the other child attributes under next_action for available values. Examples include: redirect_to_url, use_stripe_sdk, alipay_handle_redirect, oxxo_display_details, or verify_with_microdeposits. Max length: 5000.
• use_stripe_sdk - When confirming a PaymentIntent with Stripe.js, Stripe.js depends on the contents of this dictionary to invoke authentication flows. The shape of the contents is subject to change and is only intended to be used by Stripe.js.
• verify_with_microdeposits
• wechat_pay_display_qr_code
• wechat_pay_redirect_to_android_app
• wechat_pay_redirect_to_ios_app

@type next_action_verify_with_microdeposits() :: %{
  optional(:arrival_date) => integer() | nil,
  optional(:hosted_verification_url) => String.t() | nil,
  optional(:microdeposit_type) => String.t() | nil,
  optional(String.t()) => term()
}

• arrival_date - The timestamp when the microdeposits are expected to land. Format: Unix timestamp.
• hosted_verification_url - The URL for the hosted verification page, which allows customers to verify their bank account. Max length: 5000.
• microdeposit_type - The type of the microdeposit sent to the customer. Used to distinguish between different verification methods. Possible values: amounts, descriptor_code. Nullable.

@type payment_details() :: %{
  optional(:customer_reference) => String.t() | nil,
  optional(:order_reference) => String.t() | nil,
  optional(String.t()) => term()
}

• customer_reference - A unique value to identify the customer. This field is available only for card payments.

This field is truncated to 25 alphanumeric characters, excluding spaces, before being sent to card networks. Max length: 5000. Nullable.

• order_reference - A unique value assigned by the business to identify the transaction. Required for L2 and L3 rates.

Required when the Payment Method Types array contains card, including when automatic_payment_methods.enabled is set to true.

For Cards, this field is truncated to 25 alphanumeric characters, excluding spaces, before being sent to card networks. For Klarna, this field is truncated to 255 characters and is visible to customers when they view the order in the Klarna app. Max length: 5000. Nullable.

@type payment_method_configuration_details() :: %{
  optional(:id) => String.t() | nil,
  optional(:parent) => String.t() | nil,
  optional(String.t()) => term()
}

• id - ID of the payment method configuration used. Max length: 5000.
• parent - ID of the parent payment method configuration used. Max length: 5000. Nullable.

@type payment_method_options() :: %{
  optional(:acss_debit) => payment_method_options_acss_debit() | nil,
  optional(:affirm) => payment_method_options_affirm() | nil,
  optional(:afterpay_clearpay) =>
    payment_method_options_afterpay_clearpay() | nil,
  optional(:alipay) => payment_method_options_alipay() | nil,
  optional(:alma) => payment_method_options_alma() | nil,
  optional(:amazon_pay) => payment_method_options_amazon_pay() | nil,
  optional(:au_becs_debit) => payment_method_options_au_becs_debit() | nil,
  optional(:bacs_debit) => payment_method_options_bacs_debit() | nil,
  optional(:bancontact) => payment_method_options_bancontact() | nil,
  optional(:billie) => payment_method_options_billie() | nil,
  optional(:blik) => payment_method_options_blik() | nil,
  optional(:boleto) => payment_method_options_boleto() | nil,
  optional(:card) => payment_method_options_card() | nil,
  optional(:card_present) => payment_method_options_card_present() | nil,
  optional(:cashapp) => payment_method_options_cashapp() | nil,
  optional(:crypto) => payment_method_options_crypto() | nil,
  optional(:customer_balance) =>
    payment_method_options_customer_balance() | nil,
  optional(:eps) => payment_method_options_eps() | nil,
  optional(:fpx) => payment_method_options_fpx() | nil,
  optional(:giropay) => payment_method_options_giropay() | nil,
  optional(:grabpay) => payment_method_options_grabpay() | nil,
  optional(:ideal) => payment_method_options_ideal() | nil,
  optional(:interac_present) => map() | nil,
  optional(:kakao_pay) => payment_method_options_kakao_pay() | nil,
  optional(:klarna) => payment_method_options_klarna() | nil,
  optional(:konbini) => payment_method_options_konbini() | nil,
  optional(:kr_card) => payment_method_options_kr_card() | nil,
  optional(:link) => payment_method_options_link() | nil,
  optional(:mb_way) => payment_method_options_mb_way() | nil,
  optional(:mobilepay) => payment_method_options_mobilepay() | nil,
  optional(:multibanco) => payment_method_options_multibanco() | nil,
  optional(:naver_pay) => payment_method_options_naver_pay() | nil,
  optional(:nz_bank_account) => payment_method_options_nz_bank_account() | nil,
  optional(:oxxo) => payment_method_options_oxxo() | nil,
  optional(:p24) => payment_method_options_p24() | nil,
  optional(:pay_by_bank) => map() | nil,
  optional(:payco) => payment_method_options_payco() | nil,
  optional(:paynow) => payment_method_options_paynow() | nil,
  optional(:paypal) => payment_method_options_paypal() | nil,
  optional(:payto) => payment_method_options_payto() | nil,
  optional(:pix) => payment_method_options_pix() | nil,
  optional(:promptpay) => payment_method_options_promptpay() | nil,
  optional(:revolut_pay) => payment_method_options_revolut_pay() | nil,
  optional(:samsung_pay) => payment_method_options_samsung_pay() | nil,
  optional(:satispay) => payment_method_options_satispay() | nil,
  optional(:sepa_debit) => payment_method_options_sepa_debit() | nil,
  optional(:sofort) => payment_method_options_sofort() | nil,
  optional(:swish) => payment_method_options_swish() | nil,
  optional(:twint) => payment_method_options_twint() | nil,
  optional(:us_bank_account) => payment_method_options_us_bank_account() | nil,
  optional(:wechat_pay) => payment_method_options_wechat_pay() | nil,
  optional(:zip) => payment_method_options_zip() | nil,
  optional(String.t()) => term()
}

• acss_debit
• affirm
• afterpay_clearpay
• alipay
• alma
• amazon_pay
• au_becs_debit
• bacs_debit
• bancontact
• billie
• blik
• boleto
• card
• card_present
• cashapp
• crypto
• customer_balance
• eps
• fpx
• giropay
• grabpay
• ideal
• interac_present
• kakao_pay
• klarna
• konbini
• kr_card
• link
• mb_way
• mobilepay
• multibanco
• naver_pay
• nz_bank_account
• oxxo
• p24
• pay_by_bank
• payco
• paynow
• paypal
• payto
• pix
• promptpay
• revolut_pay
• samsung_pay
• satispay
• sepa_debit
• sofort
• swish
• twint
• us_bank_account
• wechat_pay
• zip

@type payment_method_options_acss_debit() :: %{
  optional(:mandate_options) =>
    payment_method_options_acss_debit_mandate_options() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(:target_date) => String.t() | nil,
  optional(:verification_method) => String.t() | nil,
  optional(String.t()) => term()
}

• mandate_options
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none, off_session, on_session.

• target_date - Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now. Max length: 5000.
• verification_method - Bank account verification method. Possible values: automatic, instant, microdeposits.

@type payment_method_options_acss_debit_mandate_options() :: %{
  optional(:custom_mandate_url) => String.t() | nil,
  optional(:interval_description) => String.t() | nil,
  optional(:payment_schedule) => String.t() | nil,
  optional(:transaction_type) => String.t() | nil,
  optional(String.t()) => term()
}

• custom_mandate_url - A URL for custom mandate text Max length: 5000.
• interval_description - Description of the interval. Only required if the 'payment_schedule' parameter is 'interval' or 'combined'. Max length: 5000. Nullable.
• payment_schedule - Payment schedule for the mandate. Possible values: combined, interval, sporadic. Nullable.
• transaction_type - Transaction type of the mandate. Possible values: business, personal. Nullable.

@type payment_method_options_affirm() :: %{
  optional(:capture_method) => String.t() | nil,
  optional(:preferred_locale) => String.t() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• capture_method - Controls when the funds will be captured from the customer's account. Possible values: manual.
• preferred_locale - Preferred language of the Affirm authorization page that the customer is redirected to. Max length: 30.
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none.

@type payment_method_options_afterpay_clearpay() :: %{
  optional(:capture_method) => String.t() | nil,
  optional(:reference) => String.t() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• capture_method - Controls when the funds will be captured from the customer's account. Possible values: manual.
• reference - An internal identifier or reference that this payment corresponds to. You must limit the identifier to 128 characters, and it can only contain letters, numbers, underscores, backslashes, and dashes. This field differs from the statement descriptor and item name. Max length: 5000. Nullable.
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none.

@type payment_method_options_alipay() :: %{
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none, off_session.

@type payment_method_options_alma() :: %{
  optional(:capture_method) => String.t() | nil,
  optional(String.t()) => term()
}

• capture_method - Controls when the funds will be captured from the customer's account. Possible values: manual.

@type payment_method_options_amazon_pay() :: %{
  optional(:capture_method) => String.t() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• capture_method - Controls when the funds will be captured from the customer's account. Possible values: manual.
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none, off_session.

@type payment_method_options_au_becs_debit() :: %{
  optional(:setup_future_usage) => String.t() | nil,
  optional(:target_date) => String.t() | nil,
  optional(String.t()) => term()
}

• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none, off_session, on_session.

• target_date - Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now. Max length: 5000.

@type payment_method_options_bacs_debit() :: %{
  optional(:mandate_options) =>
    Stripe.Resources.BacsDebitMandateOptions.t() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(:target_date) => String.t() | nil,
  optional(String.t()) => term()
}

• mandate_options
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none, off_session, on_session.

• target_date - Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now. Max length: 5000.

@type payment_method_options_bancontact() :: %{
  optional(:preferred_language) => String.t() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• preferred_language - Preferred language of the Bancontact authorization page that the customer is redirected to. Possible values: de, en, fr, nl.
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none, off_session.

@type payment_method_options_billie() :: %{
  optional(:capture_method) => String.t() | nil,
  optional(String.t()) => term()
}

• capture_method - Controls when the funds will be captured from the customer's account. Possible values: manual.

@type payment_method_options_blik() :: %{
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none.

@type payment_method_options_boleto() :: %{
  optional(:expires_after_days) => integer() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• expires_after_days - The number of calendar days before a Boleto voucher expires. For example, if you create a Boleto voucher on Monday and you set expires_after_days to 2, the Boleto voucher will expire on Wednesday at 23:59 America/Sao_Paulo time.
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none, off_session, on_session.

@type payment_method_options_card() :: %{
  optional(:capture_method) => String.t() | nil,
  optional(:installments) => payment_method_options_card_installments() | nil,
  optional(:mandate_options) => Stripe.Resources.MandateOptions.t() | nil,
  optional(:network) => String.t() | nil,
  optional(:request_extended_authorization) => String.t() | nil,
  optional(:request_incremental_authorization) => String.t() | nil,
  optional(:request_multicapture) => String.t() | nil,
  optional(:request_overcapture) => String.t() | nil,
  optional(:request_three_d_secure) => String.t() | nil,
  optional(:require_cvc_recollection) => boolean() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(:statement_descriptor_suffix_kana) => String.t() | nil,
  optional(:statement_descriptor_suffix_kanji) => String.t() | nil,
  optional(String.t()) => term()
}

• capture_method - Controls when the funds will be captured from the customer's account. Possible values: manual.
• installments - Installment details for this payment.

For more information, see the installments integration guide. Nullable.

• mandate_options - Configuration options for setting up an eMandate for cards issued in India. Nullable.
• network - Selected network to process this payment intent on. Depends on the available networks of the card attached to the payment intent. Can be only set confirm-time. Possible values: amex, cartes_bancaires, diners, discover, eftpos_au, girocard, interac, jcb, link, mastercard, unionpay, unknown, visa. Nullable.
• request_extended_authorization - Request ability to capture beyond the standard authorization validity window for this PaymentIntent. Possible values: if_available, never.
• request_incremental_authorization - Request ability to increment the authorization for this PaymentIntent. Possible values: if_available, never.
• request_multicapture - Request ability to make multiple captures for this PaymentIntent. Possible values: if_available, never.
• request_overcapture - Request ability to overcapture for this PaymentIntent. Possible values: if_available, never.
• request_three_d_secure - We strongly recommend that you rely on our SCA Engine to automatically prompt your customers for authentication based on risk level and other requirements. However, if you wish to request 3D Secure based on logic from your own fraud engine, provide this option. If not provided, this value defaults to automatic. Read our guide on manually requesting 3D Secure for more information on how this configuration interacts with Radar and our SCA Engine. Possible values: any, automatic, challenge. Nullable.
• require_cvc_recollection - When enabled, using a card that is attached to a customer will require the CVC to be provided again (i.e. using the cvc_token parameter).
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none, off_session, on_session.

• statement_descriptor_suffix_kana - Provides information about a card payment that customers see on their statements. Concatenated with the Kana prefix (shortened Kana descriptor) or Kana statement descriptor that’s set on the account to form the complete statement descriptor. Maximum 22 characters. On card statements, the concatenation of both prefix and suffix (including separators) will appear truncated to 22 characters. Max length: 5000.
• statement_descriptor_suffix_kanji - Provides information about a card payment that customers see on their statements. Concatenated with the Kanji prefix (shortened Kanji descriptor) or Kanji statement descriptor that’s set on the account to form the complete statement descriptor. Maximum 17 characters. On card statements, the concatenation of both prefix and suffix (including separators) will appear truncated to 17 characters. Max length: 5000.

@type payment_method_options_card_installments() :: %{
  optional(:available_plans) =>
    [payment_method_options_card_installments_available_plans()] | nil,
  optional(:enabled) => boolean() | nil,
  optional(:plan) => payment_method_options_card_installments_plan() | nil,
  optional(String.t()) => term()
}

• available_plans - Installment plans that may be selected for this PaymentIntent. Nullable.
• enabled - Whether Installments are enabled for this PaymentIntent.
• plan - Installment plan selected for this PaymentIntent. Nullable.

@type payment_method_options_card_installments_available_plans() :: %{
  optional(:count) => integer() | nil,
  optional(:interval) => String.t() | nil,
  optional(:type) => String.t() | nil,
  optional(String.t()) => term()
}

• count - For fixed_count installment plans, this is the number of installment payments your customer will make to their credit card. Nullable.
• interval - For fixed_count installment plans, this is the interval between installment payments your customer will make to their credit card. One of month. Possible values: month. Nullable.
• type - Type of installment plan, one of fixed_count, bonus, or revolving. Possible values: bonus, fixed_count, revolving.

@type payment_method_options_card_installments_plan() :: %{
  optional(:count) => integer() | nil,
  optional(:interval) => String.t() | nil,
  optional(:type) => String.t() | nil,
  optional(String.t()) => term()
}

• count - For fixed_count installment plans, this is the number of installment payments your customer will make to their credit card. Nullable.
• interval - For fixed_count installment plans, this is the interval between installment payments your customer will make to their credit card. One of month. Possible values: month. Nullable.
• type - Type of installment plan, one of fixed_count, bonus, or revolving. Possible values: bonus, fixed_count, revolving.

@type payment_method_options_card_present() :: %{
  optional(:capture_method) => String.t() | nil,
  optional(:request_extended_authorization) => boolean() | nil,
  optional(:request_incremental_authorization_support) => boolean() | nil,
  optional(:routing) => Stripe.Resources.Routing.t() | nil,
  optional(String.t()) => term()
}

• capture_method - Controls when the funds will be captured from the customer's account. Possible values: manual, manual_preferred.
• request_extended_authorization - Request ability to capture this payment beyond the standard authorization validity window Nullable.
• request_incremental_authorization_support - Request ability to increment this PaymentIntent if the combination of MCC and card brand is eligible. Check incremental_authorization_supported in the Confirm response to verify support. Nullable.
• routing

@type payment_method_options_cashapp() :: %{
  optional(:capture_method) => String.t() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• capture_method - Controls when the funds will be captured from the customer's account. Possible values: manual.
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none, off_session, on_session.

@type payment_method_options_crypto() :: %{
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none.

@type payment_method_options_customer_balance() :: %{
  optional(:bank_transfer) =>
    payment_method_options_customer_balance_bank_transfer() | nil,
  optional(:funding_type) => String.t() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• bank_transfer
• funding_type - The funding method type to be used when there are not enough funds in the customer balance. Permitted values include: bank_transfer. Possible values: bank_transfer. Nullable.
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none.

@type payment_method_options_customer_balance_bank_transfer() :: %{
  optional(:eu_bank_transfer) =>
    payment_method_options_customer_balance_bank_transfer_eu_bank_transfer()
    | nil,
  optional(:requested_address_types) => [String.t()] | nil,
  optional(:type) => String.t() | nil,
  optional(String.t()) => term()
}

• eu_bank_transfer
• requested_address_types - List of address types that should be returned in the financial_addresses response. If not specified, all valid types will be returned.

Permitted values include: sort_code, zengin, iban, or spei.

• type - The bank transfer type that this PaymentIntent is allowed to use for funding Permitted values include: eu_bank_transfer, gb_bank_transfer, jp_bank_transfer, mx_bank_transfer, or us_bank_transfer. Possible values: eu_bank_transfer, gb_bank_transfer, jp_bank_transfer, mx_bank_transfer, us_bank_transfer. Nullable.

@type payment_method_options_customer_balance_bank_transfer_eu_bank_transfer() :: %{
  optional(:country) => String.t() | nil,
  optional(String.t()) => term()
}

• country - The desired country code of the bank account information. Permitted values include: BE, DE, ES, FR, IE, or NL. Possible values: BE, DE, ES, FR, IE, NL.

@type payment_method_options_eps() :: %{
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none.

@type payment_method_options_fpx() :: %{
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none.

@type payment_method_options_giropay() :: %{
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none.

@type payment_method_options_grabpay() :: %{
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none.

@type payment_method_options_ideal() :: %{
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none, off_session.

@type payment_method_options_kakao_pay() :: %{
  optional(:capture_method) => String.t() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• capture_method - Controls when the funds will be captured from the customer's account. Possible values: manual.
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none, off_session.

@type payment_method_options_klarna() :: %{
  optional(:capture_method) => String.t() | nil,
  optional(:preferred_locale) => String.t() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• capture_method - Controls when the funds will be captured from the customer's account. Possible values: manual.
• preferred_locale - Preferred locale of the Klarna checkout page that the customer is redirected to. Max length: 5000. Nullable.
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none, off_session, on_session.

@type payment_method_options_konbini() :: %{
  optional(:confirmation_number) => String.t() | nil,
  optional(:expires_after_days) => integer() | nil,
  optional(:expires_at) => integer() | nil,
  optional(:product_description) => String.t() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• confirmation_number - An optional 10 to 11 digit numeric-only string determining the confirmation code at applicable convenience stores. Max length: 5000. Nullable.
• expires_after_days - The number of calendar days (between 1 and 60) after which Konbini payment instructions will expire. For example, if a PaymentIntent is confirmed with Konbini and expires_after_days set to 2 on Monday JST, the instructions will expire on Wednesday 23:59:59 JST. Nullable.
• expires_at - The timestamp at which the Konbini payment instructions will expire. Only one of expires_after_days or expires_at may be set. Format: Unix timestamp. Nullable.
• product_description - A product descriptor of up to 22 characters, which will appear to customers at the convenience store. Max length: 5000. Nullable.
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none.

@type payment_method_options_kr_card() :: %{
  optional(:capture_method) => String.t() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• capture_method - Controls when the funds will be captured from the customer's account. Possible values: manual.
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none, off_session.

@type payment_method_options_link() :: %{
  optional(:capture_method) => String.t() | nil,
  optional(:persistent_token) => String.t() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• capture_method - Controls when the funds will be captured from the customer's account. Possible values: manual.
• persistent_token - [Deprecated] This is a legacy parameter that no longer has any function. Max length: 5000. Nullable.
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none, off_session.

@type payment_method_options_mb_way() :: %{
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none.

@type payment_method_options_mobilepay() :: %{
  optional(:capture_method) => String.t() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• capture_method - Controls when the funds will be captured from the customer's account. Possible values: manual.
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none.

@type payment_method_options_multibanco() :: %{
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none.

@type payment_method_options_naver_pay() :: %{
  optional(:capture_method) => String.t() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• capture_method - Controls when the funds will be captured from the customer's account. Possible values: manual.
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none, off_session.

@type payment_method_options_nz_bank_account() :: %{
  optional(:setup_future_usage) => String.t() | nil,
  optional(:target_date) => String.t() | nil,
  optional(String.t()) => term()
}

• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none, off_session, on_session.

• target_date - Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now. Max length: 5000.

@type payment_method_options_oxxo() :: %{
  optional(:expires_after_days) => integer() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• expires_after_days - The number of calendar days before an OXXO invoice expires. For example, if you create an OXXO invoice on Monday and you set expires_after_days to 2, the OXXO invoice will expire on Wednesday at 23:59 America/Mexico_City time.
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none.

@type payment_method_options_p24() :: %{
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none.

@type payment_method_options_payco() :: %{
  optional(:capture_method) => String.t() | nil,
  optional(String.t()) => term()
}

• capture_method - Controls when the funds will be captured from the customer's account. Possible values: manual.

@type payment_method_options_paynow() :: %{
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none.

@type payment_method_options_paypal() :: %{
  optional(:capture_method) => String.t() | nil,
  optional(:preferred_locale) => String.t() | nil,
  optional(:reference) => String.t() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• capture_method - Controls when the funds will be captured from the customer's account. Possible values: manual.
• preferred_locale - Preferred locale of the PayPal checkout page that the customer is redirected to. Max length: 5000. Nullable.
• reference - A reference of the PayPal transaction visible to customer which is mapped to PayPal's invoice ID. This must be a globally unique ID if you have configured in your PayPal settings to block multiple payments per invoice ID. Max length: 5000. Nullable.
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none, off_session.

@type payment_method_options_payto() :: %{
  optional(:mandate_options) =>
    payment_method_options_payto_mandate_options() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• mandate_options
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none, off_session.

@type payment_method_options_payto_mandate_options() :: %{
  optional(:amount) => integer() | nil,
  optional(:amount_type) => String.t() | nil,
  optional(:end_date) => String.t() | nil,
  optional(:payment_schedule) => String.t() | nil,
  optional(:payments_per_period) => integer() | nil,
  optional(:purpose) => String.t() | nil,
  optional(String.t()) => term()
}

• amount - Amount that will be collected. It is required when amount_type is fixed. Nullable.
• amount_type - The type of amount that will be collected. The amount charged must be exact or up to the value of amount param for fixed or maximum type respectively. Defaults to maximum. Possible values: fixed, maximum. Nullable.
• end_date - Date, in YYYY-MM-DD format, after which payments will not be collected. Defaults to no end date. Max length: 5000. Nullable.
• payment_schedule - The periodicity at which payments will be collected. Defaults to adhoc. Possible values: adhoc, annual, daily, fortnightly, monthly, quarterly, semi_annual, weekly. Nullable.
• payments_per_period - The number of payments that will be made during a payment period. Defaults to 1 except for when payment_schedule is adhoc. In that case, it defaults to no limit. Nullable.
• purpose - The purpose for which payments are made. Has a default value based on your merchant category code. Possible values: dependant_support, government, loan, mortgage, other, pension, personal, retail, salary, tax, utility. Nullable.

@type payment_method_options_pix() :: %{
  optional(:amount_includes_iof) => String.t() | nil,
  optional(:expires_after_seconds) => integer() | nil,
  optional(:expires_at) => integer() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• amount_includes_iof - Determines if the amount includes the IOF tax. Possible values: always, never.
• expires_after_seconds - The number of seconds (between 10 and 1209600) after which Pix payment will expire. Nullable.
• expires_at - The timestamp at which the Pix expires. Nullable.
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none.

@type payment_method_options_promptpay() :: %{
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none.

@type payment_method_options_revolut_pay() :: %{
  optional(:capture_method) => String.t() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• capture_method - Controls when the funds will be captured from the customer's account. Possible values: manual.
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none, off_session.

@type payment_method_options_samsung_pay() :: %{
  optional(:capture_method) => String.t() | nil,
  optional(String.t()) => term()
}

• capture_method - Controls when the funds will be captured from the customer's account. Possible values: manual.

@type payment_method_options_satispay() :: %{
  optional(:capture_method) => String.t() | nil,
  optional(String.t()) => term()
}

• capture_method - Controls when the funds will be captured from the customer's account. Possible values: manual.

@type payment_method_options_sepa_debit() :: %{
  optional(:mandate_options) =>
    Stripe.Resources.SepaDebitMandateOptions.t() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(:target_date) => String.t() | nil,
  optional(String.t()) => term()
}

• mandate_options
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none, off_session, on_session.

• target_date - Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now. Max length: 5000.

@type payment_method_options_sofort() :: %{
  optional(:preferred_language) => String.t() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• preferred_language - Preferred language of the SOFORT authorization page that the customer is redirected to. Possible values: de, en, es, fr, it, nl, pl. Nullable.
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none, off_session.

@type payment_method_options_swish() :: %{
  optional(:reference) => String.t() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• reference - A reference for this payment to be displayed in the Swish app. Max length: 35. Nullable.
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none.

@type payment_method_options_twint() :: %{
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none.

@type payment_method_options_us_bank_account() :: %{
  optional(:financial_connections) =>
    payment_method_options_us_bank_account_financial_connections() | nil,
  optional(:mandate_options) =>
    payment_method_options_us_bank_account_mandate_options() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(:target_date) => String.t() | nil,
  optional(:verification_method) => String.t() | nil,
  optional(String.t()) => term()
}

• financial_connections
• mandate_options
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none, off_session, on_session.

• target_date - Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now. Max length: 5000.
• verification_method - Bank account verification method. Possible values: automatic, instant, microdeposits.

@type payment_method_options_us_bank_account_financial_connections() :: %{
  optional(:filters) =>
    payment_method_options_us_bank_account_financial_connections_filters() | nil,
  optional(:permissions) => [String.t()] | nil,
  optional(:prefetch) => [String.t()] | nil,
  optional(:return_url) => String.t() | nil,
  optional(String.t()) => term()
}

• filters
• permissions - The list of permissions to request. The payment_method permission must be included.
• prefetch - Data features requested to be retrieved upon account creation. Nullable.
• return_url - For webview integrations only. Upon completing OAuth login in the native browser, the user will be redirected to this URL to return to your app. Max length: 5000.

@type payment_method_options_us_bank_account_financial_connections_filters() :: %{
  optional(:account_subcategories) => [String.t()] | nil,
  optional(String.t()) => term()
}

• account_subcategories - The account subcategories to use to filter for possible accounts to link. Valid subcategories are checking and savings.

@type payment_method_options_us_bank_account_mandate_options() :: %{
  optional(:collection_method) => String.t() | nil,
  optional(String.t()) => term()
}

• collection_method - Mandate collection method Possible values: paper.

@type payment_method_options_wechat_pay() :: %{
  optional(:app_id) => String.t() | nil,
  optional(:client) => String.t() | nil,
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• app_id - The app ID registered with WeChat Pay. Only required when client is ios or android. Max length: 5000. Nullable.
• client - The client type that the end customer will pay from Possible values: android, ios, web. Nullable.
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none.

@type payment_method_options_zip() :: %{
  optional(:setup_future_usage) => String.t() | nil,
  optional(String.t()) => term()
}

• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: none.

@type presentment_details() :: %{
  optional(:presentment_amount) => integer() | nil,
  optional(:presentment_currency) => String.t() | nil,
  optional(String.t()) => term()
}

• presentment_amount - Amount intended to be collected by this payment, denominated in presentment_currency.
• presentment_currency - Currency presented to the customer during payment. Max length: 5000.

@type processing() :: %{
  optional(:card) => Stripe.Resources.Card.t() | nil,
  optional(:type) => String.t() | nil,
  optional(String.t()) => term()
}

• card
• type - Type of the payment method for which payment is in processing state, one of card. Possible values: card.

@type t() :: %Stripe.Resources.PaymentIntent{
  amount: integer(),
  amount_capturable: integer(),
  amount_details: amount_details() | nil,
  amount_received: integer(),
  application: String.t() | Stripe.Resources.Application.t(),
  application_fee_amount: integer(),
  automatic_payment_methods: automatic_payment_methods(),
  canceled_at: integer(),
  cancellation_reason: String.t(),
  capture_method: String.t(),
  client_secret: String.t(),
  confirmation_method: String.t(),
  created: integer(),
  currency: String.t(),
  customer: String.t() | Stripe.Resources.Customer.t(),
  customer_account: String.t(),
  description: String.t(),
  excluded_payment_method_types: [String.t()],
  hooks: hooks() | nil,
  id: String.t(),
  last_payment_error: Stripe.Resources.StripeError.t(),
  latest_charge: String.t() | Stripe.Resources.Charge.t(),
  livemode: boolean(),
  metadata: %{required(String.t()) => String.t()},
  next_action: next_action(),
  object: String.t(),
  on_behalf_of: String.t() | Stripe.Resources.Account.t(),
  payment_details: payment_details() | nil,
  payment_method: String.t() | Stripe.Resources.PaymentMethod.t(),
  payment_method_configuration_details: payment_method_configuration_details(),
  payment_method_options: payment_method_options(),
  payment_method_types: [String.t()],
  presentment_details: presentment_details() | nil,
  processing: processing(),
  receipt_email: String.t(),
  review: String.t() | Stripe.Resources.Review.t(),
  setup_future_usage: String.t(),
  shipping: Stripe.Resources.ShippingDetails.t(),
  source: String.t() | Stripe.Resources.PaymentSource.t(),
  statement_descriptor: String.t(),
  statement_descriptor_suffix: String.t(),
  status: String.t(),
  transfer_data: transfer_data() | nil,
  transfer_group: String.t()
}

• amount - Amount intended to be collected by this PaymentIntent. A positive integer representing how much to charge in the smallest currency unit (e.g., 100 cents to charge $1.00 or 100 to charge ¥100, a zero-decimal currency). The minimum amount is $0.50 US or equivalent in charge currency. The amount value supports up to eight digits (e.g., a value of 99999999 for a USD charge of $999,999.99).
• amount_capturable - Amount that can be captured from this PaymentIntent.
• amount_details - Expandable.
• amount_received - Amount that this PaymentIntent collects.
• application - ID of the Connect application that created the PaymentIntent. Nullable. Expandable.
• application_fee_amount - The amount of the application fee (if any) that will be requested to be applied to the payment and transferred to the application owner's Stripe account. The amount of the application fee collected will be capped at the total amount captured. For more information, see the PaymentIntents use case for connected accounts. Nullable.
• automatic_payment_methods - Settings to configure compatible payment methods from the Stripe Dashboard Nullable. Expandable.
• canceled_at - Populated when status is canceled, this is the time at which the PaymentIntent was canceled. Measured in seconds since the Unix epoch. Format: Unix timestamp. Nullable.
• cancellation_reason - Reason for cancellation of this PaymentIntent, either user-provided (duplicate, fraudulent, requested_by_customer, or abandoned) or generated by Stripe internally (failed_invoice, void_invoice, automatic, or expired). Possible values: abandoned, automatic, duplicate, expired, failed_invoice, fraudulent, requested_by_customer, void_invoice. Nullable.
• capture_method - Controls when the funds will be captured from the customer's account. Possible values: automatic, automatic_async, manual.
• client_secret - The client secret of this PaymentIntent. Used for client-side retrieval using a publishable key.

The client secret can be used to complete a payment from your frontend. It should not be stored, logged, or exposed to anyone other than the customer. Make sure that you have TLS enabled on any page that includes the client secret.

Refer to our docs to accept a payment and learn about how client_secret should be handled. Max length: 5000. Nullable.

• confirmation_method - Describes whether we can confirm this PaymentIntent automatically, or if it requires customer action to confirm the payment. Possible values: automatic, manual.
• created - Time at which the object was created. Measured in seconds since the Unix epoch. Format: Unix timestamp.
• currency - Three-letter ISO currency code, in lowercase. Must be a supported currency. Format: ISO 4217 currency code.
• customer - ID of the Customer this PaymentIntent belongs to, if one exists.

Payment methods attached to other Customers cannot be used with this PaymentIntent.

If setup_future_usage is set and this PaymentIntent's payment method is not card_present, then the payment method attaches to the Customer after the PaymentIntent has been confirmed and any required actions from the user are complete. If the payment method is card_present and isn't a digital wallet, then a generated_card payment method representing the card is created and attached to the Customer instead. Nullable. Expandable.

• customer_account - ID of the Account representing the customer that this PaymentIntent belongs to, if one exists.

Payment methods attached to other Accounts cannot be used with this PaymentIntent.

If setup_future_usage is set and this PaymentIntent's payment method is not card_present, then the payment method attaches to the Account after the PaymentIntent has been confirmed and any required actions from the user are complete. If the payment method is card_present and isn't a digital wallet, then a generated_card payment method representing the card is created and attached to the Account instead. Max length: 5000. Nullable.

• description - An arbitrary string attached to the object. Often useful for displaying to users. Max length: 5000. Nullable.
• excluded_payment_method_types - The list of payment method types to exclude from use with this payment. Nullable.
• hooks - Expandable.
• id - Unique identifier for the object. Max length: 5000.
• last_payment_error - The payment error encountered in the previous PaymentIntent confirmation. It will be cleared if the PaymentIntent is later updated for any reason. Nullable. Expandable.
• latest_charge - ID of the latest Charge object created by this PaymentIntent. This property is null until PaymentIntent confirmation is attempted. Nullable. Expandable.
• livemode - Has the value true if the object exists in live mode or the value false if the object exists in test mode.
• metadata - Set of key-value pairs that you can attach to an object. This can be useful for storing additional information about the object in a structured format. Learn more about storing information in metadata.
• next_action - If present, this property tells you what actions you need to take in order for your customer to fulfill a payment using the provided source. Nullable. Expandable.
• object - String representing the object's type. Objects of the same type share the same value. Possible values: payment_intent.
• on_behalf_of - You can specify the settlement merchant as the connected account using the on_behalf_of attribute on the charge. See the PaymentIntents use case for connected accounts for details. Nullable. Expandable.
• payment_details - Expandable.
• payment_method - ID of the payment method used in this PaymentIntent. Nullable. Expandable.
• payment_method_configuration_details - Information about the payment method configuration used for this PaymentIntent. Nullable. Expandable.
• payment_method_options - Payment-method-specific configuration for this PaymentIntent. Nullable. Expandable.
• payment_method_types - The list of payment method types (e.g. card) that this PaymentIntent is allowed to use. A comprehensive list of valid payment method types can be found here.
• presentment_details - Expandable.
• processing - If present, this property tells you about the processing state of the payment. Nullable. Expandable.
• receipt_email - Email address that the receipt for the resulting payment will be sent to. If receipt_email is specified for a payment in live mode, a receipt will be sent regardless of your email settings. Max length: 5000. Nullable.
• review - ID of the review associated with this PaymentIntent, if any. Nullable. Expandable.
• setup_future_usage - Indicates that you intend to make future payments with this PaymentIntent's payment method.

If you provide a Customer with the PaymentIntent, you can use this parameter to attach the payment method to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still attach the payment method to a Customer after the transaction completes.

If the payment method is card_present and isn't a digital wallet, Stripe creates and attaches a generated_card payment method representing the card to the Customer instead.

When processing card payments, Stripe uses setup_future_usage to help you comply with regional legislation and network rules, such as SCA. Possible values: off_session, on_session. Nullable.

• shipping - Shipping information for this PaymentIntent. Nullable. Expandable.
• source - This is a legacy field that will be removed in the future. It is the ID of the Source object that is associated with this PaymentIntent, if one was supplied. Nullable. Expandable.
• statement_descriptor - Text that appears on the customer's statement as the statement descriptor for a non-card charge. This value overrides the account's default statement descriptor. For information about requirements, including the 22-character limit, see the Statement Descriptor docs.

Setting this value for a card charge returns an error. For card charges, set the statement_descriptor_suffix instead. Max length: 5000. Nullable.

• statement_descriptor_suffix - Provides information about a card charge. Concatenated to the account's statement descriptor prefix to form the complete statement descriptor that appears on the customer's statement. Max length: 5000. Nullable.
• status - Status of this PaymentIntent, one of requires_payment_method, requires_confirmation, requires_action, processing, requires_capture, canceled, or succeeded. Read more about each PaymentIntent status. Possible values: canceled, processing, requires_action, requires_capture, requires_confirmation, requires_payment_method, succeeded.
• transfer_data - The data that automatically creates a Transfer after the payment finalizes. Learn more about the use case for connected accounts. Nullable. Expandable.
• transfer_group - A string that identifies the resulting payment as part of a group. Learn more about the use case for connected accounts. Max length: 5000. Nullable.

@type transfer_data() :: %{
  optional(:amount) => integer() | nil,
  optional(:destination) => String.t() | Stripe.Resources.Account.t() | nil,
  optional(String.t()) => term()
}

• amount - The amount transferred to the destination account. This transfer will occur automatically after the payment succeeds. If no amount is specified, by default the entire payment amount is transferred to the destination account. The amount must be less than or equal to the amount, and must be a positive integer representing how much to transfer in the smallest currency unit (e.g., 100 cents to charge $1.00).
• destination - The account (if any) that the payment is attributed to for tax reporting, and where funds from the payment are transferred to after payment success.