stripe 12.7.0.pre.beta.1 → 13.0.0

data/lib/stripe/services/issuing/physical_bundle_service.rb

@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module Issuing
+    class PhysicalBundleService < StripeService
+      # Returns a list of physical bundle objects. The objects are sorted in descending order by creation date, with the most recently created object appearing first.
+      def list(params = {}, opts = {})
+        request(
+          method: :get,
+          path: "/v1/issuing/physical_bundles",
+          params: params,
+          opts: opts,
+          base_address: :api
+        )
+      end
+
+      # Retrieves a physical bundle object.
+      def retrieve(physical_bundle, params = {}, opts = {})
+        request(
+          method: :get,
+          path: format("/v1/issuing/physical_bundles/%<physical_bundle>s", { physical_bundle: CGI.escape(physical_bundle) }),
+          params: params,
+          opts: opts,
+          base_address: :api
+        )
+      end
+    end
+  end
+end

data/lib/stripe/services/issuing/token_service.rb

@@ -0,0 +1,41 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module Issuing
+    class TokenService < StripeService
+      # Lists all Issuing Token objects for a given card.
+      def list(params = {}, opts = {})
+        request(
+          method: :get,
+          path: "/v1/issuing/tokens",
+          params: params,
+          opts: opts,
+          base_address: :api
+        )
+      end
+
+      # Retrieves an Issuing Token object.
+      def retrieve(token, params = {}, opts = {})
+        request(
+          method: :get,
+          path: format("/v1/issuing/tokens/%<token>s", { token: CGI.escape(token) }),
+          params: params,
+          opts: opts,
+          base_address: :api
+        )
+      end
+
+      # Attempts to update the specified Issuing Token object to the status specified.
+      def update(token, params = {}, opts = {})
+        request(
+          method: :post,
+          path: format("/v1/issuing/tokens/%<token>s", { token: CGI.escape(token) }),
+          params: params,
+          opts: opts,
+          base_address: :api
+        )
+      end
+    end
+  end
+end

data/lib/stripe/services/issuing/transaction_service.rb

@@ -0,0 +1,41 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module Issuing
+    class TransactionService < StripeService
+      # Returns a list of Issuing Transaction objects. The objects are sorted in descending order by creation date, with the most recently created object appearing first.
+      def list(params = {}, opts = {})
+        request(
+          method: :get,
+          path: "/v1/issuing/transactions",
+          params: params,
+          opts: opts,
+          base_address: :api
+        )
+      end
+
+      # Retrieves an Issuing Transaction object.
+      def retrieve(transaction, params = {}, opts = {})
+        request(
+          method: :get,
+          path: format("/v1/issuing/transactions/%<transaction>s", { transaction: CGI.escape(transaction) }),
+          params: params,
+          opts: opts,
+          base_address: :api
+        )
+      end
+
+      # Updates the specified Issuing Transaction object by setting the values of the parameters passed. Any parameters not provided will be left unchanged.
+      def update(transaction, params = {}, opts = {})
+        request(
+          method: :post,
+          path: format("/v1/issuing/transactions/%<transaction>s", { transaction: CGI.escape(transaction) }),
+          params: params,
+          opts: opts,
+          base_address: :api
+        )
+      end
+    end
+  end
+end

data/lib/stripe/services/issuing_service.rb

@@ -0,0 +1,20 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class IssuingService < StripeService
+    attr_reader :authorizations, :cards, :cardholders, :disputes, :personalization_designs, :physical_bundles, :tokens, :transactions
+
+    def initialize(requestor)
+      super(requestor)
+      @authorizations = Stripe::Issuing::AuthorizationService.new(@requestor)
+      @cards = Stripe::Issuing::CardService.new(@requestor)
+      @cardholders = Stripe::Issuing::CardholderService.new(@requestor)
+      @disputes = Stripe::Issuing::DisputeService.new(@requestor)
+      @personalization_designs = Stripe::Issuing::PersonalizationDesignService.new(@requestor)
+      @physical_bundles = Stripe::Issuing::PhysicalBundleService.new(@requestor)
+      @tokens = Stripe::Issuing::TokenService.new(@requestor)
+      @transactions = Stripe::Issuing::TransactionService.new(@requestor)
+    end
+  end
+end

