diff --git a/OPENAPI_VERSION b/OPENAPI_VERSION index e11db67e..986a2308 100644 --- a/OPENAPI_VERSION +++ b/OPENAPI_VERSION @@ -1 +1 @@ -v1817 \ No newline at end of file +v1818 \ No newline at end of file diff --git a/lib/stripe/resources/payment_intent.rb b/lib/stripe/resources/payment_intent.rb index 508e70f4..3c22ffc5 100644 --- a/lib/stripe/resources/payment_intent.rb +++ b/lib/stripe/resources/payment_intent.rb @@ -2044,6 +2044,159 @@ module Stripe end class CreateParams < Stripe::RequestParams + class AmountDetails < Stripe::RequestParams + class LineItem < Stripe::RequestParams + class PaymentMethodOptions < Stripe::RequestParams + class Card < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + attr_accessor :commodity_code + + def initialize(commodity_code: nil) + @commodity_code = commodity_code + end + end + + class CardPresent < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + attr_accessor :commodity_code + + def initialize(commodity_code: nil) + @commodity_code = commodity_code + end + end + + class Klarna < Stripe::RequestParams + # URL to an image for the product. Max length, 4096 characters. + attr_accessor :image_url + # URL to the product page. Max length, 4096 characters. + attr_accessor :product_url + # Reference for the subscription this line item is for. + attr_accessor :subscription_reference + + def initialize(image_url: nil, product_url: nil, subscription_reference: nil) + @image_url = image_url + @product_url = product_url + @subscription_reference = subscription_reference + end + end + + class Paypal < Stripe::RequestParams + # Type of the line item. + attr_accessor :category + # Description of the line item. + attr_accessor :description + # The Stripe account ID of the connected account that sells the item. + attr_accessor :sold_by + + def initialize(category: nil, description: nil, sold_by: nil) + @category = category + @description = description + @sold_by = sold_by + end + end + # This sub-hash contains line item details that are specific to `card` payment method." + attr_accessor :card + # This sub-hash contains line item details that are specific to `card_present` payment method." + attr_accessor :card_present + # This sub-hash contains line item details that are specific to `klarna` payment method." + attr_accessor :klarna + # This sub-hash contains line item details that are specific to `paypal` payment method." + attr_accessor :paypal + + def initialize(card: nil, card_present: nil, klarna: nil, paypal: nil) + @card = card + @card_present = card_present + @klarna = klarna + @paypal = paypal + end + end + + class Tax < Stripe::RequestParams + # The total tax on an item. Non-negative integer. + attr_accessor :total_tax_amount + + def initialize(total_tax_amount: nil) + @total_tax_amount = total_tax_amount + end + end + # The amount an item was discounted for. Positive integer. + attr_accessor :discount_amount + # Payment method-specific information for line items. + attr_accessor :payment_method_options + # Unique identifier of the product. At most 12 characters long. + attr_accessor :product_code + # Name of the product. At most 100 characters long. + attr_accessor :product_name + # Number of items of the product. Positive integer. + attr_accessor :quantity + # Contains information about the tax on the item. + attr_accessor :tax + # Cost of the product. Non-negative integer. + attr_accessor :unit_cost + # A unit of measure for the line item, such as gallons, feet, meters, etc. + attr_accessor :unit_of_measure + + def initialize( + discount_amount: nil, + payment_method_options: nil, + product_code: nil, + product_name: nil, + quantity: nil, + tax: nil, + unit_cost: nil, + unit_of_measure: nil + ) + @discount_amount = discount_amount + @payment_method_options = payment_method_options + @product_code = product_code + @product_name = product_name + @quantity = quantity + @tax = tax + @unit_cost = unit_cost + @unit_of_measure = unit_of_measure + end + end + + class Shipping < Stripe::RequestParams + # Portion of the amount that is for shipping. + attr_accessor :amount + # The postal code that represents the shipping source. + attr_accessor :from_postal_code + # The postal code that represents the shipping destination. + attr_accessor :to_postal_code + + def initialize(amount: nil, from_postal_code: nil, to_postal_code: nil) + @amount = amount + @from_postal_code = from_postal_code + @to_postal_code = to_postal_code + end + end + + class Tax < Stripe::RequestParams + # Total portion of the amount that is for tax. + attr_accessor :total_tax_amount + + def initialize(total_tax_amount: nil) + @total_tax_amount = total_tax_amount + end + end + # The amount an item was discounted for. + attr_accessor :discount_amount + # A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 100 line items. + attr_accessor :line_items + # Contains information about the shipping portion of the amount. + attr_accessor :shipping + # Contains information about the tax portion of the amount. + attr_accessor :tax + + def initialize(discount_amount: nil, line_items: nil, shipping: nil, tax: nil) + @discount_amount = discount_amount + @line_items = line_items + @shipping = shipping + @tax = tax + end + end + class AutomaticPaymentMethods < Stripe::RequestParams # Controls whether this PaymentIntent will accept redirect-based payment methods. # @@ -5483,6 +5636,8 @@ module Stripe end # Amount intended to be collected by this PaymentIntent. A positive integer representing how much to charge in the [smallest currency unit](https://stripe.com/docs/currencies#zero-decimal) (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](https://stripe.com/docs/currencies#minimum-and-maximum-charge-amounts). The amount value supports up to eight digits (e.g., a value of 99999999 for a USD charge of $999,999.99). attr_accessor :amount + # Provides industry-specific information about the amount. + attr_accessor :amount_details # 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](https://stripe.com/docs/payments/connected-accounts). attr_accessor :application_fee_amount # When you enable this parameter, this PaymentIntent accepts payment methods that you enable in the Dashboard and that are compatible with this PaymentIntent's other parameters. @@ -5583,6 +5738,7 @@ module Stripe def initialize( amount: nil, + amount_details: nil, application_fee_amount: nil, automatic_payment_methods: nil, capture_method: nil, @@ -5621,6 +5777,7 @@ module Stripe use_stripe_sdk: nil ) @amount = amount + @amount_details = amount_details @application_fee_amount = application_fee_amount @automatic_payment_methods = automatic_payment_methods @capture_method = capture_method @@ -5661,6 +5818,159 @@ module Stripe end class UpdateParams < Stripe::RequestParams + class AmountDetails < Stripe::RequestParams + class LineItem < Stripe::RequestParams + class PaymentMethodOptions < Stripe::RequestParams + class Card < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + attr_accessor :commodity_code + + def initialize(commodity_code: nil) + @commodity_code = commodity_code + end + end + + class CardPresent < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + attr_accessor :commodity_code + + def initialize(commodity_code: nil) + @commodity_code = commodity_code + end + end + + class Klarna < Stripe::RequestParams + # URL to an image for the product. Max length, 4096 characters. + attr_accessor :image_url + # URL to the product page. Max length, 4096 characters. + attr_accessor :product_url + # Reference for the subscription this line item is for. + attr_accessor :subscription_reference + + def initialize(image_url: nil, product_url: nil, subscription_reference: nil) + @image_url = image_url + @product_url = product_url + @subscription_reference = subscription_reference + end + end + + class Paypal < Stripe::RequestParams + # Type of the line item. + attr_accessor :category + # Description of the line item. + attr_accessor :description + # The Stripe account ID of the connected account that sells the item. + attr_accessor :sold_by + + def initialize(category: nil, description: nil, sold_by: nil) + @category = category + @description = description + @sold_by = sold_by + end + end + # This sub-hash contains line item details that are specific to `card` payment method." + attr_accessor :card + # This sub-hash contains line item details that are specific to `card_present` payment method." + attr_accessor :card_present + # This sub-hash contains line item details that are specific to `klarna` payment method." + attr_accessor :klarna + # This sub-hash contains line item details that are specific to `paypal` payment method." + attr_accessor :paypal + + def initialize(card: nil, card_present: nil, klarna: nil, paypal: nil) + @card = card + @card_present = card_present + @klarna = klarna + @paypal = paypal + end + end + + class Tax < Stripe::RequestParams + # The total tax on an item. Non-negative integer. + attr_accessor :total_tax_amount + + def initialize(total_tax_amount: nil) + @total_tax_amount = total_tax_amount + end + end + # The amount an item was discounted for. Positive integer. + attr_accessor :discount_amount + # Payment method-specific information for line items. + attr_accessor :payment_method_options + # Unique identifier of the product. At most 12 characters long. + attr_accessor :product_code + # Name of the product. At most 100 characters long. + attr_accessor :product_name + # Number of items of the product. Positive integer. + attr_accessor :quantity + # Contains information about the tax on the item. + attr_accessor :tax + # Cost of the product. Non-negative integer. + attr_accessor :unit_cost + # A unit of measure for the line item, such as gallons, feet, meters, etc. + attr_accessor :unit_of_measure + + def initialize( + discount_amount: nil, + payment_method_options: nil, + product_code: nil, + product_name: nil, + quantity: nil, + tax: nil, + unit_cost: nil, + unit_of_measure: nil + ) + @discount_amount = discount_amount + @payment_method_options = payment_method_options + @product_code = product_code + @product_name = product_name + @quantity = quantity + @tax = tax + @unit_cost = unit_cost + @unit_of_measure = unit_of_measure + end + end + + class Shipping < Stripe::RequestParams + # Portion of the amount that is for shipping. + attr_accessor :amount + # The postal code that represents the shipping source. + attr_accessor :from_postal_code + # The postal code that represents the shipping destination. + attr_accessor :to_postal_code + + def initialize(amount: nil, from_postal_code: nil, to_postal_code: nil) + @amount = amount + @from_postal_code = from_postal_code + @to_postal_code = to_postal_code + end + end + + class Tax < Stripe::RequestParams + # Total portion of the amount that is for tax. + attr_accessor :total_tax_amount + + def initialize(total_tax_amount: nil) + @total_tax_amount = total_tax_amount + end + end + # The amount an item was discounted for. + attr_accessor :discount_amount + # A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 100 line items. + attr_accessor :line_items + # Contains information about the shipping portion of the amount. + attr_accessor :shipping + # Contains information about the tax portion of the amount. + attr_accessor :tax + + def initialize(discount_amount: nil, line_items: nil, shipping: nil, tax: nil) + @discount_amount = discount_amount + @line_items = line_items + @shipping = shipping + @tax = tax + end + end + class Hooks < Stripe::RequestParams class Inputs < Stripe::RequestParams class Tax < Stripe::RequestParams @@ -9057,6 +9367,8 @@ module Stripe end # Amount intended to be collected by this PaymentIntent. A positive integer representing how much to charge in the [smallest currency unit](https://stripe.com/docs/currencies#zero-decimal) (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](https://stripe.com/docs/currencies#minimum-and-maximum-charge-amounts). The amount value supports up to eight digits (e.g., a value of 99999999 for a USD charge of $999,999.99). attr_accessor :amount + # Provides industry-specific information about the amount. + attr_accessor :amount_details # 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](https://stripe.com/docs/payments/connected-accounts). attr_accessor :application_fee_amount # Controls when the funds will be captured from the customer's account. @@ -9128,6 +9440,7 @@ module Stripe def initialize( amount: nil, + amount_details: nil, application_fee_amount: nil, capture_method: nil, currency: nil, @@ -9154,6 +9467,7 @@ module Stripe transfer_group: nil ) @amount = amount + @amount_details = amount_details @application_fee_amount = application_fee_amount @capture_method = capture_method @currency = currency @@ -9231,6 +9545,159 @@ module Stripe end class CaptureParams < Stripe::RequestParams + class AmountDetails < Stripe::RequestParams + class LineItem < Stripe::RequestParams + class PaymentMethodOptions < Stripe::RequestParams + class Card < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + attr_accessor :commodity_code + + def initialize(commodity_code: nil) + @commodity_code = commodity_code + end + end + + class CardPresent < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + attr_accessor :commodity_code + + def initialize(commodity_code: nil) + @commodity_code = commodity_code + end + end + + class Klarna < Stripe::RequestParams + # URL to an image for the product. Max length, 4096 characters. + attr_accessor :image_url + # URL to the product page. Max length, 4096 characters. + attr_accessor :product_url + # Reference for the subscription this line item is for. + attr_accessor :subscription_reference + + def initialize(image_url: nil, product_url: nil, subscription_reference: nil) + @image_url = image_url + @product_url = product_url + @subscription_reference = subscription_reference + end + end + + class Paypal < Stripe::RequestParams + # Type of the line item. + attr_accessor :category + # Description of the line item. + attr_accessor :description + # The Stripe account ID of the connected account that sells the item. + attr_accessor :sold_by + + def initialize(category: nil, description: nil, sold_by: nil) + @category = category + @description = description + @sold_by = sold_by + end + end + # This sub-hash contains line item details that are specific to `card` payment method." + attr_accessor :card + # This sub-hash contains line item details that are specific to `card_present` payment method." + attr_accessor :card_present + # This sub-hash contains line item details that are specific to `klarna` payment method." + attr_accessor :klarna + # This sub-hash contains line item details that are specific to `paypal` payment method." + attr_accessor :paypal + + def initialize(card: nil, card_present: nil, klarna: nil, paypal: nil) + @card = card + @card_present = card_present + @klarna = klarna + @paypal = paypal + end + end + + class Tax < Stripe::RequestParams + # The total tax on an item. Non-negative integer. + attr_accessor :total_tax_amount + + def initialize(total_tax_amount: nil) + @total_tax_amount = total_tax_amount + end + end + # The amount an item was discounted for. Positive integer. + attr_accessor :discount_amount + # Payment method-specific information for line items. + attr_accessor :payment_method_options + # Unique identifier of the product. At most 12 characters long. + attr_accessor :product_code + # Name of the product. At most 100 characters long. + attr_accessor :product_name + # Number of items of the product. Positive integer. + attr_accessor :quantity + # Contains information about the tax on the item. + attr_accessor :tax + # Cost of the product. Non-negative integer. + attr_accessor :unit_cost + # A unit of measure for the line item, such as gallons, feet, meters, etc. + attr_accessor :unit_of_measure + + def initialize( + discount_amount: nil, + payment_method_options: nil, + product_code: nil, + product_name: nil, + quantity: nil, + tax: nil, + unit_cost: nil, + unit_of_measure: nil + ) + @discount_amount = discount_amount + @payment_method_options = payment_method_options + @product_code = product_code + @product_name = product_name + @quantity = quantity + @tax = tax + @unit_cost = unit_cost + @unit_of_measure = unit_of_measure + end + end + + class Shipping < Stripe::RequestParams + # Portion of the amount that is for shipping. + attr_accessor :amount + # The postal code that represents the shipping source. + attr_accessor :from_postal_code + # The postal code that represents the shipping destination. + attr_accessor :to_postal_code + + def initialize(amount: nil, from_postal_code: nil, to_postal_code: nil) + @amount = amount + @from_postal_code = from_postal_code + @to_postal_code = to_postal_code + end + end + + class Tax < Stripe::RequestParams + # Total portion of the amount that is for tax. + attr_accessor :total_tax_amount + + def initialize(total_tax_amount: nil) + @total_tax_amount = total_tax_amount + end + end + # The amount an item was discounted for. + attr_accessor :discount_amount + # A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 100 line items. + attr_accessor :line_items + # Contains information about the shipping portion of the amount. + attr_accessor :shipping + # Contains information about the tax portion of the amount. + attr_accessor :tax + + def initialize(discount_amount: nil, line_items: nil, shipping: nil, tax: nil) + @discount_amount = discount_amount + @line_items = line_items + @shipping = shipping + @tax = tax + end + end + class Hooks < Stripe::RequestParams class Inputs < Stripe::RequestParams class Tax < Stripe::RequestParams @@ -9969,6 +10436,8 @@ module Stripe @amount = amount end end + # Provides industry-specific information about the amount. + attr_accessor :amount_details # The amount to capture from the PaymentIntent, which must be less than or equal to the original amount. Defaults to the full `amount_capturable` if it's not provided. attr_accessor :amount_to_capture # 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](https://stripe.com/docs/payments/connected-accounts). @@ -9994,6 +10463,7 @@ module Stripe attr_accessor :transfer_data def initialize( + amount_details: nil, amount_to_capture: nil, application_fee_amount: nil, expand: nil, @@ -10005,6 +10475,7 @@ module Stripe statement_descriptor_suffix: nil, transfer_data: nil ) + @amount_details = amount_details @amount_to_capture = amount_to_capture @application_fee_amount = application_fee_amount @expand = expand @@ -10019,6 +10490,159 @@ module Stripe end class ConfirmParams < Stripe::RequestParams + class AmountDetails < Stripe::RequestParams + class LineItem < Stripe::RequestParams + class PaymentMethodOptions < Stripe::RequestParams + class Card < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + attr_accessor :commodity_code + + def initialize(commodity_code: nil) + @commodity_code = commodity_code + end + end + + class CardPresent < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + attr_accessor :commodity_code + + def initialize(commodity_code: nil) + @commodity_code = commodity_code + end + end + + class Klarna < Stripe::RequestParams + # URL to an image for the product. Max length, 4096 characters. + attr_accessor :image_url + # URL to the product page. Max length, 4096 characters. + attr_accessor :product_url + # Reference for the subscription this line item is for. + attr_accessor :subscription_reference + + def initialize(image_url: nil, product_url: nil, subscription_reference: nil) + @image_url = image_url + @product_url = product_url + @subscription_reference = subscription_reference + end + end + + class Paypal < Stripe::RequestParams + # Type of the line item. + attr_accessor :category + # Description of the line item. + attr_accessor :description + # The Stripe account ID of the connected account that sells the item. + attr_accessor :sold_by + + def initialize(category: nil, description: nil, sold_by: nil) + @category = category + @description = description + @sold_by = sold_by + end + end + # This sub-hash contains line item details that are specific to `card` payment method." + attr_accessor :card + # This sub-hash contains line item details that are specific to `card_present` payment method." + attr_accessor :card_present + # This sub-hash contains line item details that are specific to `klarna` payment method." + attr_accessor :klarna + # This sub-hash contains line item details that are specific to `paypal` payment method." + attr_accessor :paypal + + def initialize(card: nil, card_present: nil, klarna: nil, paypal: nil) + @card = card + @card_present = card_present + @klarna = klarna + @paypal = paypal + end + end + + class Tax < Stripe::RequestParams + # The total tax on an item. Non-negative integer. + attr_accessor :total_tax_amount + + def initialize(total_tax_amount: nil) + @total_tax_amount = total_tax_amount + end + end + # The amount an item was discounted for. Positive integer. + attr_accessor :discount_amount + # Payment method-specific information for line items. + attr_accessor :payment_method_options + # Unique identifier of the product. At most 12 characters long. + attr_accessor :product_code + # Name of the product. At most 100 characters long. + attr_accessor :product_name + # Number of items of the product. Positive integer. + attr_accessor :quantity + # Contains information about the tax on the item. + attr_accessor :tax + # Cost of the product. Non-negative integer. + attr_accessor :unit_cost + # A unit of measure for the line item, such as gallons, feet, meters, etc. + attr_accessor :unit_of_measure + + def initialize( + discount_amount: nil, + payment_method_options: nil, + product_code: nil, + product_name: nil, + quantity: nil, + tax: nil, + unit_cost: nil, + unit_of_measure: nil + ) + @discount_amount = discount_amount + @payment_method_options = payment_method_options + @product_code = product_code + @product_name = product_name + @quantity = quantity + @tax = tax + @unit_cost = unit_cost + @unit_of_measure = unit_of_measure + end + end + + class Shipping < Stripe::RequestParams + # Portion of the amount that is for shipping. + attr_accessor :amount + # The postal code that represents the shipping source. + attr_accessor :from_postal_code + # The postal code that represents the shipping destination. + attr_accessor :to_postal_code + + def initialize(amount: nil, from_postal_code: nil, to_postal_code: nil) + @amount = amount + @from_postal_code = from_postal_code + @to_postal_code = to_postal_code + end + end + + class Tax < Stripe::RequestParams + # Total portion of the amount that is for tax. + attr_accessor :total_tax_amount + + def initialize(total_tax_amount: nil) + @total_tax_amount = total_tax_amount + end + end + # The amount an item was discounted for. + attr_accessor :discount_amount + # A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 100 line items. + attr_accessor :line_items + # Contains information about the shipping portion of the amount. + attr_accessor :shipping + # Contains information about the tax portion of the amount. + attr_accessor :tax + + def initialize(discount_amount: nil, line_items: nil, shipping: nil, tax: nil) + @discount_amount = discount_amount + @line_items = line_items + @shipping = shipping + @tax = tax + end + end + class Hooks < Stripe::RequestParams class Inputs < Stripe::RequestParams class Tax < Stripe::RequestParams @@ -13421,6 +14045,8 @@ module Stripe @tracking_number = tracking_number end end + # Provides industry-specific information about the amount. + attr_accessor :amount_details # 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](https://stripe.com/docs/payments/connected-accounts). attr_accessor :application_fee_amount # Controls when the funds will be captured from the customer's account. @@ -13480,6 +14106,7 @@ module Stripe attr_accessor :use_stripe_sdk def initialize( + amount_details: nil, application_fee_amount: nil, capture_method: nil, confirmation_token: nil, @@ -13502,6 +14129,7 @@ module Stripe shipping: nil, use_stripe_sdk: nil ) + @amount_details = amount_details @application_fee_amount = application_fee_amount @capture_method = capture_method @confirmation_token = confirmation_token diff --git a/lib/stripe/services/payment_intent_service.rb b/lib/stripe/services/payment_intent_service.rb index 563ff5d7..e062e4e8 100644 --- a/lib/stripe/services/payment_intent_service.rb +++ b/lib/stripe/services/payment_intent_service.rb @@ -63,6 +63,159 @@ module Stripe end class CreateParams < Stripe::RequestParams + class AmountDetails < Stripe::RequestParams + class LineItem < Stripe::RequestParams + class PaymentMethodOptions < Stripe::RequestParams + class Card < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + attr_accessor :commodity_code + + def initialize(commodity_code: nil) + @commodity_code = commodity_code + end + end + + class CardPresent < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + attr_accessor :commodity_code + + def initialize(commodity_code: nil) + @commodity_code = commodity_code + end + end + + class Klarna < Stripe::RequestParams + # URL to an image for the product. Max length, 4096 characters. + attr_accessor :image_url + # URL to the product page. Max length, 4096 characters. + attr_accessor :product_url + # Reference for the subscription this line item is for. + attr_accessor :subscription_reference + + def initialize(image_url: nil, product_url: nil, subscription_reference: nil) + @image_url = image_url + @product_url = product_url + @subscription_reference = subscription_reference + end + end + + class Paypal < Stripe::RequestParams + # Type of the line item. + attr_accessor :category + # Description of the line item. + attr_accessor :description + # The Stripe account ID of the connected account that sells the item. + attr_accessor :sold_by + + def initialize(category: nil, description: nil, sold_by: nil) + @category = category + @description = description + @sold_by = sold_by + end + end + # This sub-hash contains line item details that are specific to `card` payment method." + attr_accessor :card + # This sub-hash contains line item details that are specific to `card_present` payment method." + attr_accessor :card_present + # This sub-hash contains line item details that are specific to `klarna` payment method." + attr_accessor :klarna + # This sub-hash contains line item details that are specific to `paypal` payment method." + attr_accessor :paypal + + def initialize(card: nil, card_present: nil, klarna: nil, paypal: nil) + @card = card + @card_present = card_present + @klarna = klarna + @paypal = paypal + end + end + + class Tax < Stripe::RequestParams + # The total tax on an item. Non-negative integer. + attr_accessor :total_tax_amount + + def initialize(total_tax_amount: nil) + @total_tax_amount = total_tax_amount + end + end + # The amount an item was discounted for. Positive integer. + attr_accessor :discount_amount + # Payment method-specific information for line items. + attr_accessor :payment_method_options + # Unique identifier of the product. At most 12 characters long. + attr_accessor :product_code + # Name of the product. At most 100 characters long. + attr_accessor :product_name + # Number of items of the product. Positive integer. + attr_accessor :quantity + # Contains information about the tax on the item. + attr_accessor :tax + # Cost of the product. Non-negative integer. + attr_accessor :unit_cost + # A unit of measure for the line item, such as gallons, feet, meters, etc. + attr_accessor :unit_of_measure + + def initialize( + discount_amount: nil, + payment_method_options: nil, + product_code: nil, + product_name: nil, + quantity: nil, + tax: nil, + unit_cost: nil, + unit_of_measure: nil + ) + @discount_amount = discount_amount + @payment_method_options = payment_method_options + @product_code = product_code + @product_name = product_name + @quantity = quantity + @tax = tax + @unit_cost = unit_cost + @unit_of_measure = unit_of_measure + end + end + + class Shipping < Stripe::RequestParams + # Portion of the amount that is for shipping. + attr_accessor :amount + # The postal code that represents the shipping source. + attr_accessor :from_postal_code + # The postal code that represents the shipping destination. + attr_accessor :to_postal_code + + def initialize(amount: nil, from_postal_code: nil, to_postal_code: nil) + @amount = amount + @from_postal_code = from_postal_code + @to_postal_code = to_postal_code + end + end + + class Tax < Stripe::RequestParams + # Total portion of the amount that is for tax. + attr_accessor :total_tax_amount + + def initialize(total_tax_amount: nil) + @total_tax_amount = total_tax_amount + end + end + # The amount an item was discounted for. + attr_accessor :discount_amount + # A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 100 line items. + attr_accessor :line_items + # Contains information about the shipping portion of the amount. + attr_accessor :shipping + # Contains information about the tax portion of the amount. + attr_accessor :tax + + def initialize(discount_amount: nil, line_items: nil, shipping: nil, tax: nil) + @discount_amount = discount_amount + @line_items = line_items + @shipping = shipping + @tax = tax + end + end + class AutomaticPaymentMethods < Stripe::RequestParams # Controls whether this PaymentIntent will accept redirect-based payment methods. # @@ -3502,6 +3655,8 @@ module Stripe end # Amount intended to be collected by this PaymentIntent. A positive integer representing how much to charge in the [smallest currency unit](https://stripe.com/docs/currencies#zero-decimal) (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](https://stripe.com/docs/currencies#minimum-and-maximum-charge-amounts). The amount value supports up to eight digits (e.g., a value of 99999999 for a USD charge of $999,999.99). attr_accessor :amount + # Provides industry-specific information about the amount. + attr_accessor :amount_details # 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](https://stripe.com/docs/payments/connected-accounts). attr_accessor :application_fee_amount # When you enable this parameter, this PaymentIntent accepts payment methods that you enable in the Dashboard and that are compatible with this PaymentIntent's other parameters. @@ -3602,6 +3757,7 @@ module Stripe def initialize( amount: nil, + amount_details: nil, application_fee_amount: nil, automatic_payment_methods: nil, capture_method: nil, @@ -3640,6 +3796,7 @@ module Stripe use_stripe_sdk: nil ) @amount = amount + @amount_details = amount_details @application_fee_amount = application_fee_amount @automatic_payment_methods = automatic_payment_methods @capture_method = capture_method @@ -3692,6 +3849,159 @@ module Stripe end class UpdateParams < Stripe::RequestParams + class AmountDetails < Stripe::RequestParams + class LineItem < Stripe::RequestParams + class PaymentMethodOptions < Stripe::RequestParams + class Card < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + attr_accessor :commodity_code + + def initialize(commodity_code: nil) + @commodity_code = commodity_code + end + end + + class CardPresent < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + attr_accessor :commodity_code + + def initialize(commodity_code: nil) + @commodity_code = commodity_code + end + end + + class Klarna < Stripe::RequestParams + # URL to an image for the product. Max length, 4096 characters. + attr_accessor :image_url + # URL to the product page. Max length, 4096 characters. + attr_accessor :product_url + # Reference for the subscription this line item is for. + attr_accessor :subscription_reference + + def initialize(image_url: nil, product_url: nil, subscription_reference: nil) + @image_url = image_url + @product_url = product_url + @subscription_reference = subscription_reference + end + end + + class Paypal < Stripe::RequestParams + # Type of the line item. + attr_accessor :category + # Description of the line item. + attr_accessor :description + # The Stripe account ID of the connected account that sells the item. + attr_accessor :sold_by + + def initialize(category: nil, description: nil, sold_by: nil) + @category = category + @description = description + @sold_by = sold_by + end + end + # This sub-hash contains line item details that are specific to `card` payment method." + attr_accessor :card + # This sub-hash contains line item details that are specific to `card_present` payment method." + attr_accessor :card_present + # This sub-hash contains line item details that are specific to `klarna` payment method." + attr_accessor :klarna + # This sub-hash contains line item details that are specific to `paypal` payment method." + attr_accessor :paypal + + def initialize(card: nil, card_present: nil, klarna: nil, paypal: nil) + @card = card + @card_present = card_present + @klarna = klarna + @paypal = paypal + end + end + + class Tax < Stripe::RequestParams + # The total tax on an item. Non-negative integer. + attr_accessor :total_tax_amount + + def initialize(total_tax_amount: nil) + @total_tax_amount = total_tax_amount + end + end + # The amount an item was discounted for. Positive integer. + attr_accessor :discount_amount + # Payment method-specific information for line items. + attr_accessor :payment_method_options + # Unique identifier of the product. At most 12 characters long. + attr_accessor :product_code + # Name of the product. At most 100 characters long. + attr_accessor :product_name + # Number of items of the product. Positive integer. + attr_accessor :quantity + # Contains information about the tax on the item. + attr_accessor :tax + # Cost of the product. Non-negative integer. + attr_accessor :unit_cost + # A unit of measure for the line item, such as gallons, feet, meters, etc. + attr_accessor :unit_of_measure + + def initialize( + discount_amount: nil, + payment_method_options: nil, + product_code: nil, + product_name: nil, + quantity: nil, + tax: nil, + unit_cost: nil, + unit_of_measure: nil + ) + @discount_amount = discount_amount + @payment_method_options = payment_method_options + @product_code = product_code + @product_name = product_name + @quantity = quantity + @tax = tax + @unit_cost = unit_cost + @unit_of_measure = unit_of_measure + end + end + + class Shipping < Stripe::RequestParams + # Portion of the amount that is for shipping. + attr_accessor :amount + # The postal code that represents the shipping source. + attr_accessor :from_postal_code + # The postal code that represents the shipping destination. + attr_accessor :to_postal_code + + def initialize(amount: nil, from_postal_code: nil, to_postal_code: nil) + @amount = amount + @from_postal_code = from_postal_code + @to_postal_code = to_postal_code + end + end + + class Tax < Stripe::RequestParams + # Total portion of the amount that is for tax. + attr_accessor :total_tax_amount + + def initialize(total_tax_amount: nil) + @total_tax_amount = total_tax_amount + end + end + # The amount an item was discounted for. + attr_accessor :discount_amount + # A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 100 line items. + attr_accessor :line_items + # Contains information about the shipping portion of the amount. + attr_accessor :shipping + # Contains information about the tax portion of the amount. + attr_accessor :tax + + def initialize(discount_amount: nil, line_items: nil, shipping: nil, tax: nil) + @discount_amount = discount_amount + @line_items = line_items + @shipping = shipping + @tax = tax + end + end + class Hooks < Stripe::RequestParams class Inputs < Stripe::RequestParams class Tax < Stripe::RequestParams @@ -7088,6 +7398,8 @@ module Stripe end # Amount intended to be collected by this PaymentIntent. A positive integer representing how much to charge in the [smallest currency unit](https://stripe.com/docs/currencies#zero-decimal) (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](https://stripe.com/docs/currencies#minimum-and-maximum-charge-amounts). The amount value supports up to eight digits (e.g., a value of 99999999 for a USD charge of $999,999.99). attr_accessor :amount + # Provides industry-specific information about the amount. + attr_accessor :amount_details # 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](https://stripe.com/docs/payments/connected-accounts). attr_accessor :application_fee_amount # Controls when the funds will be captured from the customer's account. @@ -7159,6 +7471,7 @@ module Stripe def initialize( amount: nil, + amount_details: nil, application_fee_amount: nil, capture_method: nil, currency: nil, @@ -7185,6 +7498,7 @@ module Stripe transfer_group: nil ) @amount = amount + @amount_details = amount_details @application_fee_amount = application_fee_amount @capture_method = capture_method @currency = currency @@ -7262,6 +7576,159 @@ module Stripe end class CaptureParams < Stripe::RequestParams + class AmountDetails < Stripe::RequestParams + class LineItem < Stripe::RequestParams + class PaymentMethodOptions < Stripe::RequestParams + class Card < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + attr_accessor :commodity_code + + def initialize(commodity_code: nil) + @commodity_code = commodity_code + end + end + + class CardPresent < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + attr_accessor :commodity_code + + def initialize(commodity_code: nil) + @commodity_code = commodity_code + end + end + + class Klarna < Stripe::RequestParams + # URL to an image for the product. Max length, 4096 characters. + attr_accessor :image_url + # URL to the product page. Max length, 4096 characters. + attr_accessor :product_url + # Reference for the subscription this line item is for. + attr_accessor :subscription_reference + + def initialize(image_url: nil, product_url: nil, subscription_reference: nil) + @image_url = image_url + @product_url = product_url + @subscription_reference = subscription_reference + end + end + + class Paypal < Stripe::RequestParams + # Type of the line item. + attr_accessor :category + # Description of the line item. + attr_accessor :description + # The Stripe account ID of the connected account that sells the item. + attr_accessor :sold_by + + def initialize(category: nil, description: nil, sold_by: nil) + @category = category + @description = description + @sold_by = sold_by + end + end + # This sub-hash contains line item details that are specific to `card` payment method." + attr_accessor :card + # This sub-hash contains line item details that are specific to `card_present` payment method." + attr_accessor :card_present + # This sub-hash contains line item details that are specific to `klarna` payment method." + attr_accessor :klarna + # This sub-hash contains line item details that are specific to `paypal` payment method." + attr_accessor :paypal + + def initialize(card: nil, card_present: nil, klarna: nil, paypal: nil) + @card = card + @card_present = card_present + @klarna = klarna + @paypal = paypal + end + end + + class Tax < Stripe::RequestParams + # The total tax on an item. Non-negative integer. + attr_accessor :total_tax_amount + + def initialize(total_tax_amount: nil) + @total_tax_amount = total_tax_amount + end + end + # The amount an item was discounted for. Positive integer. + attr_accessor :discount_amount + # Payment method-specific information for line items. + attr_accessor :payment_method_options + # Unique identifier of the product. At most 12 characters long. + attr_accessor :product_code + # Name of the product. At most 100 characters long. + attr_accessor :product_name + # Number of items of the product. Positive integer. + attr_accessor :quantity + # Contains information about the tax on the item. + attr_accessor :tax + # Cost of the product. Non-negative integer. + attr_accessor :unit_cost + # A unit of measure for the line item, such as gallons, feet, meters, etc. + attr_accessor :unit_of_measure + + def initialize( + discount_amount: nil, + payment_method_options: nil, + product_code: nil, + product_name: nil, + quantity: nil, + tax: nil, + unit_cost: nil, + unit_of_measure: nil + ) + @discount_amount = discount_amount + @payment_method_options = payment_method_options + @product_code = product_code + @product_name = product_name + @quantity = quantity + @tax = tax + @unit_cost = unit_cost + @unit_of_measure = unit_of_measure + end + end + + class Shipping < Stripe::RequestParams + # Portion of the amount that is for shipping. + attr_accessor :amount + # The postal code that represents the shipping source. + attr_accessor :from_postal_code + # The postal code that represents the shipping destination. + attr_accessor :to_postal_code + + def initialize(amount: nil, from_postal_code: nil, to_postal_code: nil) + @amount = amount + @from_postal_code = from_postal_code + @to_postal_code = to_postal_code + end + end + + class Tax < Stripe::RequestParams + # Total portion of the amount that is for tax. + attr_accessor :total_tax_amount + + def initialize(total_tax_amount: nil) + @total_tax_amount = total_tax_amount + end + end + # The amount an item was discounted for. + attr_accessor :discount_amount + # A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 100 line items. + attr_accessor :line_items + # Contains information about the shipping portion of the amount. + attr_accessor :shipping + # Contains information about the tax portion of the amount. + attr_accessor :tax + + def initialize(discount_amount: nil, line_items: nil, shipping: nil, tax: nil) + @discount_amount = discount_amount + @line_items = line_items + @shipping = shipping + @tax = tax + end + end + class Hooks < Stripe::RequestParams class Inputs < Stripe::RequestParams class Tax < Stripe::RequestParams @@ -8000,6 +8467,8 @@ module Stripe @amount = amount end end + # Provides industry-specific information about the amount. + attr_accessor :amount_details # The amount to capture from the PaymentIntent, which must be less than or equal to the original amount. Defaults to the full `amount_capturable` if it's not provided. attr_accessor :amount_to_capture # 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](https://stripe.com/docs/payments/connected-accounts). @@ -8025,6 +8494,7 @@ module Stripe attr_accessor :transfer_data def initialize( + amount_details: nil, amount_to_capture: nil, application_fee_amount: nil, expand: nil, @@ -8036,6 +8506,7 @@ module Stripe statement_descriptor_suffix: nil, transfer_data: nil ) + @amount_details = amount_details @amount_to_capture = amount_to_capture @application_fee_amount = application_fee_amount @expand = expand @@ -8050,6 +8521,159 @@ module Stripe end class ConfirmParams < Stripe::RequestParams + class AmountDetails < Stripe::RequestParams + class LineItem < Stripe::RequestParams + class PaymentMethodOptions < Stripe::RequestParams + class Card < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + attr_accessor :commodity_code + + def initialize(commodity_code: nil) + @commodity_code = commodity_code + end + end + + class CardPresent < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + attr_accessor :commodity_code + + def initialize(commodity_code: nil) + @commodity_code = commodity_code + end + end + + class Klarna < Stripe::RequestParams + # URL to an image for the product. Max length, 4096 characters. + attr_accessor :image_url + # URL to the product page. Max length, 4096 characters. + attr_accessor :product_url + # Reference for the subscription this line item is for. + attr_accessor :subscription_reference + + def initialize(image_url: nil, product_url: nil, subscription_reference: nil) + @image_url = image_url + @product_url = product_url + @subscription_reference = subscription_reference + end + end + + class Paypal < Stripe::RequestParams + # Type of the line item. + attr_accessor :category + # Description of the line item. + attr_accessor :description + # The Stripe account ID of the connected account that sells the item. + attr_accessor :sold_by + + def initialize(category: nil, description: nil, sold_by: nil) + @category = category + @description = description + @sold_by = sold_by + end + end + # This sub-hash contains line item details that are specific to `card` payment method." + attr_accessor :card + # This sub-hash contains line item details that are specific to `card_present` payment method." + attr_accessor :card_present + # This sub-hash contains line item details that are specific to `klarna` payment method." + attr_accessor :klarna + # This sub-hash contains line item details that are specific to `paypal` payment method." + attr_accessor :paypal + + def initialize(card: nil, card_present: nil, klarna: nil, paypal: nil) + @card = card + @card_present = card_present + @klarna = klarna + @paypal = paypal + end + end + + class Tax < Stripe::RequestParams + # The total tax on an item. Non-negative integer. + attr_accessor :total_tax_amount + + def initialize(total_tax_amount: nil) + @total_tax_amount = total_tax_amount + end + end + # The amount an item was discounted for. Positive integer. + attr_accessor :discount_amount + # Payment method-specific information for line items. + attr_accessor :payment_method_options + # Unique identifier of the product. At most 12 characters long. + attr_accessor :product_code + # Name of the product. At most 100 characters long. + attr_accessor :product_name + # Number of items of the product. Positive integer. + attr_accessor :quantity + # Contains information about the tax on the item. + attr_accessor :tax + # Cost of the product. Non-negative integer. + attr_accessor :unit_cost + # A unit of measure for the line item, such as gallons, feet, meters, etc. + attr_accessor :unit_of_measure + + def initialize( + discount_amount: nil, + payment_method_options: nil, + product_code: nil, + product_name: nil, + quantity: nil, + tax: nil, + unit_cost: nil, + unit_of_measure: nil + ) + @discount_amount = discount_amount + @payment_method_options = payment_method_options + @product_code = product_code + @product_name = product_name + @quantity = quantity + @tax = tax + @unit_cost = unit_cost + @unit_of_measure = unit_of_measure + end + end + + class Shipping < Stripe::RequestParams + # Portion of the amount that is for shipping. + attr_accessor :amount + # The postal code that represents the shipping source. + attr_accessor :from_postal_code + # The postal code that represents the shipping destination. + attr_accessor :to_postal_code + + def initialize(amount: nil, from_postal_code: nil, to_postal_code: nil) + @amount = amount + @from_postal_code = from_postal_code + @to_postal_code = to_postal_code + end + end + + class Tax < Stripe::RequestParams + # Total portion of the amount that is for tax. + attr_accessor :total_tax_amount + + def initialize(total_tax_amount: nil) + @total_tax_amount = total_tax_amount + end + end + # The amount an item was discounted for. + attr_accessor :discount_amount + # A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 100 line items. + attr_accessor :line_items + # Contains information about the shipping portion of the amount. + attr_accessor :shipping + # Contains information about the tax portion of the amount. + attr_accessor :tax + + def initialize(discount_amount: nil, line_items: nil, shipping: nil, tax: nil) + @discount_amount = discount_amount + @line_items = line_items + @shipping = shipping + @tax = tax + end + end + class Hooks < Stripe::RequestParams class Inputs < Stripe::RequestParams class Tax < Stripe::RequestParams @@ -11452,6 +12076,8 @@ module Stripe @tracking_number = tracking_number end end + # Provides industry-specific information about the amount. + attr_accessor :amount_details # 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](https://stripe.com/docs/payments/connected-accounts). attr_accessor :application_fee_amount # Controls when the funds will be captured from the customer's account. @@ -11511,6 +12137,7 @@ module Stripe attr_accessor :use_stripe_sdk def initialize( + amount_details: nil, application_fee_amount: nil, capture_method: nil, confirmation_token: nil, @@ -11533,6 +12160,7 @@ module Stripe shipping: nil, use_stripe_sdk: nil ) + @amount_details = amount_details @application_fee_amount = application_fee_amount @capture_method = capture_method @confirmation_token = confirmation_token diff --git a/rbi/stripe.rbi b/rbi/stripe.rbi index 60eb5ae3..6c2a1b9b 100644 --- a/rbi/stripe.rbi +++ b/rbi/stripe.rbi @@ -48505,6 +48505,172 @@ module Stripe ); end end class CreateParams < Stripe::RequestParams + class AmountDetails < Stripe::RequestParams + class LineItem < Stripe::RequestParams + class PaymentMethodOptions < Stripe::RequestParams + class Card < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class CardPresent < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class Klarna < Stripe::RequestParams + # URL to an image for the product. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :image_url + # URL to the product page. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :product_url + # Reference for the subscription this line item is for. + sig { returns(T.nilable(String)) } + attr_accessor :subscription_reference + sig { + params(image_url: T.nilable(String), product_url: T.nilable(String), subscription_reference: T.nilable(String)).void + } + def initialize(image_url: nil, product_url: nil, subscription_reference: nil); end + end + class Paypal < Stripe::RequestParams + # Type of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :category + # Description of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :description + # The Stripe account ID of the connected account that sells the item. + sig { returns(T.nilable(String)) } + attr_accessor :sold_by + sig { + params(category: T.nilable(String), description: T.nilable(String), sold_by: T.nilable(String)).void + } + def initialize(category: nil, description: nil, sold_by: nil); end + end + # This sub-hash contains line item details that are specific to `card` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::Card)) + } + attr_accessor :card + # This sub-hash contains line item details that are specific to `card_present` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent)) + } + attr_accessor :card_present + # This sub-hash contains line item details that are specific to `klarna` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna)) + } + attr_accessor :klarna + # This sub-hash contains line item details that are specific to `paypal` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)) + } + attr_accessor :paypal + sig { + params(card: T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::Card), card_present: T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent), klarna: T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna), paypal: T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)).void + } + def initialize(card: nil, card_present: nil, klarna: nil, paypal: nil); end + end + class Tax < Stripe::RequestParams + # The total tax on an item. Non-negative integer. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. Positive integer. + sig { returns(T.nilable(Integer)) } + attr_accessor :discount_amount + # Payment method-specific information for line items. + sig { + returns(T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem::PaymentMethodOptions)) + } + attr_accessor :payment_method_options + # Unique identifier of the product. At most 12 characters long. + sig { returns(T.nilable(String)) } + attr_accessor :product_code + # Name of the product. At most 100 characters long. + sig { returns(String) } + attr_accessor :product_name + # Number of items of the product. Positive integer. + sig { returns(Integer) } + attr_accessor :quantity + # Contains information about the tax on the item. + sig { + returns(T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem::Tax)) + } + attr_accessor :tax + # Cost of the product. Non-negative integer. + sig { returns(Integer) } + attr_accessor :unit_cost + # A unit of measure for the line item, such as gallons, feet, meters, etc. + sig { returns(T.nilable(String)) } + attr_accessor :unit_of_measure + sig { + params(discount_amount: T.nilable(Integer), payment_method_options: T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem::PaymentMethodOptions), product_code: T.nilable(String), product_name: String, quantity: Integer, tax: T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem::Tax), unit_cost: Integer, unit_of_measure: T.nilable(String)).void + } + def initialize( + discount_amount: nil, + payment_method_options: nil, + product_code: nil, + product_name: nil, + quantity: nil, + tax: nil, + unit_cost: nil, + unit_of_measure: nil + ); end + end + class Shipping < Stripe::RequestParams + # Portion of the amount that is for shipping. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :amount + # The postal code that represents the shipping source. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :from_postal_code + # The postal code that represents the shipping destination. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :to_postal_code + sig { + params(amount: T.nilable(T.nilable(T.any(String, Integer))), from_postal_code: T.nilable(T.nilable(String)), to_postal_code: T.nilable(T.nilable(String))).void + } + def initialize(amount: nil, from_postal_code: nil, to_postal_code: nil); end + end + class Tax < Stripe::RequestParams + # Total portion of the amount that is for tax. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :discount_amount + # A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 100 line items. + sig { + returns(T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem])))) + } + attr_accessor :line_items + # Contains information about the shipping portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::CreateParams::AmountDetails::Shipping)))) + } + attr_accessor :shipping + # Contains information about the tax portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::CreateParams::AmountDetails::Tax)))) + } + attr_accessor :tax + sig { + params(discount_amount: T.nilable(T.nilable(T.any(String, Integer))), line_items: T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem]))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::CreateParams::AmountDetails::Shipping))), tax: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::CreateParams::AmountDetails::Tax)))).void + } + def initialize(discount_amount: nil, line_items: nil, shipping: nil, tax: nil); end + end class AutomaticPaymentMethods < Stripe::RequestParams # Controls whether this PaymentIntent will accept redirect-based payment methods. # @@ -52134,6 +52300,9 @@ module Stripe # Amount intended to be collected by this PaymentIntent. A positive integer representing how much to charge in the [smallest currency unit](https://stripe.com/docs/currencies#zero-decimal) (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](https://stripe.com/docs/currencies#minimum-and-maximum-charge-amounts). The amount value supports up to eight digits (e.g., a value of 99999999 for a USD charge of $999,999.99). sig { returns(Integer) } attr_accessor :amount + # Provides industry-specific information about the amount. + sig { returns(T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails)) } + attr_accessor :amount_details # 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](https://stripe.com/docs/payments/connected-accounts). sig { returns(T.nilable(Integer)) } attr_accessor :application_fee_amount @@ -52270,10 +52439,11 @@ module Stripe sig { returns(T.nilable(T::Boolean)) } attr_accessor :use_stripe_sdk sig { - params(amount: Integer, application_fee_amount: T.nilable(Integer), automatic_payment_methods: T.nilable(::Stripe::PaymentIntent::CreateParams::AutomaticPaymentMethods), capture_method: T.nilable(String), confirm: T.nilable(T::Boolean), confirmation_method: T.nilable(String), confirmation_token: T.nilable(String), currency: String, customer: T.nilable(String), customer_account: T.nilable(String), description: T.nilable(String), error_on_requires_action: T.nilable(T::Boolean), expand: T.nilable(T::Array[String]), fx_quote: T.nilable(String), hooks: T.nilable(::Stripe::PaymentIntent::CreateParams::Hooks), mandate: T.nilable(String), mandate_data: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::CreateParams::MandateData))), metadata: T.nilable(T::Hash[String, String]), off_session: T.nilable(T.any(T::Boolean, String)), on_behalf_of: T.nilable(String), payment_details: T.nilable(::Stripe::PaymentIntent::CreateParams::PaymentDetails), payment_method: T.nilable(String), payment_method_configuration: T.nilable(String), payment_method_data: T.nilable(::Stripe::PaymentIntent::CreateParams::PaymentMethodData), payment_method_options: T.nilable(::Stripe::PaymentIntent::CreateParams::PaymentMethodOptions), payment_method_types: T.nilable(T::Array[String]), radar_options: T.nilable(::Stripe::PaymentIntent::CreateParams::RadarOptions), receipt_email: T.nilable(String), return_url: T.nilable(String), secret_key_confirmation: T.nilable(String), setup_future_usage: T.nilable(String), shipping: T.nilable(::Stripe::PaymentIntent::CreateParams::Shipping), statement_descriptor: T.nilable(String), statement_descriptor_suffix: T.nilable(String), transfer_data: T.nilable(::Stripe::PaymentIntent::CreateParams::TransferData), transfer_group: T.nilable(String), use_stripe_sdk: T.nilable(T::Boolean)).void + params(amount: Integer, amount_details: T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails), application_fee_amount: T.nilable(Integer), automatic_payment_methods: T.nilable(::Stripe::PaymentIntent::CreateParams::AutomaticPaymentMethods), capture_method: T.nilable(String), confirm: T.nilable(T::Boolean), confirmation_method: T.nilable(String), confirmation_token: T.nilable(String), currency: String, customer: T.nilable(String), customer_account: T.nilable(String), description: T.nilable(String), error_on_requires_action: T.nilable(T::Boolean), expand: T.nilable(T::Array[String]), fx_quote: T.nilable(String), hooks: T.nilable(::Stripe::PaymentIntent::CreateParams::Hooks), mandate: T.nilable(String), mandate_data: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::CreateParams::MandateData))), metadata: T.nilable(T::Hash[String, String]), off_session: T.nilable(T.any(T::Boolean, String)), on_behalf_of: T.nilable(String), payment_details: T.nilable(::Stripe::PaymentIntent::CreateParams::PaymentDetails), payment_method: T.nilable(String), payment_method_configuration: T.nilable(String), payment_method_data: T.nilable(::Stripe::PaymentIntent::CreateParams::PaymentMethodData), payment_method_options: T.nilable(::Stripe::PaymentIntent::CreateParams::PaymentMethodOptions), payment_method_types: T.nilable(T::Array[String]), radar_options: T.nilable(::Stripe::PaymentIntent::CreateParams::RadarOptions), receipt_email: T.nilable(String), return_url: T.nilable(String), secret_key_confirmation: T.nilable(String), setup_future_usage: T.nilable(String), shipping: T.nilable(::Stripe::PaymentIntent::CreateParams::Shipping), statement_descriptor: T.nilable(String), statement_descriptor_suffix: T.nilable(String), transfer_data: T.nilable(::Stripe::PaymentIntent::CreateParams::TransferData), transfer_group: T.nilable(String), use_stripe_sdk: T.nilable(T::Boolean)).void } def initialize( amount: nil, + amount_details: nil, application_fee_amount: nil, automatic_payment_methods: nil, capture_method: nil, @@ -52313,6 +52483,172 @@ module Stripe ); end end class UpdateParams < Stripe::RequestParams + class AmountDetails < Stripe::RequestParams + class LineItem < Stripe::RequestParams + class PaymentMethodOptions < Stripe::RequestParams + class Card < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class CardPresent < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class Klarna < Stripe::RequestParams + # URL to an image for the product. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :image_url + # URL to the product page. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :product_url + # Reference for the subscription this line item is for. + sig { returns(T.nilable(String)) } + attr_accessor :subscription_reference + sig { + params(image_url: T.nilable(String), product_url: T.nilable(String), subscription_reference: T.nilable(String)).void + } + def initialize(image_url: nil, product_url: nil, subscription_reference: nil); end + end + class Paypal < Stripe::RequestParams + # Type of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :category + # Description of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :description + # The Stripe account ID of the connected account that sells the item. + sig { returns(T.nilable(String)) } + attr_accessor :sold_by + sig { + params(category: T.nilable(String), description: T.nilable(String), sold_by: T.nilable(String)).void + } + def initialize(category: nil, description: nil, sold_by: nil); end + end + # This sub-hash contains line item details that are specific to `card` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::Card)) + } + attr_accessor :card + # This sub-hash contains line item details that are specific to `card_present` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent)) + } + attr_accessor :card_present + # This sub-hash contains line item details that are specific to `klarna` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna)) + } + attr_accessor :klarna + # This sub-hash contains line item details that are specific to `paypal` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)) + } + attr_accessor :paypal + sig { + params(card: T.nilable(::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::Card), card_present: T.nilable(::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent), klarna: T.nilable(::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna), paypal: T.nilable(::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)).void + } + def initialize(card: nil, card_present: nil, klarna: nil, paypal: nil); end + end + class Tax < Stripe::RequestParams + # The total tax on an item. Non-negative integer. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. Positive integer. + sig { returns(T.nilable(Integer)) } + attr_accessor :discount_amount + # Payment method-specific information for line items. + sig { + returns(T.nilable(::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions)) + } + attr_accessor :payment_method_options + # Unique identifier of the product. At most 12 characters long. + sig { returns(T.nilable(String)) } + attr_accessor :product_code + # Name of the product. At most 100 characters long. + sig { returns(String) } + attr_accessor :product_name + # Number of items of the product. Positive integer. + sig { returns(Integer) } + attr_accessor :quantity + # Contains information about the tax on the item. + sig { + returns(T.nilable(::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem::Tax)) + } + attr_accessor :tax + # Cost of the product. Non-negative integer. + sig { returns(Integer) } + attr_accessor :unit_cost + # A unit of measure for the line item, such as gallons, feet, meters, etc. + sig { returns(T.nilable(String)) } + attr_accessor :unit_of_measure + sig { + params(discount_amount: T.nilable(Integer), payment_method_options: T.nilable(::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions), product_code: T.nilable(String), product_name: String, quantity: Integer, tax: T.nilable(::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem::Tax), unit_cost: Integer, unit_of_measure: T.nilable(String)).void + } + def initialize( + discount_amount: nil, + payment_method_options: nil, + product_code: nil, + product_name: nil, + quantity: nil, + tax: nil, + unit_cost: nil, + unit_of_measure: nil + ); end + end + class Shipping < Stripe::RequestParams + # Portion of the amount that is for shipping. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :amount + # The postal code that represents the shipping source. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :from_postal_code + # The postal code that represents the shipping destination. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :to_postal_code + sig { + params(amount: T.nilable(T.nilable(T.any(String, Integer))), from_postal_code: T.nilable(T.nilable(String)), to_postal_code: T.nilable(T.nilable(String))).void + } + def initialize(amount: nil, from_postal_code: nil, to_postal_code: nil); end + end + class Tax < Stripe::RequestParams + # Total portion of the amount that is for tax. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :discount_amount + # A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 100 line items. + sig { + returns(T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem])))) + } + attr_accessor :line_items + # Contains information about the shipping portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::UpdateParams::AmountDetails::Shipping)))) + } + attr_accessor :shipping + # Contains information about the tax portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::UpdateParams::AmountDetails::Tax)))) + } + attr_accessor :tax + sig { + params(discount_amount: T.nilable(T.nilable(T.any(String, Integer))), line_items: T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem]))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::UpdateParams::AmountDetails::Shipping))), tax: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::UpdateParams::AmountDetails::Tax)))).void + } + def initialize(discount_amount: nil, line_items: nil, shipping: nil, tax: nil); end + end class Hooks < Stripe::RequestParams class Inputs < Stripe::RequestParams class Tax < Stripe::RequestParams @@ -55902,6 +56238,11 @@ module Stripe # Amount intended to be collected by this PaymentIntent. A positive integer representing how much to charge in the [smallest currency unit](https://stripe.com/docs/currencies#zero-decimal) (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](https://stripe.com/docs/currencies#minimum-and-maximum-charge-amounts). The amount value supports up to eight digits (e.g., a value of 99999999 for a USD charge of $999,999.99). sig { returns(T.nilable(Integer)) } attr_accessor :amount + # Provides industry-specific information about the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::UpdateParams::AmountDetails)))) + } + attr_accessor :amount_details # 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](https://stripe.com/docs/payments/connected-accounts). sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } attr_accessor :application_fee_amount @@ -55999,10 +56340,11 @@ module Stripe sig { returns(T.nilable(String)) } attr_accessor :transfer_group sig { - params(amount: T.nilable(Integer), application_fee_amount: T.nilable(T.nilable(T.any(String, Integer))), capture_method: T.nilable(String), currency: T.nilable(String), customer: T.nilable(String), customer_account: T.nilable(String), description: T.nilable(String), expand: T.nilable(T::Array[String]), fx_quote: T.nilable(String), hooks: T.nilable(::Stripe::PaymentIntent::UpdateParams::Hooks), mandate_data: T.nilable(::Stripe::PaymentIntent::UpdateParams::MandateData), metadata: T.nilable(T.nilable(T.any(String, T::Hash[String, String]))), payment_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::UpdateParams::PaymentDetails))), payment_method: T.nilable(String), payment_method_configuration: T.nilable(String), payment_method_data: T.nilable(::Stripe::PaymentIntent::UpdateParams::PaymentMethodData), payment_method_options: T.nilable(::Stripe::PaymentIntent::UpdateParams::PaymentMethodOptions), payment_method_types: T.nilable(T::Array[String]), receipt_email: T.nilable(T.nilable(String)), setup_future_usage: T.nilable(T.nilable(T.any(String, String))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::UpdateParams::Shipping))), statement_descriptor: T.nilable(String), statement_descriptor_suffix: T.nilable(String), transfer_data: T.nilable(::Stripe::PaymentIntent::UpdateParams::TransferData), transfer_group: T.nilable(String)).void + params(amount: T.nilable(Integer), amount_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::UpdateParams::AmountDetails))), application_fee_amount: T.nilable(T.nilable(T.any(String, Integer))), capture_method: T.nilable(String), currency: T.nilable(String), customer: T.nilable(String), customer_account: T.nilable(String), description: T.nilable(String), expand: T.nilable(T::Array[String]), fx_quote: T.nilable(String), hooks: T.nilable(::Stripe::PaymentIntent::UpdateParams::Hooks), mandate_data: T.nilable(::Stripe::PaymentIntent::UpdateParams::MandateData), metadata: T.nilable(T.nilable(T.any(String, T::Hash[String, String]))), payment_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::UpdateParams::PaymentDetails))), payment_method: T.nilable(String), payment_method_configuration: T.nilable(String), payment_method_data: T.nilable(::Stripe::PaymentIntent::UpdateParams::PaymentMethodData), payment_method_options: T.nilable(::Stripe::PaymentIntent::UpdateParams::PaymentMethodOptions), payment_method_types: T.nilable(T::Array[String]), receipt_email: T.nilable(T.nilable(String)), setup_future_usage: T.nilable(T.nilable(T.any(String, String))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::UpdateParams::Shipping))), statement_descriptor: T.nilable(String), statement_descriptor_suffix: T.nilable(String), transfer_data: T.nilable(::Stripe::PaymentIntent::UpdateParams::TransferData), transfer_group: T.nilable(String)).void } def initialize( amount: nil, + amount_details: nil, application_fee_amount: nil, capture_method: nil, currency: nil, @@ -56079,6 +56421,172 @@ module Stripe def initialize(cancellation_reason: nil, expand: nil); end end class CaptureParams < Stripe::RequestParams + class AmountDetails < Stripe::RequestParams + class LineItem < Stripe::RequestParams + class PaymentMethodOptions < Stripe::RequestParams + class Card < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class CardPresent < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class Klarna < Stripe::RequestParams + # URL to an image for the product. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :image_url + # URL to the product page. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :product_url + # Reference for the subscription this line item is for. + sig { returns(T.nilable(String)) } + attr_accessor :subscription_reference + sig { + params(image_url: T.nilable(String), product_url: T.nilable(String), subscription_reference: T.nilable(String)).void + } + def initialize(image_url: nil, product_url: nil, subscription_reference: nil); end + end + class Paypal < Stripe::RequestParams + # Type of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :category + # Description of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :description + # The Stripe account ID of the connected account that sells the item. + sig { returns(T.nilable(String)) } + attr_accessor :sold_by + sig { + params(category: T.nilable(String), description: T.nilable(String), sold_by: T.nilable(String)).void + } + def initialize(category: nil, description: nil, sold_by: nil); end + end + # This sub-hash contains line item details that are specific to `card` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::Card)) + } + attr_accessor :card + # This sub-hash contains line item details that are specific to `card_present` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent)) + } + attr_accessor :card_present + # This sub-hash contains line item details that are specific to `klarna` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna)) + } + attr_accessor :klarna + # This sub-hash contains line item details that are specific to `paypal` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)) + } + attr_accessor :paypal + sig { + params(card: T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::Card), card_present: T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent), klarna: T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna), paypal: T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)).void + } + def initialize(card: nil, card_present: nil, klarna: nil, paypal: nil); end + end + class Tax < Stripe::RequestParams + # The total tax on an item. Non-negative integer. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. Positive integer. + sig { returns(T.nilable(Integer)) } + attr_accessor :discount_amount + # Payment method-specific information for line items. + sig { + returns(T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions)) + } + attr_accessor :payment_method_options + # Unique identifier of the product. At most 12 characters long. + sig { returns(T.nilable(String)) } + attr_accessor :product_code + # Name of the product. At most 100 characters long. + sig { returns(String) } + attr_accessor :product_name + # Number of items of the product. Positive integer. + sig { returns(Integer) } + attr_accessor :quantity + # Contains information about the tax on the item. + sig { + returns(T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem::Tax)) + } + attr_accessor :tax + # Cost of the product. Non-negative integer. + sig { returns(Integer) } + attr_accessor :unit_cost + # A unit of measure for the line item, such as gallons, feet, meters, etc. + sig { returns(T.nilable(String)) } + attr_accessor :unit_of_measure + sig { + params(discount_amount: T.nilable(Integer), payment_method_options: T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions), product_code: T.nilable(String), product_name: String, quantity: Integer, tax: T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem::Tax), unit_cost: Integer, unit_of_measure: T.nilable(String)).void + } + def initialize( + discount_amount: nil, + payment_method_options: nil, + product_code: nil, + product_name: nil, + quantity: nil, + tax: nil, + unit_cost: nil, + unit_of_measure: nil + ); end + end + class Shipping < Stripe::RequestParams + # Portion of the amount that is for shipping. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :amount + # The postal code that represents the shipping source. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :from_postal_code + # The postal code that represents the shipping destination. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :to_postal_code + sig { + params(amount: T.nilable(T.nilable(T.any(String, Integer))), from_postal_code: T.nilable(T.nilable(String)), to_postal_code: T.nilable(T.nilable(String))).void + } + def initialize(amount: nil, from_postal_code: nil, to_postal_code: nil); end + end + class Tax < Stripe::RequestParams + # Total portion of the amount that is for tax. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :discount_amount + # A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 100 line items. + sig { + returns(T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem])))) + } + attr_accessor :line_items + # Contains information about the shipping portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::CaptureParams::AmountDetails::Shipping)))) + } + attr_accessor :shipping + # Contains information about the tax portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::CaptureParams::AmountDetails::Tax)))) + } + attr_accessor :tax + sig { + params(discount_amount: T.nilable(T.nilable(T.any(String, Integer))), line_items: T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem]))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::CaptureParams::AmountDetails::Shipping))), tax: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::CaptureParams::AmountDetails::Tax)))).void + } + def initialize(discount_amount: nil, line_items: nil, shipping: nil, tax: nil); end + end class Hooks < Stripe::RequestParams class Inputs < Stripe::RequestParams class Tax < Stripe::RequestParams @@ -56864,6 +57372,9 @@ module Stripe sig { params(amount: T.nilable(Integer)).void } def initialize(amount: nil); end end + # Provides industry-specific information about the amount. + sig { returns(T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails)) } + attr_accessor :amount_details # The amount to capture from the PaymentIntent, which must be less than or equal to the original amount. Defaults to the full `amount_capturable` if it's not provided. sig { returns(T.nilable(Integer)) } attr_accessor :amount_to_capture @@ -56900,9 +57411,10 @@ module Stripe sig { returns(T.nilable(::Stripe::PaymentIntent::CaptureParams::TransferData)) } attr_accessor :transfer_data sig { - params(amount_to_capture: T.nilable(Integer), application_fee_amount: T.nilable(Integer), expand: T.nilable(T::Array[String]), final_capture: T.nilable(T::Boolean), hooks: T.nilable(::Stripe::PaymentIntent::CaptureParams::Hooks), metadata: T.nilable(T.nilable(T.any(String, T::Hash[String, String]))), payment_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::CaptureParams::PaymentDetails))), statement_descriptor: T.nilable(String), statement_descriptor_suffix: T.nilable(String), transfer_data: T.nilable(::Stripe::PaymentIntent::CaptureParams::TransferData)).void + params(amount_details: T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails), amount_to_capture: T.nilable(Integer), application_fee_amount: T.nilable(Integer), expand: T.nilable(T::Array[String]), final_capture: T.nilable(T::Boolean), hooks: T.nilable(::Stripe::PaymentIntent::CaptureParams::Hooks), metadata: T.nilable(T.nilable(T.any(String, T::Hash[String, String]))), payment_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::CaptureParams::PaymentDetails))), statement_descriptor: T.nilable(String), statement_descriptor_suffix: T.nilable(String), transfer_data: T.nilable(::Stripe::PaymentIntent::CaptureParams::TransferData)).void } def initialize( + amount_details: nil, amount_to_capture: nil, application_fee_amount: nil, expand: nil, @@ -56916,6 +57428,172 @@ module Stripe ); end end class ConfirmParams < Stripe::RequestParams + class AmountDetails < Stripe::RequestParams + class LineItem < Stripe::RequestParams + class PaymentMethodOptions < Stripe::RequestParams + class Card < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class CardPresent < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class Klarna < Stripe::RequestParams + # URL to an image for the product. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :image_url + # URL to the product page. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :product_url + # Reference for the subscription this line item is for. + sig { returns(T.nilable(String)) } + attr_accessor :subscription_reference + sig { + params(image_url: T.nilable(String), product_url: T.nilable(String), subscription_reference: T.nilable(String)).void + } + def initialize(image_url: nil, product_url: nil, subscription_reference: nil); end + end + class Paypal < Stripe::RequestParams + # Type of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :category + # Description of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :description + # The Stripe account ID of the connected account that sells the item. + sig { returns(T.nilable(String)) } + attr_accessor :sold_by + sig { + params(category: T.nilable(String), description: T.nilable(String), sold_by: T.nilable(String)).void + } + def initialize(category: nil, description: nil, sold_by: nil); end + end + # This sub-hash contains line item details that are specific to `card` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::Card)) + } + attr_accessor :card + # This sub-hash contains line item details that are specific to `card_present` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent)) + } + attr_accessor :card_present + # This sub-hash contains line item details that are specific to `klarna` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna)) + } + attr_accessor :klarna + # This sub-hash contains line item details that are specific to `paypal` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)) + } + attr_accessor :paypal + sig { + params(card: T.nilable(::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::Card), card_present: T.nilable(::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent), klarna: T.nilable(::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna), paypal: T.nilable(::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)).void + } + def initialize(card: nil, card_present: nil, klarna: nil, paypal: nil); end + end + class Tax < Stripe::RequestParams + # The total tax on an item. Non-negative integer. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. Positive integer. + sig { returns(T.nilable(Integer)) } + attr_accessor :discount_amount + # Payment method-specific information for line items. + sig { + returns(T.nilable(::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions)) + } + attr_accessor :payment_method_options + # Unique identifier of the product. At most 12 characters long. + sig { returns(T.nilable(String)) } + attr_accessor :product_code + # Name of the product. At most 100 characters long. + sig { returns(String) } + attr_accessor :product_name + # Number of items of the product. Positive integer. + sig { returns(Integer) } + attr_accessor :quantity + # Contains information about the tax on the item. + sig { + returns(T.nilable(::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem::Tax)) + } + attr_accessor :tax + # Cost of the product. Non-negative integer. + sig { returns(Integer) } + attr_accessor :unit_cost + # A unit of measure for the line item, such as gallons, feet, meters, etc. + sig { returns(T.nilable(String)) } + attr_accessor :unit_of_measure + sig { + params(discount_amount: T.nilable(Integer), payment_method_options: T.nilable(::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions), product_code: T.nilable(String), product_name: String, quantity: Integer, tax: T.nilable(::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem::Tax), unit_cost: Integer, unit_of_measure: T.nilable(String)).void + } + def initialize( + discount_amount: nil, + payment_method_options: nil, + product_code: nil, + product_name: nil, + quantity: nil, + tax: nil, + unit_cost: nil, + unit_of_measure: nil + ); end + end + class Shipping < Stripe::RequestParams + # Portion of the amount that is for shipping. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :amount + # The postal code that represents the shipping source. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :from_postal_code + # The postal code that represents the shipping destination. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :to_postal_code + sig { + params(amount: T.nilable(T.nilable(T.any(String, Integer))), from_postal_code: T.nilable(T.nilable(String)), to_postal_code: T.nilable(T.nilable(String))).void + } + def initialize(amount: nil, from_postal_code: nil, to_postal_code: nil); end + end + class Tax < Stripe::RequestParams + # Total portion of the amount that is for tax. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :discount_amount + # A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 100 line items. + sig { + returns(T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem])))) + } + attr_accessor :line_items + # Contains information about the shipping portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::ConfirmParams::AmountDetails::Shipping)))) + } + attr_accessor :shipping + # Contains information about the tax portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::ConfirmParams::AmountDetails::Tax)))) + } + attr_accessor :tax + sig { + params(discount_amount: T.nilable(T.nilable(T.any(String, Integer))), line_items: T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem]))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::ConfirmParams::AmountDetails::Shipping))), tax: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::ConfirmParams::AmountDetails::Tax)))).void + } + def initialize(discount_amount: nil, line_items: nil, shipping: nil, tax: nil); end + end class Hooks < Stripe::RequestParams class Inputs < Stripe::RequestParams class Tax < Stripe::RequestParams @@ -60537,6 +61215,11 @@ module Stripe } def initialize(address: nil, carrier: nil, name: nil, phone: nil, tracking_number: nil); end end + # Provides industry-specific information about the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::ConfirmParams::AmountDetails)))) + } + attr_accessor :amount_details # 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](https://stripe.com/docs/payments/connected-accounts). sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } attr_accessor :application_fee_amount @@ -60622,9 +61305,10 @@ module Stripe sig { returns(T.nilable(T::Boolean)) } attr_accessor :use_stripe_sdk sig { - params(application_fee_amount: T.nilable(T.nilable(T.any(String, Integer))), capture_method: T.nilable(String), confirmation_token: T.nilable(String), error_on_requires_action: T.nilable(T::Boolean), expand: T.nilable(T::Array[String]), fx_quote: T.nilable(String), hooks: T.nilable(::Stripe::PaymentIntent::ConfirmParams::Hooks), mandate: T.nilable(String), mandate_data: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::ConfirmParams::MandateData))), off_session: T.nilable(T.any(T::Boolean, String)), payment_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::ConfirmParams::PaymentDetails))), payment_method: T.nilable(String), payment_method_data: T.nilable(::Stripe::PaymentIntent::ConfirmParams::PaymentMethodData), payment_method_options: T.nilable(::Stripe::PaymentIntent::ConfirmParams::PaymentMethodOptions), payment_method_types: T.nilable(T::Array[String]), radar_options: T.nilable(::Stripe::PaymentIntent::ConfirmParams::RadarOptions), receipt_email: T.nilable(T.nilable(String)), return_url: T.nilable(String), setup_future_usage: T.nilable(T.nilable(T.any(String, String))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::ConfirmParams::Shipping))), use_stripe_sdk: T.nilable(T::Boolean)).void + params(amount_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::ConfirmParams::AmountDetails))), application_fee_amount: T.nilable(T.nilable(T.any(String, Integer))), capture_method: T.nilable(String), confirmation_token: T.nilable(String), error_on_requires_action: T.nilable(T::Boolean), expand: T.nilable(T::Array[String]), fx_quote: T.nilable(String), hooks: T.nilable(::Stripe::PaymentIntent::ConfirmParams::Hooks), mandate: T.nilable(String), mandate_data: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::ConfirmParams::MandateData))), off_session: T.nilable(T.any(T::Boolean, String)), payment_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::ConfirmParams::PaymentDetails))), payment_method: T.nilable(String), payment_method_data: T.nilable(::Stripe::PaymentIntent::ConfirmParams::PaymentMethodData), payment_method_options: T.nilable(::Stripe::PaymentIntent::ConfirmParams::PaymentMethodOptions), payment_method_types: T.nilable(T::Array[String]), radar_options: T.nilable(::Stripe::PaymentIntent::ConfirmParams::RadarOptions), receipt_email: T.nilable(T.nilable(String)), return_url: T.nilable(String), setup_future_usage: T.nilable(T.nilable(T.any(String, String))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::ConfirmParams::Shipping))), use_stripe_sdk: T.nilable(T::Boolean)).void } def initialize( + amount_details: nil, application_fee_amount: nil, capture_method: nil, confirmation_token: nil, @@ -143816,6 +144500,172 @@ module Stripe ); end end class CreateParams < Stripe::RequestParams + class AmountDetails < Stripe::RequestParams + class LineItem < Stripe::RequestParams + class PaymentMethodOptions < Stripe::RequestParams + class Card < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class CardPresent < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class Klarna < Stripe::RequestParams + # URL to an image for the product. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :image_url + # URL to the product page. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :product_url + # Reference for the subscription this line item is for. + sig { returns(T.nilable(String)) } + attr_accessor :subscription_reference + sig { + params(image_url: T.nilable(String), product_url: T.nilable(String), subscription_reference: T.nilable(String)).void + } + def initialize(image_url: nil, product_url: nil, subscription_reference: nil); end + end + class Paypal < Stripe::RequestParams + # Type of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :category + # Description of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :description + # The Stripe account ID of the connected account that sells the item. + sig { returns(T.nilable(String)) } + attr_accessor :sold_by + sig { + params(category: T.nilable(String), description: T.nilable(String), sold_by: T.nilable(String)).void + } + def initialize(category: nil, description: nil, sold_by: nil); end + end + # This sub-hash contains line item details that are specific to `card` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::Card)) + } + attr_accessor :card + # This sub-hash contains line item details that are specific to `card_present` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent)) + } + attr_accessor :card_present + # This sub-hash contains line item details that are specific to `klarna` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna)) + } + attr_accessor :klarna + # This sub-hash contains line item details that are specific to `paypal` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)) + } + attr_accessor :paypal + sig { + params(card: T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::Card), card_present: T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent), klarna: T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna), paypal: T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)).void + } + def initialize(card: nil, card_present: nil, klarna: nil, paypal: nil); end + end + class Tax < Stripe::RequestParams + # The total tax on an item. Non-negative integer. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. Positive integer. + sig { returns(T.nilable(Integer)) } + attr_accessor :discount_amount + # Payment method-specific information for line items. + sig { + returns(T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem::PaymentMethodOptions)) + } + attr_accessor :payment_method_options + # Unique identifier of the product. At most 12 characters long. + sig { returns(T.nilable(String)) } + attr_accessor :product_code + # Name of the product. At most 100 characters long. + sig { returns(String) } + attr_accessor :product_name + # Number of items of the product. Positive integer. + sig { returns(Integer) } + attr_accessor :quantity + # Contains information about the tax on the item. + sig { + returns(T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem::Tax)) + } + attr_accessor :tax + # Cost of the product. Non-negative integer. + sig { returns(Integer) } + attr_accessor :unit_cost + # A unit of measure for the line item, such as gallons, feet, meters, etc. + sig { returns(T.nilable(String)) } + attr_accessor :unit_of_measure + sig { + params(discount_amount: T.nilable(Integer), payment_method_options: T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem::PaymentMethodOptions), product_code: T.nilable(String), product_name: String, quantity: Integer, tax: T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem::Tax), unit_cost: Integer, unit_of_measure: T.nilable(String)).void + } + def initialize( + discount_amount: nil, + payment_method_options: nil, + product_code: nil, + product_name: nil, + quantity: nil, + tax: nil, + unit_cost: nil, + unit_of_measure: nil + ); end + end + class Shipping < Stripe::RequestParams + # Portion of the amount that is for shipping. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :amount + # The postal code that represents the shipping source. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :from_postal_code + # The postal code that represents the shipping destination. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :to_postal_code + sig { + params(amount: T.nilable(T.nilable(T.any(String, Integer))), from_postal_code: T.nilable(T.nilable(String)), to_postal_code: T.nilable(T.nilable(String))).void + } + def initialize(amount: nil, from_postal_code: nil, to_postal_code: nil); end + end + class Tax < Stripe::RequestParams + # Total portion of the amount that is for tax. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :discount_amount + # A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 100 line items. + sig { + returns(T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem])))) + } + attr_accessor :line_items + # Contains information about the shipping portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::CreateParams::AmountDetails::Shipping)))) + } + attr_accessor :shipping + # Contains information about the tax portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::CreateParams::AmountDetails::Tax)))) + } + attr_accessor :tax + sig { + params(discount_amount: T.nilable(T.nilable(T.any(String, Integer))), line_items: T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem]))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::CreateParams::AmountDetails::Shipping))), tax: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::CreateParams::AmountDetails::Tax)))).void + } + def initialize(discount_amount: nil, line_items: nil, shipping: nil, tax: nil); end + end class AutomaticPaymentMethods < Stripe::RequestParams # Controls whether this PaymentIntent will accept redirect-based payment methods. # @@ -147513,6 +148363,9 @@ module Stripe # Amount intended to be collected by this PaymentIntent. A positive integer representing how much to charge in the [smallest currency unit](https://stripe.com/docs/currencies#zero-decimal) (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](https://stripe.com/docs/currencies#minimum-and-maximum-charge-amounts). The amount value supports up to eight digits (e.g., a value of 99999999 for a USD charge of $999,999.99). sig { returns(Integer) } attr_accessor :amount + # Provides industry-specific information about the amount. + sig { returns(T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails)) } + attr_accessor :amount_details # 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](https://stripe.com/docs/payments/connected-accounts). sig { returns(T.nilable(Integer)) } attr_accessor :application_fee_amount @@ -147651,10 +148504,11 @@ module Stripe sig { returns(T.nilable(T::Boolean)) } attr_accessor :use_stripe_sdk sig { - params(amount: Integer, application_fee_amount: T.nilable(Integer), automatic_payment_methods: T.nilable(::Stripe::PaymentIntentService::CreateParams::AutomaticPaymentMethods), capture_method: T.nilable(String), confirm: T.nilable(T::Boolean), confirmation_method: T.nilable(String), confirmation_token: T.nilable(String), currency: String, customer: T.nilable(String), customer_account: T.nilable(String), description: T.nilable(String), error_on_requires_action: T.nilable(T::Boolean), expand: T.nilable(T::Array[String]), fx_quote: T.nilable(String), hooks: T.nilable(::Stripe::PaymentIntentService::CreateParams::Hooks), mandate: T.nilable(String), mandate_data: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::CreateParams::MandateData))), metadata: T.nilable(T::Hash[String, String]), off_session: T.nilable(T.any(T::Boolean, String)), on_behalf_of: T.nilable(String), payment_details: T.nilable(::Stripe::PaymentIntentService::CreateParams::PaymentDetails), payment_method: T.nilable(String), payment_method_configuration: T.nilable(String), payment_method_data: T.nilable(::Stripe::PaymentIntentService::CreateParams::PaymentMethodData), payment_method_options: T.nilable(::Stripe::PaymentIntentService::CreateParams::PaymentMethodOptions), payment_method_types: T.nilable(T::Array[String]), radar_options: T.nilable(::Stripe::PaymentIntentService::CreateParams::RadarOptions), receipt_email: T.nilable(String), return_url: T.nilable(String), secret_key_confirmation: T.nilable(String), setup_future_usage: T.nilable(String), shipping: T.nilable(::Stripe::PaymentIntentService::CreateParams::Shipping), statement_descriptor: T.nilable(String), statement_descriptor_suffix: T.nilable(String), transfer_data: T.nilable(::Stripe::PaymentIntentService::CreateParams::TransferData), transfer_group: T.nilable(String), use_stripe_sdk: T.nilable(T::Boolean)).void + params(amount: Integer, amount_details: T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails), application_fee_amount: T.nilable(Integer), automatic_payment_methods: T.nilable(::Stripe::PaymentIntentService::CreateParams::AutomaticPaymentMethods), capture_method: T.nilable(String), confirm: T.nilable(T::Boolean), confirmation_method: T.nilable(String), confirmation_token: T.nilable(String), currency: String, customer: T.nilable(String), customer_account: T.nilable(String), description: T.nilable(String), error_on_requires_action: T.nilable(T::Boolean), expand: T.nilable(T::Array[String]), fx_quote: T.nilable(String), hooks: T.nilable(::Stripe::PaymentIntentService::CreateParams::Hooks), mandate: T.nilable(String), mandate_data: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::CreateParams::MandateData))), metadata: T.nilable(T::Hash[String, String]), off_session: T.nilable(T.any(T::Boolean, String)), on_behalf_of: T.nilable(String), payment_details: T.nilable(::Stripe::PaymentIntentService::CreateParams::PaymentDetails), payment_method: T.nilable(String), payment_method_configuration: T.nilable(String), payment_method_data: T.nilable(::Stripe::PaymentIntentService::CreateParams::PaymentMethodData), payment_method_options: T.nilable(::Stripe::PaymentIntentService::CreateParams::PaymentMethodOptions), payment_method_types: T.nilable(T::Array[String]), radar_options: T.nilable(::Stripe::PaymentIntentService::CreateParams::RadarOptions), receipt_email: T.nilable(String), return_url: T.nilable(String), secret_key_confirmation: T.nilable(String), setup_future_usage: T.nilable(String), shipping: T.nilable(::Stripe::PaymentIntentService::CreateParams::Shipping), statement_descriptor: T.nilable(String), statement_descriptor_suffix: T.nilable(String), transfer_data: T.nilable(::Stripe::PaymentIntentService::CreateParams::TransferData), transfer_group: T.nilable(String), use_stripe_sdk: T.nilable(T::Boolean)).void } def initialize( amount: nil, + amount_details: nil, application_fee_amount: nil, automatic_payment_methods: nil, capture_method: nil, @@ -147704,6 +148558,172 @@ module Stripe def initialize(client_secret: nil, expand: nil); end end class UpdateParams < Stripe::RequestParams + class AmountDetails < Stripe::RequestParams + class LineItem < Stripe::RequestParams + class PaymentMethodOptions < Stripe::RequestParams + class Card < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class CardPresent < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class Klarna < Stripe::RequestParams + # URL to an image for the product. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :image_url + # URL to the product page. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :product_url + # Reference for the subscription this line item is for. + sig { returns(T.nilable(String)) } + attr_accessor :subscription_reference + sig { + params(image_url: T.nilable(String), product_url: T.nilable(String), subscription_reference: T.nilable(String)).void + } + def initialize(image_url: nil, product_url: nil, subscription_reference: nil); end + end + class Paypal < Stripe::RequestParams + # Type of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :category + # Description of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :description + # The Stripe account ID of the connected account that sells the item. + sig { returns(T.nilable(String)) } + attr_accessor :sold_by + sig { + params(category: T.nilable(String), description: T.nilable(String), sold_by: T.nilable(String)).void + } + def initialize(category: nil, description: nil, sold_by: nil); end + end + # This sub-hash contains line item details that are specific to `card` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::Card)) + } + attr_accessor :card + # This sub-hash contains line item details that are specific to `card_present` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent)) + } + attr_accessor :card_present + # This sub-hash contains line item details that are specific to `klarna` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna)) + } + attr_accessor :klarna + # This sub-hash contains line item details that are specific to `paypal` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)) + } + attr_accessor :paypal + sig { + params(card: T.nilable(::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::Card), card_present: T.nilable(::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent), klarna: T.nilable(::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna), paypal: T.nilable(::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)).void + } + def initialize(card: nil, card_present: nil, klarna: nil, paypal: nil); end + end + class Tax < Stripe::RequestParams + # The total tax on an item. Non-negative integer. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. Positive integer. + sig { returns(T.nilable(Integer)) } + attr_accessor :discount_amount + # Payment method-specific information for line items. + sig { + returns(T.nilable(::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions)) + } + attr_accessor :payment_method_options + # Unique identifier of the product. At most 12 characters long. + sig { returns(T.nilable(String)) } + attr_accessor :product_code + # Name of the product. At most 100 characters long. + sig { returns(String) } + attr_accessor :product_name + # Number of items of the product. Positive integer. + sig { returns(Integer) } + attr_accessor :quantity + # Contains information about the tax on the item. + sig { + returns(T.nilable(::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem::Tax)) + } + attr_accessor :tax + # Cost of the product. Non-negative integer. + sig { returns(Integer) } + attr_accessor :unit_cost + # A unit of measure for the line item, such as gallons, feet, meters, etc. + sig { returns(T.nilable(String)) } + attr_accessor :unit_of_measure + sig { + params(discount_amount: T.nilable(Integer), payment_method_options: T.nilable(::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions), product_code: T.nilable(String), product_name: String, quantity: Integer, tax: T.nilable(::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem::Tax), unit_cost: Integer, unit_of_measure: T.nilable(String)).void + } + def initialize( + discount_amount: nil, + payment_method_options: nil, + product_code: nil, + product_name: nil, + quantity: nil, + tax: nil, + unit_cost: nil, + unit_of_measure: nil + ); end + end + class Shipping < Stripe::RequestParams + # Portion of the amount that is for shipping. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :amount + # The postal code that represents the shipping source. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :from_postal_code + # The postal code that represents the shipping destination. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :to_postal_code + sig { + params(amount: T.nilable(T.nilable(T.any(String, Integer))), from_postal_code: T.nilable(T.nilable(String)), to_postal_code: T.nilable(T.nilable(String))).void + } + def initialize(amount: nil, from_postal_code: nil, to_postal_code: nil); end + end + class Tax < Stripe::RequestParams + # Total portion of the amount that is for tax. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :discount_amount + # A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 100 line items. + sig { + returns(T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem])))) + } + attr_accessor :line_items + # Contains information about the shipping portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::UpdateParams::AmountDetails::Shipping)))) + } + attr_accessor :shipping + # Contains information about the tax portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::UpdateParams::AmountDetails::Tax)))) + } + attr_accessor :tax + sig { + params(discount_amount: T.nilable(T.nilable(T.any(String, Integer))), line_items: T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem]))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::UpdateParams::AmountDetails::Shipping))), tax: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::UpdateParams::AmountDetails::Tax)))).void + } + def initialize(discount_amount: nil, line_items: nil, shipping: nil, tax: nil); end + end class Hooks < Stripe::RequestParams class Inputs < Stripe::RequestParams class Tax < Stripe::RequestParams @@ -151361,6 +152381,11 @@ module Stripe # Amount intended to be collected by this PaymentIntent. A positive integer representing how much to charge in the [smallest currency unit](https://stripe.com/docs/currencies#zero-decimal) (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](https://stripe.com/docs/currencies#minimum-and-maximum-charge-amounts). The amount value supports up to eight digits (e.g., a value of 99999999 for a USD charge of $999,999.99). sig { returns(T.nilable(Integer)) } attr_accessor :amount + # Provides industry-specific information about the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::UpdateParams::AmountDetails)))) + } + attr_accessor :amount_details # 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](https://stripe.com/docs/payments/connected-accounts). sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } attr_accessor :application_fee_amount @@ -151458,10 +152483,11 @@ module Stripe sig { returns(T.nilable(String)) } attr_accessor :transfer_group sig { - params(amount: T.nilable(Integer), application_fee_amount: T.nilable(T.nilable(T.any(String, Integer))), capture_method: T.nilable(String), currency: T.nilable(String), customer: T.nilable(String), customer_account: T.nilable(String), description: T.nilable(String), expand: T.nilable(T::Array[String]), fx_quote: T.nilable(String), hooks: T.nilable(::Stripe::PaymentIntentService::UpdateParams::Hooks), mandate_data: T.nilable(::Stripe::PaymentIntentService::UpdateParams::MandateData), metadata: T.nilable(T.nilable(T.any(String, T::Hash[String, String]))), payment_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::UpdateParams::PaymentDetails))), payment_method: T.nilable(String), payment_method_configuration: T.nilable(String), payment_method_data: T.nilable(::Stripe::PaymentIntentService::UpdateParams::PaymentMethodData), payment_method_options: T.nilable(::Stripe::PaymentIntentService::UpdateParams::PaymentMethodOptions), payment_method_types: T.nilable(T::Array[String]), receipt_email: T.nilable(T.nilable(String)), setup_future_usage: T.nilable(T.nilable(T.any(String, String))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::UpdateParams::Shipping))), statement_descriptor: T.nilable(String), statement_descriptor_suffix: T.nilable(String), transfer_data: T.nilable(::Stripe::PaymentIntentService::UpdateParams::TransferData), transfer_group: T.nilable(String)).void + params(amount: T.nilable(Integer), amount_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::UpdateParams::AmountDetails))), application_fee_amount: T.nilable(T.nilable(T.any(String, Integer))), capture_method: T.nilable(String), currency: T.nilable(String), customer: T.nilable(String), customer_account: T.nilable(String), description: T.nilable(String), expand: T.nilable(T::Array[String]), fx_quote: T.nilable(String), hooks: T.nilable(::Stripe::PaymentIntentService::UpdateParams::Hooks), mandate_data: T.nilable(::Stripe::PaymentIntentService::UpdateParams::MandateData), metadata: T.nilable(T.nilable(T.any(String, T::Hash[String, String]))), payment_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::UpdateParams::PaymentDetails))), payment_method: T.nilable(String), payment_method_configuration: T.nilable(String), payment_method_data: T.nilable(::Stripe::PaymentIntentService::UpdateParams::PaymentMethodData), payment_method_options: T.nilable(::Stripe::PaymentIntentService::UpdateParams::PaymentMethodOptions), payment_method_types: T.nilable(T::Array[String]), receipt_email: T.nilable(T.nilable(String)), setup_future_usage: T.nilable(T.nilable(T.any(String, String))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::UpdateParams::Shipping))), statement_descriptor: T.nilable(String), statement_descriptor_suffix: T.nilable(String), transfer_data: T.nilable(::Stripe::PaymentIntentService::UpdateParams::TransferData), transfer_group: T.nilable(String)).void } def initialize( amount: nil, + amount_details: nil, application_fee_amount: nil, capture_method: nil, currency: nil, @@ -151538,6 +152564,172 @@ module Stripe def initialize(cancellation_reason: nil, expand: nil); end end class CaptureParams < Stripe::RequestParams + class AmountDetails < Stripe::RequestParams + class LineItem < Stripe::RequestParams + class PaymentMethodOptions < Stripe::RequestParams + class Card < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class CardPresent < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class Klarna < Stripe::RequestParams + # URL to an image for the product. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :image_url + # URL to the product page. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :product_url + # Reference for the subscription this line item is for. + sig { returns(T.nilable(String)) } + attr_accessor :subscription_reference + sig { + params(image_url: T.nilable(String), product_url: T.nilable(String), subscription_reference: T.nilable(String)).void + } + def initialize(image_url: nil, product_url: nil, subscription_reference: nil); end + end + class Paypal < Stripe::RequestParams + # Type of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :category + # Description of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :description + # The Stripe account ID of the connected account that sells the item. + sig { returns(T.nilable(String)) } + attr_accessor :sold_by + sig { + params(category: T.nilable(String), description: T.nilable(String), sold_by: T.nilable(String)).void + } + def initialize(category: nil, description: nil, sold_by: nil); end + end + # This sub-hash contains line item details that are specific to `card` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::Card)) + } + attr_accessor :card + # This sub-hash contains line item details that are specific to `card_present` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent)) + } + attr_accessor :card_present + # This sub-hash contains line item details that are specific to `klarna` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna)) + } + attr_accessor :klarna + # This sub-hash contains line item details that are specific to `paypal` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)) + } + attr_accessor :paypal + sig { + params(card: T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::Card), card_present: T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent), klarna: T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna), paypal: T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)).void + } + def initialize(card: nil, card_present: nil, klarna: nil, paypal: nil); end + end + class Tax < Stripe::RequestParams + # The total tax on an item. Non-negative integer. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. Positive integer. + sig { returns(T.nilable(Integer)) } + attr_accessor :discount_amount + # Payment method-specific information for line items. + sig { + returns(T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions)) + } + attr_accessor :payment_method_options + # Unique identifier of the product. At most 12 characters long. + sig { returns(T.nilable(String)) } + attr_accessor :product_code + # Name of the product. At most 100 characters long. + sig { returns(String) } + attr_accessor :product_name + # Number of items of the product. Positive integer. + sig { returns(Integer) } + attr_accessor :quantity + # Contains information about the tax on the item. + sig { + returns(T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem::Tax)) + } + attr_accessor :tax + # Cost of the product. Non-negative integer. + sig { returns(Integer) } + attr_accessor :unit_cost + # A unit of measure for the line item, such as gallons, feet, meters, etc. + sig { returns(T.nilable(String)) } + attr_accessor :unit_of_measure + sig { + params(discount_amount: T.nilable(Integer), payment_method_options: T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions), product_code: T.nilable(String), product_name: String, quantity: Integer, tax: T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem::Tax), unit_cost: Integer, unit_of_measure: T.nilable(String)).void + } + def initialize( + discount_amount: nil, + payment_method_options: nil, + product_code: nil, + product_name: nil, + quantity: nil, + tax: nil, + unit_cost: nil, + unit_of_measure: nil + ); end + end + class Shipping < Stripe::RequestParams + # Portion of the amount that is for shipping. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :amount + # The postal code that represents the shipping source. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :from_postal_code + # The postal code that represents the shipping destination. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :to_postal_code + sig { + params(amount: T.nilable(T.nilable(T.any(String, Integer))), from_postal_code: T.nilable(T.nilable(String)), to_postal_code: T.nilable(T.nilable(String))).void + } + def initialize(amount: nil, from_postal_code: nil, to_postal_code: nil); end + end + class Tax < Stripe::RequestParams + # Total portion of the amount that is for tax. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :discount_amount + # A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 100 line items. + sig { + returns(T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem])))) + } + attr_accessor :line_items + # Contains information about the shipping portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::CaptureParams::AmountDetails::Shipping)))) + } + attr_accessor :shipping + # Contains information about the tax portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::CaptureParams::AmountDetails::Tax)))) + } + attr_accessor :tax + sig { + params(discount_amount: T.nilable(T.nilable(T.any(String, Integer))), line_items: T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem]))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::CaptureParams::AmountDetails::Shipping))), tax: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::CaptureParams::AmountDetails::Tax)))).void + } + def initialize(discount_amount: nil, line_items: nil, shipping: nil, tax: nil); end + end class Hooks < Stripe::RequestParams class Inputs < Stripe::RequestParams class Tax < Stripe::RequestParams @@ -152329,6 +153521,9 @@ module Stripe sig { params(amount: T.nilable(Integer)).void } def initialize(amount: nil); end end + # Provides industry-specific information about the amount. + sig { returns(T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails)) } + attr_accessor :amount_details # The amount to capture from the PaymentIntent, which must be less than or equal to the original amount. Defaults to the full `amount_capturable` if it's not provided. sig { returns(T.nilable(Integer)) } attr_accessor :amount_to_capture @@ -152365,9 +153560,10 @@ module Stripe sig { returns(T.nilable(::Stripe::PaymentIntentService::CaptureParams::TransferData)) } attr_accessor :transfer_data sig { - params(amount_to_capture: T.nilable(Integer), application_fee_amount: T.nilable(Integer), expand: T.nilable(T::Array[String]), final_capture: T.nilable(T::Boolean), hooks: T.nilable(::Stripe::PaymentIntentService::CaptureParams::Hooks), metadata: T.nilable(T.nilable(T.any(String, T::Hash[String, String]))), payment_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::CaptureParams::PaymentDetails))), statement_descriptor: T.nilable(String), statement_descriptor_suffix: T.nilable(String), transfer_data: T.nilable(::Stripe::PaymentIntentService::CaptureParams::TransferData)).void + params(amount_details: T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails), amount_to_capture: T.nilable(Integer), application_fee_amount: T.nilable(Integer), expand: T.nilable(T::Array[String]), final_capture: T.nilable(T::Boolean), hooks: T.nilable(::Stripe::PaymentIntentService::CaptureParams::Hooks), metadata: T.nilable(T.nilable(T.any(String, T::Hash[String, String]))), payment_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::CaptureParams::PaymentDetails))), statement_descriptor: T.nilable(String), statement_descriptor_suffix: T.nilable(String), transfer_data: T.nilable(::Stripe::PaymentIntentService::CaptureParams::TransferData)).void } def initialize( + amount_details: nil, amount_to_capture: nil, application_fee_amount: nil, expand: nil, @@ -152381,6 +153577,172 @@ module Stripe ); end end class ConfirmParams < Stripe::RequestParams + class AmountDetails < Stripe::RequestParams + class LineItem < Stripe::RequestParams + class PaymentMethodOptions < Stripe::RequestParams + class Card < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class CardPresent < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class Klarna < Stripe::RequestParams + # URL to an image for the product. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :image_url + # URL to the product page. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :product_url + # Reference for the subscription this line item is for. + sig { returns(T.nilable(String)) } + attr_accessor :subscription_reference + sig { + params(image_url: T.nilable(String), product_url: T.nilable(String), subscription_reference: T.nilable(String)).void + } + def initialize(image_url: nil, product_url: nil, subscription_reference: nil); end + end + class Paypal < Stripe::RequestParams + # Type of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :category + # Description of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :description + # The Stripe account ID of the connected account that sells the item. + sig { returns(T.nilable(String)) } + attr_accessor :sold_by + sig { + params(category: T.nilable(String), description: T.nilable(String), sold_by: T.nilable(String)).void + } + def initialize(category: nil, description: nil, sold_by: nil); end + end + # This sub-hash contains line item details that are specific to `card` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::Card)) + } + attr_accessor :card + # This sub-hash contains line item details that are specific to `card_present` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent)) + } + attr_accessor :card_present + # This sub-hash contains line item details that are specific to `klarna` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna)) + } + attr_accessor :klarna + # This sub-hash contains line item details that are specific to `paypal` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)) + } + attr_accessor :paypal + sig { + params(card: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::Card), card_present: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent), klarna: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna), paypal: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)).void + } + def initialize(card: nil, card_present: nil, klarna: nil, paypal: nil); end + end + class Tax < Stripe::RequestParams + # The total tax on an item. Non-negative integer. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. Positive integer. + sig { returns(T.nilable(Integer)) } + attr_accessor :discount_amount + # Payment method-specific information for line items. + sig { + returns(T.nilable(::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions)) + } + attr_accessor :payment_method_options + # Unique identifier of the product. At most 12 characters long. + sig { returns(T.nilable(String)) } + attr_accessor :product_code + # Name of the product. At most 100 characters long. + sig { returns(String) } + attr_accessor :product_name + # Number of items of the product. Positive integer. + sig { returns(Integer) } + attr_accessor :quantity + # Contains information about the tax on the item. + sig { + returns(T.nilable(::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem::Tax)) + } + attr_accessor :tax + # Cost of the product. Non-negative integer. + sig { returns(Integer) } + attr_accessor :unit_cost + # A unit of measure for the line item, such as gallons, feet, meters, etc. + sig { returns(T.nilable(String)) } + attr_accessor :unit_of_measure + sig { + params(discount_amount: T.nilable(Integer), payment_method_options: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions), product_code: T.nilable(String), product_name: String, quantity: Integer, tax: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem::Tax), unit_cost: Integer, unit_of_measure: T.nilable(String)).void + } + def initialize( + discount_amount: nil, + payment_method_options: nil, + product_code: nil, + product_name: nil, + quantity: nil, + tax: nil, + unit_cost: nil, + unit_of_measure: nil + ); end + end + class Shipping < Stripe::RequestParams + # Portion of the amount that is for shipping. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :amount + # The postal code that represents the shipping source. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :from_postal_code + # The postal code that represents the shipping destination. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :to_postal_code + sig { + params(amount: T.nilable(T.nilable(T.any(String, Integer))), from_postal_code: T.nilable(T.nilable(String)), to_postal_code: T.nilable(T.nilable(String))).void + } + def initialize(amount: nil, from_postal_code: nil, to_postal_code: nil); end + end + class Tax < Stripe::RequestParams + # Total portion of the amount that is for tax. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :discount_amount + # A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 100 line items. + sig { + returns(T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem])))) + } + attr_accessor :line_items + # Contains information about the shipping portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::Shipping)))) + } + attr_accessor :shipping + # Contains information about the tax portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::Tax)))) + } + attr_accessor :tax + sig { + params(discount_amount: T.nilable(T.nilable(T.any(String, Integer))), line_items: T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem]))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::Shipping))), tax: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::Tax)))).void + } + def initialize(discount_amount: nil, line_items: nil, shipping: nil, tax: nil); end + end class Hooks < Stripe::RequestParams class Inputs < Stripe::RequestParams class Tax < Stripe::RequestParams @@ -156044,6 +157406,11 @@ module Stripe } def initialize(address: nil, carrier: nil, name: nil, phone: nil, tracking_number: nil); end end + # Provides industry-specific information about the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::ConfirmParams::AmountDetails)))) + } + attr_accessor :amount_details # 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](https://stripe.com/docs/payments/connected-accounts). sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } attr_accessor :application_fee_amount @@ -156131,9 +157498,10 @@ module Stripe sig { returns(T.nilable(T::Boolean)) } attr_accessor :use_stripe_sdk sig { - params(application_fee_amount: T.nilable(T.nilable(T.any(String, Integer))), capture_method: T.nilable(String), confirmation_token: T.nilable(String), error_on_requires_action: T.nilable(T::Boolean), expand: T.nilable(T::Array[String]), fx_quote: T.nilable(String), hooks: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::Hooks), mandate: T.nilable(String), mandate_data: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::ConfirmParams::MandateData))), off_session: T.nilable(T.any(T::Boolean, String)), payment_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::ConfirmParams::PaymentDetails))), payment_method: T.nilable(String), payment_method_data: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::PaymentMethodData), payment_method_options: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::PaymentMethodOptions), payment_method_types: T.nilable(T::Array[String]), radar_options: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::RadarOptions), receipt_email: T.nilable(T.nilable(String)), return_url: T.nilable(String), setup_future_usage: T.nilable(T.nilable(T.any(String, String))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::ConfirmParams::Shipping))), use_stripe_sdk: T.nilable(T::Boolean)).void + params(amount_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::ConfirmParams::AmountDetails))), application_fee_amount: T.nilable(T.nilable(T.any(String, Integer))), capture_method: T.nilable(String), confirmation_token: T.nilable(String), error_on_requires_action: T.nilable(T::Boolean), expand: T.nilable(T::Array[String]), fx_quote: T.nilable(String), hooks: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::Hooks), mandate: T.nilable(String), mandate_data: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::ConfirmParams::MandateData))), off_session: T.nilable(T.any(T::Boolean, String)), payment_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::ConfirmParams::PaymentDetails))), payment_method: T.nilable(String), payment_method_data: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::PaymentMethodData), payment_method_options: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::PaymentMethodOptions), payment_method_types: T.nilable(T::Array[String]), radar_options: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::RadarOptions), receipt_email: T.nilable(T.nilable(String)), return_url: T.nilable(String), setup_future_usage: T.nilable(T.nilable(T.any(String, String))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::ConfirmParams::Shipping))), use_stripe_sdk: T.nilable(T::Boolean)).void } def initialize( + amount_details: nil, application_fee_amount: nil, capture_method: nil, confirmation_token: nil, diff --git a/rbi/stripe/resources/payment_intent.rbi b/rbi/stripe/resources/payment_intent.rbi index b6ee5d96..feb03b0c 100644 --- a/rbi/stripe/resources/payment_intent.rbi +++ b/rbi/stripe/resources/payment_intent.rbi @@ -2674,6 +2674,172 @@ module Stripe ); end end class CreateParams < Stripe::RequestParams + class AmountDetails < Stripe::RequestParams + class LineItem < Stripe::RequestParams + class PaymentMethodOptions < Stripe::RequestParams + class Card < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class CardPresent < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class Klarna < Stripe::RequestParams + # URL to an image for the product. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :image_url + # URL to the product page. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :product_url + # Reference for the subscription this line item is for. + sig { returns(T.nilable(String)) } + attr_accessor :subscription_reference + sig { + params(image_url: T.nilable(String), product_url: T.nilable(String), subscription_reference: T.nilable(String)).void + } + def initialize(image_url: nil, product_url: nil, subscription_reference: nil); end + end + class Paypal < Stripe::RequestParams + # Type of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :category + # Description of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :description + # The Stripe account ID of the connected account that sells the item. + sig { returns(T.nilable(String)) } + attr_accessor :sold_by + sig { + params(category: T.nilable(String), description: T.nilable(String), sold_by: T.nilable(String)).void + } + def initialize(category: nil, description: nil, sold_by: nil); end + end + # This sub-hash contains line item details that are specific to `card` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::Card)) + } + attr_accessor :card + # This sub-hash contains line item details that are specific to `card_present` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent)) + } + attr_accessor :card_present + # This sub-hash contains line item details that are specific to `klarna` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna)) + } + attr_accessor :klarna + # This sub-hash contains line item details that are specific to `paypal` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)) + } + attr_accessor :paypal + sig { + params(card: T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::Card), card_present: T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent), klarna: T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna), paypal: T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)).void + } + def initialize(card: nil, card_present: nil, klarna: nil, paypal: nil); end + end + class Tax < Stripe::RequestParams + # The total tax on an item. Non-negative integer. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. Positive integer. + sig { returns(T.nilable(Integer)) } + attr_accessor :discount_amount + # Payment method-specific information for line items. + sig { + returns(T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem::PaymentMethodOptions)) + } + attr_accessor :payment_method_options + # Unique identifier of the product. At most 12 characters long. + sig { returns(T.nilable(String)) } + attr_accessor :product_code + # Name of the product. At most 100 characters long. + sig { returns(String) } + attr_accessor :product_name + # Number of items of the product. Positive integer. + sig { returns(Integer) } + attr_accessor :quantity + # Contains information about the tax on the item. + sig { + returns(T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem::Tax)) + } + attr_accessor :tax + # Cost of the product. Non-negative integer. + sig { returns(Integer) } + attr_accessor :unit_cost + # A unit of measure for the line item, such as gallons, feet, meters, etc. + sig { returns(T.nilable(String)) } + attr_accessor :unit_of_measure + sig { + params(discount_amount: T.nilable(Integer), payment_method_options: T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem::PaymentMethodOptions), product_code: T.nilable(String), product_name: String, quantity: Integer, tax: T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem::Tax), unit_cost: Integer, unit_of_measure: T.nilable(String)).void + } + def initialize( + discount_amount: nil, + payment_method_options: nil, + product_code: nil, + product_name: nil, + quantity: nil, + tax: nil, + unit_cost: nil, + unit_of_measure: nil + ); end + end + class Shipping < Stripe::RequestParams + # Portion of the amount that is for shipping. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :amount + # The postal code that represents the shipping source. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :from_postal_code + # The postal code that represents the shipping destination. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :to_postal_code + sig { + params(amount: T.nilable(T.nilable(T.any(String, Integer))), from_postal_code: T.nilable(T.nilable(String)), to_postal_code: T.nilable(T.nilable(String))).void + } + def initialize(amount: nil, from_postal_code: nil, to_postal_code: nil); end + end + class Tax < Stripe::RequestParams + # Total portion of the amount that is for tax. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :discount_amount + # A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 100 line items. + sig { + returns(T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem])))) + } + attr_accessor :line_items + # Contains information about the shipping portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::CreateParams::AmountDetails::Shipping)))) + } + attr_accessor :shipping + # Contains information about the tax portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::CreateParams::AmountDetails::Tax)))) + } + attr_accessor :tax + sig { + params(discount_amount: T.nilable(T.nilable(T.any(String, Integer))), line_items: T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntent::CreateParams::AmountDetails::LineItem]))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::CreateParams::AmountDetails::Shipping))), tax: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::CreateParams::AmountDetails::Tax)))).void + } + def initialize(discount_amount: nil, line_items: nil, shipping: nil, tax: nil); end + end class AutomaticPaymentMethods < Stripe::RequestParams # Controls whether this PaymentIntent will accept redirect-based payment methods. # @@ -6303,6 +6469,9 @@ module Stripe # Amount intended to be collected by this PaymentIntent. A positive integer representing how much to charge in the [smallest currency unit](https://stripe.com/docs/currencies#zero-decimal) (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](https://stripe.com/docs/currencies#minimum-and-maximum-charge-amounts). The amount value supports up to eight digits (e.g., a value of 99999999 for a USD charge of $999,999.99). sig { returns(Integer) } attr_accessor :amount + # Provides industry-specific information about the amount. + sig { returns(T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails)) } + attr_accessor :amount_details # 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](https://stripe.com/docs/payments/connected-accounts). sig { returns(T.nilable(Integer)) } attr_accessor :application_fee_amount @@ -6439,10 +6608,11 @@ module Stripe sig { returns(T.nilable(T::Boolean)) } attr_accessor :use_stripe_sdk sig { - params(amount: Integer, application_fee_amount: T.nilable(Integer), automatic_payment_methods: T.nilable(::Stripe::PaymentIntent::CreateParams::AutomaticPaymentMethods), capture_method: T.nilable(String), confirm: T.nilable(T::Boolean), confirmation_method: T.nilable(String), confirmation_token: T.nilable(String), currency: String, customer: T.nilable(String), customer_account: T.nilable(String), description: T.nilable(String), error_on_requires_action: T.nilable(T::Boolean), expand: T.nilable(T::Array[String]), fx_quote: T.nilable(String), hooks: T.nilable(::Stripe::PaymentIntent::CreateParams::Hooks), mandate: T.nilable(String), mandate_data: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::CreateParams::MandateData))), metadata: T.nilable(T::Hash[String, String]), off_session: T.nilable(T.any(T::Boolean, String)), on_behalf_of: T.nilable(String), payment_details: T.nilable(::Stripe::PaymentIntent::CreateParams::PaymentDetails), payment_method: T.nilable(String), payment_method_configuration: T.nilable(String), payment_method_data: T.nilable(::Stripe::PaymentIntent::CreateParams::PaymentMethodData), payment_method_options: T.nilable(::Stripe::PaymentIntent::CreateParams::PaymentMethodOptions), payment_method_types: T.nilable(T::Array[String]), radar_options: T.nilable(::Stripe::PaymentIntent::CreateParams::RadarOptions), receipt_email: T.nilable(String), return_url: T.nilable(String), secret_key_confirmation: T.nilable(String), setup_future_usage: T.nilable(String), shipping: T.nilable(::Stripe::PaymentIntent::CreateParams::Shipping), statement_descriptor: T.nilable(String), statement_descriptor_suffix: T.nilable(String), transfer_data: T.nilable(::Stripe::PaymentIntent::CreateParams::TransferData), transfer_group: T.nilable(String), use_stripe_sdk: T.nilable(T::Boolean)).void + params(amount: Integer, amount_details: T.nilable(::Stripe::PaymentIntent::CreateParams::AmountDetails), application_fee_amount: T.nilable(Integer), automatic_payment_methods: T.nilable(::Stripe::PaymentIntent::CreateParams::AutomaticPaymentMethods), capture_method: T.nilable(String), confirm: T.nilable(T::Boolean), confirmation_method: T.nilable(String), confirmation_token: T.nilable(String), currency: String, customer: T.nilable(String), customer_account: T.nilable(String), description: T.nilable(String), error_on_requires_action: T.nilable(T::Boolean), expand: T.nilable(T::Array[String]), fx_quote: T.nilable(String), hooks: T.nilable(::Stripe::PaymentIntent::CreateParams::Hooks), mandate: T.nilable(String), mandate_data: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::CreateParams::MandateData))), metadata: T.nilable(T::Hash[String, String]), off_session: T.nilable(T.any(T::Boolean, String)), on_behalf_of: T.nilable(String), payment_details: T.nilable(::Stripe::PaymentIntent::CreateParams::PaymentDetails), payment_method: T.nilable(String), payment_method_configuration: T.nilable(String), payment_method_data: T.nilable(::Stripe::PaymentIntent::CreateParams::PaymentMethodData), payment_method_options: T.nilable(::Stripe::PaymentIntent::CreateParams::PaymentMethodOptions), payment_method_types: T.nilable(T::Array[String]), radar_options: T.nilable(::Stripe::PaymentIntent::CreateParams::RadarOptions), receipt_email: T.nilable(String), return_url: T.nilable(String), secret_key_confirmation: T.nilable(String), setup_future_usage: T.nilable(String), shipping: T.nilable(::Stripe::PaymentIntent::CreateParams::Shipping), statement_descriptor: T.nilable(String), statement_descriptor_suffix: T.nilable(String), transfer_data: T.nilable(::Stripe::PaymentIntent::CreateParams::TransferData), transfer_group: T.nilable(String), use_stripe_sdk: T.nilable(T::Boolean)).void } def initialize( amount: nil, + amount_details: nil, application_fee_amount: nil, automatic_payment_methods: nil, capture_method: nil, @@ -6482,6 +6652,172 @@ module Stripe ); end end class UpdateParams < Stripe::RequestParams + class AmountDetails < Stripe::RequestParams + class LineItem < Stripe::RequestParams + class PaymentMethodOptions < Stripe::RequestParams + class Card < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class CardPresent < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class Klarna < Stripe::RequestParams + # URL to an image for the product. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :image_url + # URL to the product page. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :product_url + # Reference for the subscription this line item is for. + sig { returns(T.nilable(String)) } + attr_accessor :subscription_reference + sig { + params(image_url: T.nilable(String), product_url: T.nilable(String), subscription_reference: T.nilable(String)).void + } + def initialize(image_url: nil, product_url: nil, subscription_reference: nil); end + end + class Paypal < Stripe::RequestParams + # Type of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :category + # Description of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :description + # The Stripe account ID of the connected account that sells the item. + sig { returns(T.nilable(String)) } + attr_accessor :sold_by + sig { + params(category: T.nilable(String), description: T.nilable(String), sold_by: T.nilable(String)).void + } + def initialize(category: nil, description: nil, sold_by: nil); end + end + # This sub-hash contains line item details that are specific to `card` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::Card)) + } + attr_accessor :card + # This sub-hash contains line item details that are specific to `card_present` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent)) + } + attr_accessor :card_present + # This sub-hash contains line item details that are specific to `klarna` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna)) + } + attr_accessor :klarna + # This sub-hash contains line item details that are specific to `paypal` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)) + } + attr_accessor :paypal + sig { + params(card: T.nilable(::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::Card), card_present: T.nilable(::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent), klarna: T.nilable(::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna), paypal: T.nilable(::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)).void + } + def initialize(card: nil, card_present: nil, klarna: nil, paypal: nil); end + end + class Tax < Stripe::RequestParams + # The total tax on an item. Non-negative integer. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. Positive integer. + sig { returns(T.nilable(Integer)) } + attr_accessor :discount_amount + # Payment method-specific information for line items. + sig { + returns(T.nilable(::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions)) + } + attr_accessor :payment_method_options + # Unique identifier of the product. At most 12 characters long. + sig { returns(T.nilable(String)) } + attr_accessor :product_code + # Name of the product. At most 100 characters long. + sig { returns(String) } + attr_accessor :product_name + # Number of items of the product. Positive integer. + sig { returns(Integer) } + attr_accessor :quantity + # Contains information about the tax on the item. + sig { + returns(T.nilable(::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem::Tax)) + } + attr_accessor :tax + # Cost of the product. Non-negative integer. + sig { returns(Integer) } + attr_accessor :unit_cost + # A unit of measure for the line item, such as gallons, feet, meters, etc. + sig { returns(T.nilable(String)) } + attr_accessor :unit_of_measure + sig { + params(discount_amount: T.nilable(Integer), payment_method_options: T.nilable(::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions), product_code: T.nilable(String), product_name: String, quantity: Integer, tax: T.nilable(::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem::Tax), unit_cost: Integer, unit_of_measure: T.nilable(String)).void + } + def initialize( + discount_amount: nil, + payment_method_options: nil, + product_code: nil, + product_name: nil, + quantity: nil, + tax: nil, + unit_cost: nil, + unit_of_measure: nil + ); end + end + class Shipping < Stripe::RequestParams + # Portion of the amount that is for shipping. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :amount + # The postal code that represents the shipping source. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :from_postal_code + # The postal code that represents the shipping destination. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :to_postal_code + sig { + params(amount: T.nilable(T.nilable(T.any(String, Integer))), from_postal_code: T.nilable(T.nilable(String)), to_postal_code: T.nilable(T.nilable(String))).void + } + def initialize(amount: nil, from_postal_code: nil, to_postal_code: nil); end + end + class Tax < Stripe::RequestParams + # Total portion of the amount that is for tax. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :discount_amount + # A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 100 line items. + sig { + returns(T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem])))) + } + attr_accessor :line_items + # Contains information about the shipping portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::UpdateParams::AmountDetails::Shipping)))) + } + attr_accessor :shipping + # Contains information about the tax portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::UpdateParams::AmountDetails::Tax)))) + } + attr_accessor :tax + sig { + params(discount_amount: T.nilable(T.nilable(T.any(String, Integer))), line_items: T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntent::UpdateParams::AmountDetails::LineItem]))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::UpdateParams::AmountDetails::Shipping))), tax: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::UpdateParams::AmountDetails::Tax)))).void + } + def initialize(discount_amount: nil, line_items: nil, shipping: nil, tax: nil); end + end class Hooks < Stripe::RequestParams class Inputs < Stripe::RequestParams class Tax < Stripe::RequestParams @@ -10071,6 +10407,11 @@ module Stripe # Amount intended to be collected by this PaymentIntent. A positive integer representing how much to charge in the [smallest currency unit](https://stripe.com/docs/currencies#zero-decimal) (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](https://stripe.com/docs/currencies#minimum-and-maximum-charge-amounts). The amount value supports up to eight digits (e.g., a value of 99999999 for a USD charge of $999,999.99). sig { returns(T.nilable(Integer)) } attr_accessor :amount + # Provides industry-specific information about the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::UpdateParams::AmountDetails)))) + } + attr_accessor :amount_details # 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](https://stripe.com/docs/payments/connected-accounts). sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } attr_accessor :application_fee_amount @@ -10168,10 +10509,11 @@ module Stripe sig { returns(T.nilable(String)) } attr_accessor :transfer_group sig { - params(amount: T.nilable(Integer), application_fee_amount: T.nilable(T.nilable(T.any(String, Integer))), capture_method: T.nilable(String), currency: T.nilable(String), customer: T.nilable(String), customer_account: T.nilable(String), description: T.nilable(String), expand: T.nilable(T::Array[String]), fx_quote: T.nilable(String), hooks: T.nilable(::Stripe::PaymentIntent::UpdateParams::Hooks), mandate_data: T.nilable(::Stripe::PaymentIntent::UpdateParams::MandateData), metadata: T.nilable(T.nilable(T.any(String, T::Hash[String, String]))), payment_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::UpdateParams::PaymentDetails))), payment_method: T.nilable(String), payment_method_configuration: T.nilable(String), payment_method_data: T.nilable(::Stripe::PaymentIntent::UpdateParams::PaymentMethodData), payment_method_options: T.nilable(::Stripe::PaymentIntent::UpdateParams::PaymentMethodOptions), payment_method_types: T.nilable(T::Array[String]), receipt_email: T.nilable(T.nilable(String)), setup_future_usage: T.nilable(T.nilable(T.any(String, String))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::UpdateParams::Shipping))), statement_descriptor: T.nilable(String), statement_descriptor_suffix: T.nilable(String), transfer_data: T.nilable(::Stripe::PaymentIntent::UpdateParams::TransferData), transfer_group: T.nilable(String)).void + params(amount: T.nilable(Integer), amount_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::UpdateParams::AmountDetails))), application_fee_amount: T.nilable(T.nilable(T.any(String, Integer))), capture_method: T.nilable(String), currency: T.nilable(String), customer: T.nilable(String), customer_account: T.nilable(String), description: T.nilable(String), expand: T.nilable(T::Array[String]), fx_quote: T.nilable(String), hooks: T.nilable(::Stripe::PaymentIntent::UpdateParams::Hooks), mandate_data: T.nilable(::Stripe::PaymentIntent::UpdateParams::MandateData), metadata: T.nilable(T.nilable(T.any(String, T::Hash[String, String]))), payment_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::UpdateParams::PaymentDetails))), payment_method: T.nilable(String), payment_method_configuration: T.nilable(String), payment_method_data: T.nilable(::Stripe::PaymentIntent::UpdateParams::PaymentMethodData), payment_method_options: T.nilable(::Stripe::PaymentIntent::UpdateParams::PaymentMethodOptions), payment_method_types: T.nilable(T::Array[String]), receipt_email: T.nilable(T.nilable(String)), setup_future_usage: T.nilable(T.nilable(T.any(String, String))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::UpdateParams::Shipping))), statement_descriptor: T.nilable(String), statement_descriptor_suffix: T.nilable(String), transfer_data: T.nilable(::Stripe::PaymentIntent::UpdateParams::TransferData), transfer_group: T.nilable(String)).void } def initialize( amount: nil, + amount_details: nil, application_fee_amount: nil, capture_method: nil, currency: nil, @@ -10248,6 +10590,172 @@ module Stripe def initialize(cancellation_reason: nil, expand: nil); end end class CaptureParams < Stripe::RequestParams + class AmountDetails < Stripe::RequestParams + class LineItem < Stripe::RequestParams + class PaymentMethodOptions < Stripe::RequestParams + class Card < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class CardPresent < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class Klarna < Stripe::RequestParams + # URL to an image for the product. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :image_url + # URL to the product page. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :product_url + # Reference for the subscription this line item is for. + sig { returns(T.nilable(String)) } + attr_accessor :subscription_reference + sig { + params(image_url: T.nilable(String), product_url: T.nilable(String), subscription_reference: T.nilable(String)).void + } + def initialize(image_url: nil, product_url: nil, subscription_reference: nil); end + end + class Paypal < Stripe::RequestParams + # Type of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :category + # Description of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :description + # The Stripe account ID of the connected account that sells the item. + sig { returns(T.nilable(String)) } + attr_accessor :sold_by + sig { + params(category: T.nilable(String), description: T.nilable(String), sold_by: T.nilable(String)).void + } + def initialize(category: nil, description: nil, sold_by: nil); end + end + # This sub-hash contains line item details that are specific to `card` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::Card)) + } + attr_accessor :card + # This sub-hash contains line item details that are specific to `card_present` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent)) + } + attr_accessor :card_present + # This sub-hash contains line item details that are specific to `klarna` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna)) + } + attr_accessor :klarna + # This sub-hash contains line item details that are specific to `paypal` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)) + } + attr_accessor :paypal + sig { + params(card: T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::Card), card_present: T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent), klarna: T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna), paypal: T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)).void + } + def initialize(card: nil, card_present: nil, klarna: nil, paypal: nil); end + end + class Tax < Stripe::RequestParams + # The total tax on an item. Non-negative integer. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. Positive integer. + sig { returns(T.nilable(Integer)) } + attr_accessor :discount_amount + # Payment method-specific information for line items. + sig { + returns(T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions)) + } + attr_accessor :payment_method_options + # Unique identifier of the product. At most 12 characters long. + sig { returns(T.nilable(String)) } + attr_accessor :product_code + # Name of the product. At most 100 characters long. + sig { returns(String) } + attr_accessor :product_name + # Number of items of the product. Positive integer. + sig { returns(Integer) } + attr_accessor :quantity + # Contains information about the tax on the item. + sig { + returns(T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem::Tax)) + } + attr_accessor :tax + # Cost of the product. Non-negative integer. + sig { returns(Integer) } + attr_accessor :unit_cost + # A unit of measure for the line item, such as gallons, feet, meters, etc. + sig { returns(T.nilable(String)) } + attr_accessor :unit_of_measure + sig { + params(discount_amount: T.nilable(Integer), payment_method_options: T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions), product_code: T.nilable(String), product_name: String, quantity: Integer, tax: T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem::Tax), unit_cost: Integer, unit_of_measure: T.nilable(String)).void + } + def initialize( + discount_amount: nil, + payment_method_options: nil, + product_code: nil, + product_name: nil, + quantity: nil, + tax: nil, + unit_cost: nil, + unit_of_measure: nil + ); end + end + class Shipping < Stripe::RequestParams + # Portion of the amount that is for shipping. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :amount + # The postal code that represents the shipping source. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :from_postal_code + # The postal code that represents the shipping destination. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :to_postal_code + sig { + params(amount: T.nilable(T.nilable(T.any(String, Integer))), from_postal_code: T.nilable(T.nilable(String)), to_postal_code: T.nilable(T.nilable(String))).void + } + def initialize(amount: nil, from_postal_code: nil, to_postal_code: nil); end + end + class Tax < Stripe::RequestParams + # Total portion of the amount that is for tax. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :discount_amount + # A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 100 line items. + sig { + returns(T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem])))) + } + attr_accessor :line_items + # Contains information about the shipping portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::CaptureParams::AmountDetails::Shipping)))) + } + attr_accessor :shipping + # Contains information about the tax portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::CaptureParams::AmountDetails::Tax)))) + } + attr_accessor :tax + sig { + params(discount_amount: T.nilable(T.nilable(T.any(String, Integer))), line_items: T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntent::CaptureParams::AmountDetails::LineItem]))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::CaptureParams::AmountDetails::Shipping))), tax: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::CaptureParams::AmountDetails::Tax)))).void + } + def initialize(discount_amount: nil, line_items: nil, shipping: nil, tax: nil); end + end class Hooks < Stripe::RequestParams class Inputs < Stripe::RequestParams class Tax < Stripe::RequestParams @@ -11033,6 +11541,9 @@ module Stripe sig { params(amount: T.nilable(Integer)).void } def initialize(amount: nil); end end + # Provides industry-specific information about the amount. + sig { returns(T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails)) } + attr_accessor :amount_details # The amount to capture from the PaymentIntent, which must be less than or equal to the original amount. Defaults to the full `amount_capturable` if it's not provided. sig { returns(T.nilable(Integer)) } attr_accessor :amount_to_capture @@ -11069,9 +11580,10 @@ module Stripe sig { returns(T.nilable(::Stripe::PaymentIntent::CaptureParams::TransferData)) } attr_accessor :transfer_data sig { - params(amount_to_capture: T.nilable(Integer), application_fee_amount: T.nilable(Integer), expand: T.nilable(T::Array[String]), final_capture: T.nilable(T::Boolean), hooks: T.nilable(::Stripe::PaymentIntent::CaptureParams::Hooks), metadata: T.nilable(T.nilable(T.any(String, T::Hash[String, String]))), payment_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::CaptureParams::PaymentDetails))), statement_descriptor: T.nilable(String), statement_descriptor_suffix: T.nilable(String), transfer_data: T.nilable(::Stripe::PaymentIntent::CaptureParams::TransferData)).void + params(amount_details: T.nilable(::Stripe::PaymentIntent::CaptureParams::AmountDetails), amount_to_capture: T.nilable(Integer), application_fee_amount: T.nilable(Integer), expand: T.nilable(T::Array[String]), final_capture: T.nilable(T::Boolean), hooks: T.nilable(::Stripe::PaymentIntent::CaptureParams::Hooks), metadata: T.nilable(T.nilable(T.any(String, T::Hash[String, String]))), payment_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::CaptureParams::PaymentDetails))), statement_descriptor: T.nilable(String), statement_descriptor_suffix: T.nilable(String), transfer_data: T.nilable(::Stripe::PaymentIntent::CaptureParams::TransferData)).void } def initialize( + amount_details: nil, amount_to_capture: nil, application_fee_amount: nil, expand: nil, @@ -11085,6 +11597,172 @@ module Stripe ); end end class ConfirmParams < Stripe::RequestParams + class AmountDetails < Stripe::RequestParams + class LineItem < Stripe::RequestParams + class PaymentMethodOptions < Stripe::RequestParams + class Card < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class CardPresent < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class Klarna < Stripe::RequestParams + # URL to an image for the product. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :image_url + # URL to the product page. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :product_url + # Reference for the subscription this line item is for. + sig { returns(T.nilable(String)) } + attr_accessor :subscription_reference + sig { + params(image_url: T.nilable(String), product_url: T.nilable(String), subscription_reference: T.nilable(String)).void + } + def initialize(image_url: nil, product_url: nil, subscription_reference: nil); end + end + class Paypal < Stripe::RequestParams + # Type of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :category + # Description of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :description + # The Stripe account ID of the connected account that sells the item. + sig { returns(T.nilable(String)) } + attr_accessor :sold_by + sig { + params(category: T.nilable(String), description: T.nilable(String), sold_by: T.nilable(String)).void + } + def initialize(category: nil, description: nil, sold_by: nil); end + end + # This sub-hash contains line item details that are specific to `card` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::Card)) + } + attr_accessor :card + # This sub-hash contains line item details that are specific to `card_present` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent)) + } + attr_accessor :card_present + # This sub-hash contains line item details that are specific to `klarna` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna)) + } + attr_accessor :klarna + # This sub-hash contains line item details that are specific to `paypal` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)) + } + attr_accessor :paypal + sig { + params(card: T.nilable(::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::Card), card_present: T.nilable(::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent), klarna: T.nilable(::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna), paypal: T.nilable(::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)).void + } + def initialize(card: nil, card_present: nil, klarna: nil, paypal: nil); end + end + class Tax < Stripe::RequestParams + # The total tax on an item. Non-negative integer. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. Positive integer. + sig { returns(T.nilable(Integer)) } + attr_accessor :discount_amount + # Payment method-specific information for line items. + sig { + returns(T.nilable(::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions)) + } + attr_accessor :payment_method_options + # Unique identifier of the product. At most 12 characters long. + sig { returns(T.nilable(String)) } + attr_accessor :product_code + # Name of the product. At most 100 characters long. + sig { returns(String) } + attr_accessor :product_name + # Number of items of the product. Positive integer. + sig { returns(Integer) } + attr_accessor :quantity + # Contains information about the tax on the item. + sig { + returns(T.nilable(::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem::Tax)) + } + attr_accessor :tax + # Cost of the product. Non-negative integer. + sig { returns(Integer) } + attr_accessor :unit_cost + # A unit of measure for the line item, such as gallons, feet, meters, etc. + sig { returns(T.nilable(String)) } + attr_accessor :unit_of_measure + sig { + params(discount_amount: T.nilable(Integer), payment_method_options: T.nilable(::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions), product_code: T.nilable(String), product_name: String, quantity: Integer, tax: T.nilable(::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem::Tax), unit_cost: Integer, unit_of_measure: T.nilable(String)).void + } + def initialize( + discount_amount: nil, + payment_method_options: nil, + product_code: nil, + product_name: nil, + quantity: nil, + tax: nil, + unit_cost: nil, + unit_of_measure: nil + ); end + end + class Shipping < Stripe::RequestParams + # Portion of the amount that is for shipping. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :amount + # The postal code that represents the shipping source. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :from_postal_code + # The postal code that represents the shipping destination. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :to_postal_code + sig { + params(amount: T.nilable(T.nilable(T.any(String, Integer))), from_postal_code: T.nilable(T.nilable(String)), to_postal_code: T.nilable(T.nilable(String))).void + } + def initialize(amount: nil, from_postal_code: nil, to_postal_code: nil); end + end + class Tax < Stripe::RequestParams + # Total portion of the amount that is for tax. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :discount_amount + # A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 100 line items. + sig { + returns(T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem])))) + } + attr_accessor :line_items + # Contains information about the shipping portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::ConfirmParams::AmountDetails::Shipping)))) + } + attr_accessor :shipping + # Contains information about the tax portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::ConfirmParams::AmountDetails::Tax)))) + } + attr_accessor :tax + sig { + params(discount_amount: T.nilable(T.nilable(T.any(String, Integer))), line_items: T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntent::ConfirmParams::AmountDetails::LineItem]))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::ConfirmParams::AmountDetails::Shipping))), tax: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::ConfirmParams::AmountDetails::Tax)))).void + } + def initialize(discount_amount: nil, line_items: nil, shipping: nil, tax: nil); end + end class Hooks < Stripe::RequestParams class Inputs < Stripe::RequestParams class Tax < Stripe::RequestParams @@ -14706,6 +15384,11 @@ module Stripe } def initialize(address: nil, carrier: nil, name: nil, phone: nil, tracking_number: nil); end end + # Provides industry-specific information about the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::ConfirmParams::AmountDetails)))) + } + attr_accessor :amount_details # 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](https://stripe.com/docs/payments/connected-accounts). sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } attr_accessor :application_fee_amount @@ -14791,9 +15474,10 @@ module Stripe sig { returns(T.nilable(T::Boolean)) } attr_accessor :use_stripe_sdk sig { - params(application_fee_amount: T.nilable(T.nilable(T.any(String, Integer))), capture_method: T.nilable(String), confirmation_token: T.nilable(String), error_on_requires_action: T.nilable(T::Boolean), expand: T.nilable(T::Array[String]), fx_quote: T.nilable(String), hooks: T.nilable(::Stripe::PaymentIntent::ConfirmParams::Hooks), mandate: T.nilable(String), mandate_data: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::ConfirmParams::MandateData))), off_session: T.nilable(T.any(T::Boolean, String)), payment_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::ConfirmParams::PaymentDetails))), payment_method: T.nilable(String), payment_method_data: T.nilable(::Stripe::PaymentIntent::ConfirmParams::PaymentMethodData), payment_method_options: T.nilable(::Stripe::PaymentIntent::ConfirmParams::PaymentMethodOptions), payment_method_types: T.nilable(T::Array[String]), radar_options: T.nilable(::Stripe::PaymentIntent::ConfirmParams::RadarOptions), receipt_email: T.nilable(T.nilable(String)), return_url: T.nilable(String), setup_future_usage: T.nilable(T.nilable(T.any(String, String))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::ConfirmParams::Shipping))), use_stripe_sdk: T.nilable(T::Boolean)).void + params(amount_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::ConfirmParams::AmountDetails))), application_fee_amount: T.nilable(T.nilable(T.any(String, Integer))), capture_method: T.nilable(String), confirmation_token: T.nilable(String), error_on_requires_action: T.nilable(T::Boolean), expand: T.nilable(T::Array[String]), fx_quote: T.nilable(String), hooks: T.nilable(::Stripe::PaymentIntent::ConfirmParams::Hooks), mandate: T.nilable(String), mandate_data: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::ConfirmParams::MandateData))), off_session: T.nilable(T.any(T::Boolean, String)), payment_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::ConfirmParams::PaymentDetails))), payment_method: T.nilable(String), payment_method_data: T.nilable(::Stripe::PaymentIntent::ConfirmParams::PaymentMethodData), payment_method_options: T.nilable(::Stripe::PaymentIntent::ConfirmParams::PaymentMethodOptions), payment_method_types: T.nilable(T::Array[String]), radar_options: T.nilable(::Stripe::PaymentIntent::ConfirmParams::RadarOptions), receipt_email: T.nilable(T.nilable(String)), return_url: T.nilable(String), setup_future_usage: T.nilable(T.nilable(T.any(String, String))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntent::ConfirmParams::Shipping))), use_stripe_sdk: T.nilable(T::Boolean)).void } def initialize( + amount_details: nil, application_fee_amount: nil, capture_method: nil, confirmation_token: nil, diff --git a/rbi/stripe/services/payment_intent_service.rbi b/rbi/stripe/services/payment_intent_service.rbi index 8a96eb7c..cd908362 100644 --- a/rbi/stripe/services/payment_intent_service.rbi +++ b/rbi/stripe/services/payment_intent_service.rbi @@ -61,6 +61,172 @@ module Stripe ); end end class CreateParams < Stripe::RequestParams + class AmountDetails < Stripe::RequestParams + class LineItem < Stripe::RequestParams + class PaymentMethodOptions < Stripe::RequestParams + class Card < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class CardPresent < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class Klarna < Stripe::RequestParams + # URL to an image for the product. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :image_url + # URL to the product page. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :product_url + # Reference for the subscription this line item is for. + sig { returns(T.nilable(String)) } + attr_accessor :subscription_reference + sig { + params(image_url: T.nilable(String), product_url: T.nilable(String), subscription_reference: T.nilable(String)).void + } + def initialize(image_url: nil, product_url: nil, subscription_reference: nil); end + end + class Paypal < Stripe::RequestParams + # Type of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :category + # Description of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :description + # The Stripe account ID of the connected account that sells the item. + sig { returns(T.nilable(String)) } + attr_accessor :sold_by + sig { + params(category: T.nilable(String), description: T.nilable(String), sold_by: T.nilable(String)).void + } + def initialize(category: nil, description: nil, sold_by: nil); end + end + # This sub-hash contains line item details that are specific to `card` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::Card)) + } + attr_accessor :card + # This sub-hash contains line item details that are specific to `card_present` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent)) + } + attr_accessor :card_present + # This sub-hash contains line item details that are specific to `klarna` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna)) + } + attr_accessor :klarna + # This sub-hash contains line item details that are specific to `paypal` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)) + } + attr_accessor :paypal + sig { + params(card: T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::Card), card_present: T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent), klarna: T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna), paypal: T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)).void + } + def initialize(card: nil, card_present: nil, klarna: nil, paypal: nil); end + end + class Tax < Stripe::RequestParams + # The total tax on an item. Non-negative integer. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. Positive integer. + sig { returns(T.nilable(Integer)) } + attr_accessor :discount_amount + # Payment method-specific information for line items. + sig { + returns(T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem::PaymentMethodOptions)) + } + attr_accessor :payment_method_options + # Unique identifier of the product. At most 12 characters long. + sig { returns(T.nilable(String)) } + attr_accessor :product_code + # Name of the product. At most 100 characters long. + sig { returns(String) } + attr_accessor :product_name + # Number of items of the product. Positive integer. + sig { returns(Integer) } + attr_accessor :quantity + # Contains information about the tax on the item. + sig { + returns(T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem::Tax)) + } + attr_accessor :tax + # Cost of the product. Non-negative integer. + sig { returns(Integer) } + attr_accessor :unit_cost + # A unit of measure for the line item, such as gallons, feet, meters, etc. + sig { returns(T.nilable(String)) } + attr_accessor :unit_of_measure + sig { + params(discount_amount: T.nilable(Integer), payment_method_options: T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem::PaymentMethodOptions), product_code: T.nilable(String), product_name: String, quantity: Integer, tax: T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem::Tax), unit_cost: Integer, unit_of_measure: T.nilable(String)).void + } + def initialize( + discount_amount: nil, + payment_method_options: nil, + product_code: nil, + product_name: nil, + quantity: nil, + tax: nil, + unit_cost: nil, + unit_of_measure: nil + ); end + end + class Shipping < Stripe::RequestParams + # Portion of the amount that is for shipping. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :amount + # The postal code that represents the shipping source. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :from_postal_code + # The postal code that represents the shipping destination. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :to_postal_code + sig { + params(amount: T.nilable(T.nilable(T.any(String, Integer))), from_postal_code: T.nilable(T.nilable(String)), to_postal_code: T.nilable(T.nilable(String))).void + } + def initialize(amount: nil, from_postal_code: nil, to_postal_code: nil); end + end + class Tax < Stripe::RequestParams + # Total portion of the amount that is for tax. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :discount_amount + # A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 100 line items. + sig { + returns(T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem])))) + } + attr_accessor :line_items + # Contains information about the shipping portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::CreateParams::AmountDetails::Shipping)))) + } + attr_accessor :shipping + # Contains information about the tax portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::CreateParams::AmountDetails::Tax)))) + } + attr_accessor :tax + sig { + params(discount_amount: T.nilable(T.nilable(T.any(String, Integer))), line_items: T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntentService::CreateParams::AmountDetails::LineItem]))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::CreateParams::AmountDetails::Shipping))), tax: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::CreateParams::AmountDetails::Tax)))).void + } + def initialize(discount_amount: nil, line_items: nil, shipping: nil, tax: nil); end + end class AutomaticPaymentMethods < Stripe::RequestParams # Controls whether this PaymentIntent will accept redirect-based payment methods. # @@ -3758,6 +3924,9 @@ module Stripe # Amount intended to be collected by this PaymentIntent. A positive integer representing how much to charge in the [smallest currency unit](https://stripe.com/docs/currencies#zero-decimal) (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](https://stripe.com/docs/currencies#minimum-and-maximum-charge-amounts). The amount value supports up to eight digits (e.g., a value of 99999999 for a USD charge of $999,999.99). sig { returns(Integer) } attr_accessor :amount + # Provides industry-specific information about the amount. + sig { returns(T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails)) } + attr_accessor :amount_details # 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](https://stripe.com/docs/payments/connected-accounts). sig { returns(T.nilable(Integer)) } attr_accessor :application_fee_amount @@ -3896,10 +4065,11 @@ module Stripe sig { returns(T.nilable(T::Boolean)) } attr_accessor :use_stripe_sdk sig { - params(amount: Integer, application_fee_amount: T.nilable(Integer), automatic_payment_methods: T.nilable(::Stripe::PaymentIntentService::CreateParams::AutomaticPaymentMethods), capture_method: T.nilable(String), confirm: T.nilable(T::Boolean), confirmation_method: T.nilable(String), confirmation_token: T.nilable(String), currency: String, customer: T.nilable(String), customer_account: T.nilable(String), description: T.nilable(String), error_on_requires_action: T.nilable(T::Boolean), expand: T.nilable(T::Array[String]), fx_quote: T.nilable(String), hooks: T.nilable(::Stripe::PaymentIntentService::CreateParams::Hooks), mandate: T.nilable(String), mandate_data: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::CreateParams::MandateData))), metadata: T.nilable(T::Hash[String, String]), off_session: T.nilable(T.any(T::Boolean, String)), on_behalf_of: T.nilable(String), payment_details: T.nilable(::Stripe::PaymentIntentService::CreateParams::PaymentDetails), payment_method: T.nilable(String), payment_method_configuration: T.nilable(String), payment_method_data: T.nilable(::Stripe::PaymentIntentService::CreateParams::PaymentMethodData), payment_method_options: T.nilable(::Stripe::PaymentIntentService::CreateParams::PaymentMethodOptions), payment_method_types: T.nilable(T::Array[String]), radar_options: T.nilable(::Stripe::PaymentIntentService::CreateParams::RadarOptions), receipt_email: T.nilable(String), return_url: T.nilable(String), secret_key_confirmation: T.nilable(String), setup_future_usage: T.nilable(String), shipping: T.nilable(::Stripe::PaymentIntentService::CreateParams::Shipping), statement_descriptor: T.nilable(String), statement_descriptor_suffix: T.nilable(String), transfer_data: T.nilable(::Stripe::PaymentIntentService::CreateParams::TransferData), transfer_group: T.nilable(String), use_stripe_sdk: T.nilable(T::Boolean)).void + params(amount: Integer, amount_details: T.nilable(::Stripe::PaymentIntentService::CreateParams::AmountDetails), application_fee_amount: T.nilable(Integer), automatic_payment_methods: T.nilable(::Stripe::PaymentIntentService::CreateParams::AutomaticPaymentMethods), capture_method: T.nilable(String), confirm: T.nilable(T::Boolean), confirmation_method: T.nilable(String), confirmation_token: T.nilable(String), currency: String, customer: T.nilable(String), customer_account: T.nilable(String), description: T.nilable(String), error_on_requires_action: T.nilable(T::Boolean), expand: T.nilable(T::Array[String]), fx_quote: T.nilable(String), hooks: T.nilable(::Stripe::PaymentIntentService::CreateParams::Hooks), mandate: T.nilable(String), mandate_data: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::CreateParams::MandateData))), metadata: T.nilable(T::Hash[String, String]), off_session: T.nilable(T.any(T::Boolean, String)), on_behalf_of: T.nilable(String), payment_details: T.nilable(::Stripe::PaymentIntentService::CreateParams::PaymentDetails), payment_method: T.nilable(String), payment_method_configuration: T.nilable(String), payment_method_data: T.nilable(::Stripe::PaymentIntentService::CreateParams::PaymentMethodData), payment_method_options: T.nilable(::Stripe::PaymentIntentService::CreateParams::PaymentMethodOptions), payment_method_types: T.nilable(T::Array[String]), radar_options: T.nilable(::Stripe::PaymentIntentService::CreateParams::RadarOptions), receipt_email: T.nilable(String), return_url: T.nilable(String), secret_key_confirmation: T.nilable(String), setup_future_usage: T.nilable(String), shipping: T.nilable(::Stripe::PaymentIntentService::CreateParams::Shipping), statement_descriptor: T.nilable(String), statement_descriptor_suffix: T.nilable(String), transfer_data: T.nilable(::Stripe::PaymentIntentService::CreateParams::TransferData), transfer_group: T.nilable(String), use_stripe_sdk: T.nilable(T::Boolean)).void } def initialize( amount: nil, + amount_details: nil, application_fee_amount: nil, automatic_payment_methods: nil, capture_method: nil, @@ -3949,6 +4119,172 @@ module Stripe def initialize(client_secret: nil, expand: nil); end end class UpdateParams < Stripe::RequestParams + class AmountDetails < Stripe::RequestParams + class LineItem < Stripe::RequestParams + class PaymentMethodOptions < Stripe::RequestParams + class Card < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class CardPresent < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class Klarna < Stripe::RequestParams + # URL to an image for the product. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :image_url + # URL to the product page. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :product_url + # Reference for the subscription this line item is for. + sig { returns(T.nilable(String)) } + attr_accessor :subscription_reference + sig { + params(image_url: T.nilable(String), product_url: T.nilable(String), subscription_reference: T.nilable(String)).void + } + def initialize(image_url: nil, product_url: nil, subscription_reference: nil); end + end + class Paypal < Stripe::RequestParams + # Type of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :category + # Description of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :description + # The Stripe account ID of the connected account that sells the item. + sig { returns(T.nilable(String)) } + attr_accessor :sold_by + sig { + params(category: T.nilable(String), description: T.nilable(String), sold_by: T.nilable(String)).void + } + def initialize(category: nil, description: nil, sold_by: nil); end + end + # This sub-hash contains line item details that are specific to `card` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::Card)) + } + attr_accessor :card + # This sub-hash contains line item details that are specific to `card_present` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent)) + } + attr_accessor :card_present + # This sub-hash contains line item details that are specific to `klarna` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna)) + } + attr_accessor :klarna + # This sub-hash contains line item details that are specific to `paypal` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)) + } + attr_accessor :paypal + sig { + params(card: T.nilable(::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::Card), card_present: T.nilable(::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent), klarna: T.nilable(::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna), paypal: T.nilable(::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)).void + } + def initialize(card: nil, card_present: nil, klarna: nil, paypal: nil); end + end + class Tax < Stripe::RequestParams + # The total tax on an item. Non-negative integer. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. Positive integer. + sig { returns(T.nilable(Integer)) } + attr_accessor :discount_amount + # Payment method-specific information for line items. + sig { + returns(T.nilable(::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions)) + } + attr_accessor :payment_method_options + # Unique identifier of the product. At most 12 characters long. + sig { returns(T.nilable(String)) } + attr_accessor :product_code + # Name of the product. At most 100 characters long. + sig { returns(String) } + attr_accessor :product_name + # Number of items of the product. Positive integer. + sig { returns(Integer) } + attr_accessor :quantity + # Contains information about the tax on the item. + sig { + returns(T.nilable(::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem::Tax)) + } + attr_accessor :tax + # Cost of the product. Non-negative integer. + sig { returns(Integer) } + attr_accessor :unit_cost + # A unit of measure for the line item, such as gallons, feet, meters, etc. + sig { returns(T.nilable(String)) } + attr_accessor :unit_of_measure + sig { + params(discount_amount: T.nilable(Integer), payment_method_options: T.nilable(::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem::PaymentMethodOptions), product_code: T.nilable(String), product_name: String, quantity: Integer, tax: T.nilable(::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem::Tax), unit_cost: Integer, unit_of_measure: T.nilable(String)).void + } + def initialize( + discount_amount: nil, + payment_method_options: nil, + product_code: nil, + product_name: nil, + quantity: nil, + tax: nil, + unit_cost: nil, + unit_of_measure: nil + ); end + end + class Shipping < Stripe::RequestParams + # Portion of the amount that is for shipping. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :amount + # The postal code that represents the shipping source. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :from_postal_code + # The postal code that represents the shipping destination. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :to_postal_code + sig { + params(amount: T.nilable(T.nilable(T.any(String, Integer))), from_postal_code: T.nilable(T.nilable(String)), to_postal_code: T.nilable(T.nilable(String))).void + } + def initialize(amount: nil, from_postal_code: nil, to_postal_code: nil); end + end + class Tax < Stripe::RequestParams + # Total portion of the amount that is for tax. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :discount_amount + # A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 100 line items. + sig { + returns(T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem])))) + } + attr_accessor :line_items + # Contains information about the shipping portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::UpdateParams::AmountDetails::Shipping)))) + } + attr_accessor :shipping + # Contains information about the tax portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::UpdateParams::AmountDetails::Tax)))) + } + attr_accessor :tax + sig { + params(discount_amount: T.nilable(T.nilable(T.any(String, Integer))), line_items: T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntentService::UpdateParams::AmountDetails::LineItem]))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::UpdateParams::AmountDetails::Shipping))), tax: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::UpdateParams::AmountDetails::Tax)))).void + } + def initialize(discount_amount: nil, line_items: nil, shipping: nil, tax: nil); end + end class Hooks < Stripe::RequestParams class Inputs < Stripe::RequestParams class Tax < Stripe::RequestParams @@ -7606,6 +7942,11 @@ module Stripe # Amount intended to be collected by this PaymentIntent. A positive integer representing how much to charge in the [smallest currency unit](https://stripe.com/docs/currencies#zero-decimal) (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](https://stripe.com/docs/currencies#minimum-and-maximum-charge-amounts). The amount value supports up to eight digits (e.g., a value of 99999999 for a USD charge of $999,999.99). sig { returns(T.nilable(Integer)) } attr_accessor :amount + # Provides industry-specific information about the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::UpdateParams::AmountDetails)))) + } + attr_accessor :amount_details # 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](https://stripe.com/docs/payments/connected-accounts). sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } attr_accessor :application_fee_amount @@ -7703,10 +8044,11 @@ module Stripe sig { returns(T.nilable(String)) } attr_accessor :transfer_group sig { - params(amount: T.nilable(Integer), application_fee_amount: T.nilable(T.nilable(T.any(String, Integer))), capture_method: T.nilable(String), currency: T.nilable(String), customer: T.nilable(String), customer_account: T.nilable(String), description: T.nilable(String), expand: T.nilable(T::Array[String]), fx_quote: T.nilable(String), hooks: T.nilable(::Stripe::PaymentIntentService::UpdateParams::Hooks), mandate_data: T.nilable(::Stripe::PaymentIntentService::UpdateParams::MandateData), metadata: T.nilable(T.nilable(T.any(String, T::Hash[String, String]))), payment_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::UpdateParams::PaymentDetails))), payment_method: T.nilable(String), payment_method_configuration: T.nilable(String), payment_method_data: T.nilable(::Stripe::PaymentIntentService::UpdateParams::PaymentMethodData), payment_method_options: T.nilable(::Stripe::PaymentIntentService::UpdateParams::PaymentMethodOptions), payment_method_types: T.nilable(T::Array[String]), receipt_email: T.nilable(T.nilable(String)), setup_future_usage: T.nilable(T.nilable(T.any(String, String))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::UpdateParams::Shipping))), statement_descriptor: T.nilable(String), statement_descriptor_suffix: T.nilable(String), transfer_data: T.nilable(::Stripe::PaymentIntentService::UpdateParams::TransferData), transfer_group: T.nilable(String)).void + params(amount: T.nilable(Integer), amount_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::UpdateParams::AmountDetails))), application_fee_amount: T.nilable(T.nilable(T.any(String, Integer))), capture_method: T.nilable(String), currency: T.nilable(String), customer: T.nilable(String), customer_account: T.nilable(String), description: T.nilable(String), expand: T.nilable(T::Array[String]), fx_quote: T.nilable(String), hooks: T.nilable(::Stripe::PaymentIntentService::UpdateParams::Hooks), mandate_data: T.nilable(::Stripe::PaymentIntentService::UpdateParams::MandateData), metadata: T.nilable(T.nilable(T.any(String, T::Hash[String, String]))), payment_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::UpdateParams::PaymentDetails))), payment_method: T.nilable(String), payment_method_configuration: T.nilable(String), payment_method_data: T.nilable(::Stripe::PaymentIntentService::UpdateParams::PaymentMethodData), payment_method_options: T.nilable(::Stripe::PaymentIntentService::UpdateParams::PaymentMethodOptions), payment_method_types: T.nilable(T::Array[String]), receipt_email: T.nilable(T.nilable(String)), setup_future_usage: T.nilable(T.nilable(T.any(String, String))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::UpdateParams::Shipping))), statement_descriptor: T.nilable(String), statement_descriptor_suffix: T.nilable(String), transfer_data: T.nilable(::Stripe::PaymentIntentService::UpdateParams::TransferData), transfer_group: T.nilable(String)).void } def initialize( amount: nil, + amount_details: nil, application_fee_amount: nil, capture_method: nil, currency: nil, @@ -7783,6 +8125,172 @@ module Stripe def initialize(cancellation_reason: nil, expand: nil); end end class CaptureParams < Stripe::RequestParams + class AmountDetails < Stripe::RequestParams + class LineItem < Stripe::RequestParams + class PaymentMethodOptions < Stripe::RequestParams + class Card < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class CardPresent < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class Klarna < Stripe::RequestParams + # URL to an image for the product. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :image_url + # URL to the product page. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :product_url + # Reference for the subscription this line item is for. + sig { returns(T.nilable(String)) } + attr_accessor :subscription_reference + sig { + params(image_url: T.nilable(String), product_url: T.nilable(String), subscription_reference: T.nilable(String)).void + } + def initialize(image_url: nil, product_url: nil, subscription_reference: nil); end + end + class Paypal < Stripe::RequestParams + # Type of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :category + # Description of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :description + # The Stripe account ID of the connected account that sells the item. + sig { returns(T.nilable(String)) } + attr_accessor :sold_by + sig { + params(category: T.nilable(String), description: T.nilable(String), sold_by: T.nilable(String)).void + } + def initialize(category: nil, description: nil, sold_by: nil); end + end + # This sub-hash contains line item details that are specific to `card` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::Card)) + } + attr_accessor :card + # This sub-hash contains line item details that are specific to `card_present` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent)) + } + attr_accessor :card_present + # This sub-hash contains line item details that are specific to `klarna` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna)) + } + attr_accessor :klarna + # This sub-hash contains line item details that are specific to `paypal` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)) + } + attr_accessor :paypal + sig { + params(card: T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::Card), card_present: T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent), klarna: T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna), paypal: T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)).void + } + def initialize(card: nil, card_present: nil, klarna: nil, paypal: nil); end + end + class Tax < Stripe::RequestParams + # The total tax on an item. Non-negative integer. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. Positive integer. + sig { returns(T.nilable(Integer)) } + attr_accessor :discount_amount + # Payment method-specific information for line items. + sig { + returns(T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions)) + } + attr_accessor :payment_method_options + # Unique identifier of the product. At most 12 characters long. + sig { returns(T.nilable(String)) } + attr_accessor :product_code + # Name of the product. At most 100 characters long. + sig { returns(String) } + attr_accessor :product_name + # Number of items of the product. Positive integer. + sig { returns(Integer) } + attr_accessor :quantity + # Contains information about the tax on the item. + sig { + returns(T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem::Tax)) + } + attr_accessor :tax + # Cost of the product. Non-negative integer. + sig { returns(Integer) } + attr_accessor :unit_cost + # A unit of measure for the line item, such as gallons, feet, meters, etc. + sig { returns(T.nilable(String)) } + attr_accessor :unit_of_measure + sig { + params(discount_amount: T.nilable(Integer), payment_method_options: T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem::PaymentMethodOptions), product_code: T.nilable(String), product_name: String, quantity: Integer, tax: T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem::Tax), unit_cost: Integer, unit_of_measure: T.nilable(String)).void + } + def initialize( + discount_amount: nil, + payment_method_options: nil, + product_code: nil, + product_name: nil, + quantity: nil, + tax: nil, + unit_cost: nil, + unit_of_measure: nil + ); end + end + class Shipping < Stripe::RequestParams + # Portion of the amount that is for shipping. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :amount + # The postal code that represents the shipping source. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :from_postal_code + # The postal code that represents the shipping destination. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :to_postal_code + sig { + params(amount: T.nilable(T.nilable(T.any(String, Integer))), from_postal_code: T.nilable(T.nilable(String)), to_postal_code: T.nilable(T.nilable(String))).void + } + def initialize(amount: nil, from_postal_code: nil, to_postal_code: nil); end + end + class Tax < Stripe::RequestParams + # Total portion of the amount that is for tax. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :discount_amount + # A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 100 line items. + sig { + returns(T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem])))) + } + attr_accessor :line_items + # Contains information about the shipping portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::CaptureParams::AmountDetails::Shipping)))) + } + attr_accessor :shipping + # Contains information about the tax portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::CaptureParams::AmountDetails::Tax)))) + } + attr_accessor :tax + sig { + params(discount_amount: T.nilable(T.nilable(T.any(String, Integer))), line_items: T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntentService::CaptureParams::AmountDetails::LineItem]))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::CaptureParams::AmountDetails::Shipping))), tax: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::CaptureParams::AmountDetails::Tax)))).void + } + def initialize(discount_amount: nil, line_items: nil, shipping: nil, tax: nil); end + end class Hooks < Stripe::RequestParams class Inputs < Stripe::RequestParams class Tax < Stripe::RequestParams @@ -8574,6 +9082,9 @@ module Stripe sig { params(amount: T.nilable(Integer)).void } def initialize(amount: nil); end end + # Provides industry-specific information about the amount. + sig { returns(T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails)) } + attr_accessor :amount_details # The amount to capture from the PaymentIntent, which must be less than or equal to the original amount. Defaults to the full `amount_capturable` if it's not provided. sig { returns(T.nilable(Integer)) } attr_accessor :amount_to_capture @@ -8610,9 +9121,10 @@ module Stripe sig { returns(T.nilable(::Stripe::PaymentIntentService::CaptureParams::TransferData)) } attr_accessor :transfer_data sig { - params(amount_to_capture: T.nilable(Integer), application_fee_amount: T.nilable(Integer), expand: T.nilable(T::Array[String]), final_capture: T.nilable(T::Boolean), hooks: T.nilable(::Stripe::PaymentIntentService::CaptureParams::Hooks), metadata: T.nilable(T.nilable(T.any(String, T::Hash[String, String]))), payment_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::CaptureParams::PaymentDetails))), statement_descriptor: T.nilable(String), statement_descriptor_suffix: T.nilable(String), transfer_data: T.nilable(::Stripe::PaymentIntentService::CaptureParams::TransferData)).void + params(amount_details: T.nilable(::Stripe::PaymentIntentService::CaptureParams::AmountDetails), amount_to_capture: T.nilable(Integer), application_fee_amount: T.nilable(Integer), expand: T.nilable(T::Array[String]), final_capture: T.nilable(T::Boolean), hooks: T.nilable(::Stripe::PaymentIntentService::CaptureParams::Hooks), metadata: T.nilable(T.nilable(T.any(String, T::Hash[String, String]))), payment_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::CaptureParams::PaymentDetails))), statement_descriptor: T.nilable(String), statement_descriptor_suffix: T.nilable(String), transfer_data: T.nilable(::Stripe::PaymentIntentService::CaptureParams::TransferData)).void } def initialize( + amount_details: nil, amount_to_capture: nil, application_fee_amount: nil, expand: nil, @@ -8626,6 +9138,172 @@ module Stripe ); end end class ConfirmParams < Stripe::RequestParams + class AmountDetails < Stripe::RequestParams + class LineItem < Stripe::RequestParams + class PaymentMethodOptions < Stripe::RequestParams + class Card < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class CardPresent < Stripe::RequestParams + # Identifier that categorizes the items being purchased using a standardized commodity scheme such as (but not limited to) UNSPSC, NAICS, NAPCS, etc. + sig { returns(T.nilable(String)) } + attr_accessor :commodity_code + sig { params(commodity_code: T.nilable(String)).void } + def initialize(commodity_code: nil); end + end + class Klarna < Stripe::RequestParams + # URL to an image for the product. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :image_url + # URL to the product page. Max length, 4096 characters. + sig { returns(T.nilable(String)) } + attr_accessor :product_url + # Reference for the subscription this line item is for. + sig { returns(T.nilable(String)) } + attr_accessor :subscription_reference + sig { + params(image_url: T.nilable(String), product_url: T.nilable(String), subscription_reference: T.nilable(String)).void + } + def initialize(image_url: nil, product_url: nil, subscription_reference: nil); end + end + class Paypal < Stripe::RequestParams + # Type of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :category + # Description of the line item. + sig { returns(T.nilable(String)) } + attr_accessor :description + # The Stripe account ID of the connected account that sells the item. + sig { returns(T.nilable(String)) } + attr_accessor :sold_by + sig { + params(category: T.nilable(String), description: T.nilable(String), sold_by: T.nilable(String)).void + } + def initialize(category: nil, description: nil, sold_by: nil); end + end + # This sub-hash contains line item details that are specific to `card` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::Card)) + } + attr_accessor :card + # This sub-hash contains line item details that are specific to `card_present` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent)) + } + attr_accessor :card_present + # This sub-hash contains line item details that are specific to `klarna` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna)) + } + attr_accessor :klarna + # This sub-hash contains line item details that are specific to `paypal` payment method." + sig { + returns(T.nilable(::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)) + } + attr_accessor :paypal + sig { + params(card: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::Card), card_present: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::CardPresent), klarna: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::Klarna), paypal: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions::Paypal)).void + } + def initialize(card: nil, card_present: nil, klarna: nil, paypal: nil); end + end + class Tax < Stripe::RequestParams + # The total tax on an item. Non-negative integer. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. Positive integer. + sig { returns(T.nilable(Integer)) } + attr_accessor :discount_amount + # Payment method-specific information for line items. + sig { + returns(T.nilable(::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions)) + } + attr_accessor :payment_method_options + # Unique identifier of the product. At most 12 characters long. + sig { returns(T.nilable(String)) } + attr_accessor :product_code + # Name of the product. At most 100 characters long. + sig { returns(String) } + attr_accessor :product_name + # Number of items of the product. Positive integer. + sig { returns(Integer) } + attr_accessor :quantity + # Contains information about the tax on the item. + sig { + returns(T.nilable(::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem::Tax)) + } + attr_accessor :tax + # Cost of the product. Non-negative integer. + sig { returns(Integer) } + attr_accessor :unit_cost + # A unit of measure for the line item, such as gallons, feet, meters, etc. + sig { returns(T.nilable(String)) } + attr_accessor :unit_of_measure + sig { + params(discount_amount: T.nilable(Integer), payment_method_options: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem::PaymentMethodOptions), product_code: T.nilable(String), product_name: String, quantity: Integer, tax: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem::Tax), unit_cost: Integer, unit_of_measure: T.nilable(String)).void + } + def initialize( + discount_amount: nil, + payment_method_options: nil, + product_code: nil, + product_name: nil, + quantity: nil, + tax: nil, + unit_cost: nil, + unit_of_measure: nil + ); end + end + class Shipping < Stripe::RequestParams + # Portion of the amount that is for shipping. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :amount + # The postal code that represents the shipping source. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :from_postal_code + # The postal code that represents the shipping destination. + sig { returns(T.nilable(T.nilable(String))) } + attr_accessor :to_postal_code + sig { + params(amount: T.nilable(T.nilable(T.any(String, Integer))), from_postal_code: T.nilable(T.nilable(String)), to_postal_code: T.nilable(T.nilable(String))).void + } + def initialize(amount: nil, from_postal_code: nil, to_postal_code: nil); end + end + class Tax < Stripe::RequestParams + # Total portion of the amount that is for tax. + sig { returns(Integer) } + attr_accessor :total_tax_amount + sig { params(total_tax_amount: Integer).void } + def initialize(total_tax_amount: nil); end + end + # The amount an item was discounted for. + sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } + attr_accessor :discount_amount + # A list of line items, each containing information about a product in the PaymentIntent. There is a maximum of 100 line items. + sig { + returns(T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem])))) + } + attr_accessor :line_items + # Contains information about the shipping portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::Shipping)))) + } + attr_accessor :shipping + # Contains information about the tax portion of the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::Tax)))) + } + attr_accessor :tax + sig { + params(discount_amount: T.nilable(T.nilable(T.any(String, Integer))), line_items: T.nilable(T.nilable(T.any(String, T::Array[::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::LineItem]))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::Shipping))), tax: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::ConfirmParams::AmountDetails::Tax)))).void + } + def initialize(discount_amount: nil, line_items: nil, shipping: nil, tax: nil); end + end class Hooks < Stripe::RequestParams class Inputs < Stripe::RequestParams class Tax < Stripe::RequestParams @@ -12289,6 +12967,11 @@ module Stripe } def initialize(address: nil, carrier: nil, name: nil, phone: nil, tracking_number: nil); end end + # Provides industry-specific information about the amount. + sig { + returns(T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::ConfirmParams::AmountDetails)))) + } + attr_accessor :amount_details # 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](https://stripe.com/docs/payments/connected-accounts). sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) } attr_accessor :application_fee_amount @@ -12376,9 +13059,10 @@ module Stripe sig { returns(T.nilable(T::Boolean)) } attr_accessor :use_stripe_sdk sig { - params(application_fee_amount: T.nilable(T.nilable(T.any(String, Integer))), capture_method: T.nilable(String), confirmation_token: T.nilable(String), error_on_requires_action: T.nilable(T::Boolean), expand: T.nilable(T::Array[String]), fx_quote: T.nilable(String), hooks: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::Hooks), mandate: T.nilable(String), mandate_data: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::ConfirmParams::MandateData))), off_session: T.nilable(T.any(T::Boolean, String)), payment_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::ConfirmParams::PaymentDetails))), payment_method: T.nilable(String), payment_method_data: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::PaymentMethodData), payment_method_options: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::PaymentMethodOptions), payment_method_types: T.nilable(T::Array[String]), radar_options: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::RadarOptions), receipt_email: T.nilable(T.nilable(String)), return_url: T.nilable(String), setup_future_usage: T.nilable(T.nilable(T.any(String, String))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::ConfirmParams::Shipping))), use_stripe_sdk: T.nilable(T::Boolean)).void + params(amount_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::ConfirmParams::AmountDetails))), application_fee_amount: T.nilable(T.nilable(T.any(String, Integer))), capture_method: T.nilable(String), confirmation_token: T.nilable(String), error_on_requires_action: T.nilable(T::Boolean), expand: T.nilable(T::Array[String]), fx_quote: T.nilable(String), hooks: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::Hooks), mandate: T.nilable(String), mandate_data: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::ConfirmParams::MandateData))), off_session: T.nilable(T.any(T::Boolean, String)), payment_details: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::ConfirmParams::PaymentDetails))), payment_method: T.nilable(String), payment_method_data: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::PaymentMethodData), payment_method_options: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::PaymentMethodOptions), payment_method_types: T.nilable(T::Array[String]), radar_options: T.nilable(::Stripe::PaymentIntentService::ConfirmParams::RadarOptions), receipt_email: T.nilable(T.nilable(String)), return_url: T.nilable(String), setup_future_usage: T.nilable(T.nilable(T.any(String, String))), shipping: T.nilable(T.nilable(T.any(String, ::Stripe::PaymentIntentService::ConfirmParams::Shipping))), use_stripe_sdk: T.nilable(T::Boolean)).void } def initialize( + amount_details: nil, application_fee_amount: nil, capture_method: nil, confirmation_token: nil,