stripe 5.55.0 → 18.2.0.pre.beta.1

data/lib/stripe/services/payment_intent_service.rb

@@ -0,0 +1,253 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class PaymentIntentService < StripeService
+    attr_reader :amount_details_line_items
+
+    def initialize(requestor)
+      super
+      @amount_details_line_items = Stripe::PaymentIntentAmountDetailsLineItemService.new(@requestor)
+    end
+
+    # Manually reconcile the remaining amount for a customer_balance PaymentIntent.
+    def apply_customer_balance(intent, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_intents/%<intent>s/apply_customer_balance", { intent: CGI.escape(intent) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # You can cancel a PaymentIntent object when it's in one of these statuses: requires_payment_method, requires_capture, requires_confirmation, requires_action or, [in rare cases](https://docs.stripe.com/docs/payments/intents), processing.
+    #
+    # After it's canceled, no additional charges are made by the PaymentIntent and any operations on the PaymentIntent fail with an error. For PaymentIntents with a status of requires_capture, the remaining amount_capturable is automatically refunded.
+    #
+    # You can't cancel the PaymentIntent for a Checkout Session. [Expire the Checkout Session](https://docs.stripe.com/docs/api/checkout/sessions/expire) instead.
+    def cancel(intent, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_intents/%<intent>s/cancel", { intent: CGI.escape(intent) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Capture the funds of an existing uncaptured PaymentIntent when its status is requires_capture.
+    #
+    # Uncaptured PaymentIntents are cancelled a set number of days (7 by default) after their creation.
+    #
+    # Learn more about [separate authorization and capture](https://docs.stripe.com/docs/payments/capture-later).
+    def capture(intent, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_intents/%<intent>s/capture", { intent: CGI.escape(intent) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Confirm that your customer intends to pay with current or provided
+    # payment method. Upon confirmation, the PaymentIntent will attempt to initiate
+    # a payment.
+    #
+    # If the selected payment method requires additional authentication steps, the
+    # PaymentIntent will transition to the requires_action status and
+    # suggest additional actions via next_action. If payment fails,
+    # the PaymentIntent transitions to the requires_payment_method status or the
+    # canceled status if the confirmation limit is reached. If
+    # payment succeeds, the PaymentIntent will transition to the succeeded
+    # status (or requires_capture, if capture_method is set to manual).
+    #
+    # If the confirmation_method is automatic, payment may be attempted
+    # using our [client SDKs](https://docs.stripe.com/docs/stripe-js/reference#stripe-handle-card-payment)
+    # and the PaymentIntent's [client_secret](https://docs.stripe.com/api#payment_intent_object-client_secret).
+    # After next_actions are handled by the client, no additional
+    # confirmation is required to complete the payment.
+    #
+    # If the confirmation_method is manual, all payment attempts must be
+    # initiated using a secret key.
+    #
+    # If any actions are required for the payment, the PaymentIntent will
+    # return to the requires_confirmation state
+    # after those actions are completed. Your server needs to then
+    # explicitly re-confirm the PaymentIntent to initiate the next payment
+    # attempt.
+    #
+    # There is a variable upper limit on how many times a PaymentIntent can be confirmed.
+    # After this limit is reached, any further calls to this endpoint will
+    # transition the PaymentIntent to the canceled state.
+    def confirm(intent, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_intents/%<intent>s/confirm", { intent: CGI.escape(intent) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Creates a PaymentIntent object.
+    #
+    # After the PaymentIntent is created, attach a payment method and [confirm](https://docs.stripe.com/docs/api/payment_intents/confirm)
+    # to continue the payment. Learn more about <a href="/docs/payments/payment-intents">the available payment flows
+    # with the Payment Intents API.
+    #
+    # When you use confirm=true during creation, it's equivalent to creating
+    # and confirming the PaymentIntent in the same call. You can use any parameters
+    # available in the [confirm API](https://docs.stripe.com/docs/api/payment_intents/confirm) when you supply
+    # confirm=true.
+    def create(params = {}, opts = {})
+      request(
+        method: :post,
+        path: "/v1/payment_intents",
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Perform a decremental authorization on an eligible
+    # [PaymentIntent](https://docs.stripe.com/docs/api/payment_intents/object). To be eligible, the
+    # PaymentIntent's status must be requires_capture and
+    # [decremental_authorization.status](https://docs.stripe.com/docs/api/charges/object#charge_object-payment_method_details-card-decremental_authorization)
+    # must be available.
+    #
+    # Decremental authorizations decrease the authorized amount on your customer's card
+    # to the new, lower amount provided. A single PaymentIntent can call this endpoint multiple times to further decrease the authorized amount.
+    #
+    # After decrement, the PaymentIntent object
+    # returns with the updated
+    # [amount](https://docs.stripe.com/docs/api/payment_intents/object#payment_intent_object-amount).
+    # The PaymentIntent will now be capturable up to the new authorized amount.
+    #
+    # Each PaymentIntent can have a maximum of 10 decremental or incremental authorization attempts, including declines.
+    # After it's fully captured, a PaymentIntent can no longer be decremented.
+    def decrement_authorization(intent, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_intents/%<intent>s/decrement_authorization", { intent: CGI.escape(intent) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Perform an incremental authorization on an eligible
+    # [PaymentIntent](https://docs.stripe.com/docs/api/payment_intents/object). To be eligible, the
+    # PaymentIntent's status must be requires_capture and
+    # [incremental_authorization_supported](https://docs.stripe.com/docs/api/charges/object#charge_object-payment_method_details-card_present-incremental_authorization_supported)
+    # must be true.
+    #
+    # Incremental authorizations attempt to increase the authorized amount on
+    # your customer's card to the new, higher amount provided. Similar to the
+    # initial authorization, incremental authorizations can be declined. A
+    # single PaymentIntent can call this endpoint multiple times to further
+    # increase the authorized amount.
+    #
+    # If the incremental authorization succeeds, the PaymentIntent object
+    # returns with the updated
+    # [amount](https://docs.stripe.com/docs/api/payment_intents/object#payment_intent_object-amount).
+    # If the incremental authorization fails, a
+    # [card_declined](https://docs.stripe.com/docs/error-codes#card-declined) error returns, and no other
+    # fields on the PaymentIntent or Charge update. The PaymentIntent
+    # object remains capturable for the previously authorized amount.
+    #
+    # Each PaymentIntent can have a maximum of 10 incremental authorization attempts, including declines.
+    # After it's captured, a PaymentIntent can no longer be incremented.
+    #
+    # Learn more about [incremental authorizations](https://docs.stripe.com/docs/terminal/features/incremental-authorizations).
+    def increment_authorization(intent, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_intents/%<intent>s/increment_authorization", { intent: CGI.escape(intent) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Returns a list of PaymentIntents.
+    def list(params = {}, opts = {})
+      request(
+        method: :get,
+        path: "/v1/payment_intents",
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Retrieves the details of a PaymentIntent that has previously been created.
+    #
+    # You can retrieve a PaymentIntent client-side using a publishable key when the client_secret is in the query string.
+    #
+    # If you retrieve a PaymentIntent with a publishable key, it only returns a subset of properties. Refer to the [payment intent](https://docs.stripe.com/api#payment_intent_object) object reference for more details.
+    def retrieve(intent, params = {}, opts = {})
+      request(
+        method: :get,
+        path: format("/v1/payment_intents/%<intent>s", { intent: CGI.escape(intent) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Search for PaymentIntents you've previously created using Stripe's [Search Query Language](https://docs.stripe.com/docs/search#search-query-language).
+    # Don't use search in read-after-write flows where strict consistency is necessary. Under normal operating
+    # conditions, data is searchable in less than a minute. Occasionally, propagation of new or updated data can be up
+    # to an hour behind during outages. Search functionality is not available to merchants in India.
+    def search(params = {}, opts = {})
+      request(
+        method: :get,
+        path: "/v1/payment_intents/search",
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Trigger an external action on a PaymentIntent.
+    def trigger_action(intent, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/test/payment_intents/%<intent>s/trigger_action", { intent: CGI.escape(intent) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Updates properties on a PaymentIntent object without confirming.
+    #
+    # Depending on which properties you update, you might need to confirm the
+    # PaymentIntent again. For example, updating the payment_method
+    # always requires you to confirm the PaymentIntent again. If you prefer to
+    # update and confirm at the same time, we recommend updating properties through
+    # the [confirm API](https://docs.stripe.com/docs/api/payment_intents/confirm) instead.
+    def update(intent, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_intents/%<intent>s", { intent: CGI.escape(intent) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Verifies microdeposits on a PaymentIntent object.
+    def verify_microdeposits(intent, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_intents/%<intent>s/verify_microdeposits", { intent: CGI.escape(intent) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+  end
+end

data/lib/stripe/services/payment_link_line_item_service.rb

@@ -0,0 +1,17 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class PaymentLinkLineItemService < StripeService
+    # When retrieving a payment link, there is an includable line_items property containing the first handful of those items. There is also a URL where you can retrieve the full (paginated) list of line items.
+    def list(payment_link, params = {}, opts = {})
+      request(
+        method: :get,
+        path: format("/v1/payment_links/%<payment_link>s/line_items", { payment_link: CGI.escape(payment_link) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+  end
+end

data/lib/stripe/services/payment_link_service.rb

@@ -0,0 +1,57 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class PaymentLinkService < StripeService
+    attr_reader :line_items
+
+    def initialize(requestor)
+      super
+      @line_items = Stripe::PaymentLinkLineItemService.new(@requestor)
+    end
+
+    # Creates a payment link.
+    def create(params = {}, opts = {})
+      request(
+        method: :post,
+        path: "/v1/payment_links",
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Returns a list of your payment links.
+    def list(params = {}, opts = {})
+      request(
+        method: :get,
+        path: "/v1/payment_links",
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Retrieve a payment link.
+    def retrieve(payment_link, params = {}, opts = {})
+      request(
+        method: :get,
+        path: format("/v1/payment_links/%<payment_link>s", { payment_link: CGI.escape(payment_link) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Updates a payment link.
+    def update(payment_link, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_links/%<payment_link>s", { payment_link: CGI.escape(payment_link) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+  end
+end

data/lib/stripe/services/payment_method_configuration_service.rb

@@ -0,0 +1,50 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class PaymentMethodConfigurationService < StripeService
+    # Creates a payment method configuration
+    def create(params = {}, opts = {})
+      request(
+        method: :post,
+        path: "/v1/payment_method_configurations",
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # List payment method configurations
+    def list(params = {}, opts = {})
+      request(
+        method: :get,
+        path: "/v1/payment_method_configurations",
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Retrieve payment method configuration
+    def retrieve(configuration, params = {}, opts = {})
+      request(
+        method: :get,
+        path: format("/v1/payment_method_configurations/%<configuration>s", { configuration: CGI.escape(configuration) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Update payment method configuration
+    def update(configuration, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_method_configurations/%<configuration>s", { configuration: CGI.escape(configuration) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+  end
+end

data/lib/stripe/services/payment_method_domain_service.rb

@@ -0,0 +1,66 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class PaymentMethodDomainService < StripeService
+    # Creates a payment method domain.
+    def create(params = {}, opts = {})
+      request(
+        method: :post,
+        path: "/v1/payment_method_domains",
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Lists the details of existing payment method domains.
+    def list(params = {}, opts = {})
+      request(
+        method: :get,
+        path: "/v1/payment_method_domains",
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Retrieves the details of an existing payment method domain.
+    def retrieve(payment_method_domain, params = {}, opts = {})
+      request(
+        method: :get,
+        path: format("/v1/payment_method_domains/%<payment_method_domain>s", { payment_method_domain: CGI.escape(payment_method_domain) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Updates an existing payment method domain.
+    def update(payment_method_domain, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_method_domains/%<payment_method_domain>s", { payment_method_domain: CGI.escape(payment_method_domain) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Some payment methods might require additional steps to register a domain. If the requirements weren't satisfied when the domain was created, the payment method will be inactive on the domain.
+    # The payment method doesn't appear in Elements or Embedded Checkout for this domain until it is active.
+    #
+    # To activate a payment method on an existing payment method domain, complete the required registration steps specific to the payment method, and then validate the payment method domain with this endpoint.
+    #
+    # Related guides: [Payment method domains](https://docs.stripe.com/docs/payments/payment-methods/pmd-registration).
+    def validate(payment_method_domain, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_method_domains/%<payment_method_domain>s/validate", { payment_method_domain: CGI.escape(payment_method_domain) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+  end
+end

data/lib/stripe/services/payment_method_service.rb

@@ -0,0 +1,86 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class PaymentMethodService < StripeService
+    # Attaches a PaymentMethod object to a Customer.
+    #
+    # To attach a new PaymentMethod to a customer for future payments, we recommend you use a [SetupIntent](https://docs.stripe.com/docs/api/setup_intents)
+    # or a PaymentIntent with [setup_future_usage](https://docs.stripe.com/docs/api/payment_intents/create#create_payment_intent-setup_future_usage).
+    # These approaches will perform any necessary steps to set up the PaymentMethod for future payments. Using the /v1/payment_methods/:id/attach
+    # endpoint without first using a SetupIntent or PaymentIntent with setup_future_usage does not optimize the PaymentMethod for
+    # future use, which makes later declines and payment friction more likely.
+    # See [Optimizing cards for future payments](https://docs.stripe.com/docs/payments/payment-intents#future-usage) for more information about setting up
+    # future payments.
+    #
+    # To use this PaymentMethod as the default for invoice or subscription payments,
+    # set [invoice_settings.default_payment_method](https://docs.stripe.com/docs/api/customers/update#update_customer-invoice_settings-default_payment_method),
+    # on the Customer to the PaymentMethod's ID.
+    def attach(payment_method, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_methods/%<payment_method>s/attach", { payment_method: CGI.escape(payment_method) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Creates a PaymentMethod object. Read the [Stripe.js reference](https://docs.stripe.com/docs/stripe-js/reference#stripe-create-payment-method) to learn how to create PaymentMethods via Stripe.js.
+    #
+    # Instead of creating a PaymentMethod directly, we recommend using the [PaymentIntents API to accept a payment immediately or the <a href="/docs/payments/save-and-reuse">SetupIntent](https://docs.stripe.com/docs/payments/accept-a-payment) API to collect payment method details ahead of a future payment.
+    def create(params = {}, opts = {})
+      request(
+        method: :post,
+        path: "/v1/payment_methods",
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Detaches a PaymentMethod object from a Customer. After a PaymentMethod is detached, it can no longer be used for a payment or re-attached to a Customer.
+    def detach(payment_method, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_methods/%<payment_method>s/detach", { payment_method: CGI.escape(payment_method) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Returns a list of all PaymentMethods.
+    def list(params = {}, opts = {})
+      request(
+        method: :get,
+        path: "/v1/payment_methods",
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Retrieves a PaymentMethod object attached to the StripeAccount. To retrieve a payment method attached to a Customer, you should use [Retrieve a Customer's PaymentMethods](https://docs.stripe.com/docs/api/payment_methods/customer)
+    def retrieve(payment_method, params = {}, opts = {})
+      request(
+        method: :get,
+        path: format("/v1/payment_methods/%<payment_method>s", { payment_method: CGI.escape(payment_method) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Updates a PaymentMethod object. A PaymentMethod must be attached to a customer to be updated.
+    def update(payment_method, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_methods/%<payment_method>s", { payment_method: CGI.escape(payment_method) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+  end
+end

data/lib/stripe/services/payment_record_service.rb

@@ -0,0 +1,101 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class PaymentRecordService < StripeService
+    # Report a new Payment Record. You may report a Payment Record as it is
+    #  initialized and later report updates through the other report_* methods, or report Payment
+    #  Records in a terminal state directly, through this method.
+    def report_payment(params = {}, opts = {})
+      request(
+        method: :post,
+        path: "/v1/payment_records/report_payment",
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Report a new payment attempt on the specified Payment Record. A new payment
+    #  attempt can only be specified if all other payment attempts are canceled or failed.
+    def report_payment_attempt(id, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_records/%<id>s/report_payment_attempt", { id: CGI.escape(id) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Report that the most recent payment attempt on the specified Payment Record
+    #  was canceled.
+    def report_payment_attempt_canceled(id, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_records/%<id>s/report_payment_attempt_canceled", { id: CGI.escape(id) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Report that the most recent payment attempt on the specified Payment Record
+    #  failed or errored.
+    def report_payment_attempt_failed(id, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_records/%<id>s/report_payment_attempt_failed", { id: CGI.escape(id) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Report that the most recent payment attempt on the specified Payment Record
+    #  was guaranteed.
+    def report_payment_attempt_guaranteed(id, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_records/%<id>s/report_payment_attempt_guaranteed", { id: CGI.escape(id) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Report informational updates on the specified Payment Record.
+    def report_payment_attempt_informational(id, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_records/%<id>s/report_payment_attempt_informational", { id: CGI.escape(id) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Report that the most recent payment attempt on the specified Payment Record
+    #  was refunded.
+    def report_refund(id, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_records/%<id>s/report_refund", { id: CGI.escape(id) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Retrieves a Payment Record with the given ID
+    def retrieve(id, params = {}, opts = {})
+      request(
+        method: :get,
+        path: format("/v1/payment_records/%<id>s", { id: CGI.escape(id) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+  end
+end