data/lib/stripe/services/mandate_service.rb

@@ -0,0 +1,17 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class MandateService < StripeService
+    # Retrieves a Mandate object.
+    def retrieve(mandate, params = {}, opts = {})
+      request(
+        method: :get,
+        path: format("/v1/mandates/%<mandate>s", { mandate: CGI.escape(mandate) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+  end
+end

data/lib/stripe/services/oauth_service.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Stripe
+  class OAuthService < StripeService
+    def authorize_url(params = {}, opts = {})
+      path = if opts[:express]
+               "/express/oauth/authorize"
+             else
+               "/oauth/authorize"
+             end
+
+      params[:client_id] = client_id(params)
+
+      params[:response_type] = "code" if params.include?(:response_type)
+
+      query = Util.encode_parameters(params, :v1)
+
+      connect_api_base = @requestor.config.base_addresses[:connect]
+      raise ArgumentError, "connect_api_base cannot be empty" if connect_api_base.nil? || connect_api_base.empty?
+
+      "#{connect_api_base}#{path}?#{query}"
+    end
+
+    def token(params = {}, opts = {})
+      opts = Util.normalize_opts(opts)
+      opts[:api_key] = params[:client_secret] if params[:client_secret]
+
+      request(
+        method: :post,
+        path: "/oauth/token",
+        params: params,
+        opts: opts,
+        base_address: :connect
+      )
+    end
+
+    def deauthorize(params = {}, opts = {})
+      params[:client_id] = client_id(params)
+
+      request(
+        method: :post,
+        path: "/oauth/deauthorize",
+        params: params,
+        opts: opts,
+        base_address: :connect
+      )
+    end
+
+    private def client_id(params = {})
+      return params[:client_id] if params.include?(:client_id)
+
+      return @requestor.config.client_id if !@requestor.config.client_id.nil? && !@requestor.config.client_id.empty?
+
+      raise AuthenticationError, "No client_id provided. (HINT: set your client_id when configuring " \
+                                 "your StripeClient: \"Stripe::StripeClient.new(..., client_id: <CLIENT_ID>)\"). " \
+                                 "You can find your client_ids in your Stripe dashboard at " \
+                                 "https://dashboard.stripe.com/account/applications/settings, " \
+                                 "after registering your account as a platform. See " \
+                                 "https://stripe.com/docs/connect/standalone-accounts for details, " \
+                                 "or email support@stripe.com if you have any questions." \
+    end
+  end
+end

data/lib/stripe/services/payment_intent_service.rb

@@ -0,0 +1,204 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class PaymentIntentService < StripeService
+    # 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://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://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://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://stripe.com/docs/stripe-js/reference#stripe-handle-card-payment)
+    # and the PaymentIntent's [client_secret](https://stripe.com/docs/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://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://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 an incremental authorization on an eligible
+    # [PaymentIntent](https://stripe.com/docs/api/payment_intents/object). To be eligible, the
+    # PaymentIntent's status must be requires_capture and
+    # [incremental_authorization_supported](https://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://stripe.com/docs/api/payment_intents/object#payment_intent_object-amount).
+    # If the incremental authorization fails, a
+    # [card_declined](https://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://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://stripe.com/docs/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://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
+
+    # 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://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(requestor)
+      @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 such as Apple Pay require additional steps to verify 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 for this domain until it is active.
+    #
+    # To activate a payment method on an existing payment method domain, complete the required validation steps specific to the payment method, and then validate the payment method domain with this endpoint.
+    #
+    # Related guides: [Payment method domains](https://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