stripe 5.55.0 → 13.5.1

data/lib/stripe/resources/payment_method_configuration.rb

@@ -0,0 +1,59 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  # PaymentMethodConfigurations control which payment methods are displayed to your customers when you don't explicitly specify payment method types. You can have multiple configurations with different sets of payment methods for different scenarios.
+  #
+  # There are two types of PaymentMethodConfigurations. Which is used depends on the [charge type](https://stripe.com/docs/connect/charges):
+  #
+  # **Direct** configurations apply to payments created on your account, including Connect destination charges, Connect separate charges and transfers, and payments not involving Connect.
+  #
+  # **Child** configurations apply to payments created on your connected accounts using direct charges, and charges with the on_behalf_of parameter.
+  #
+  # Child configurations have a `parent` that sets default values and controls which settings connected accounts may override. You can specify a parent ID at payment time, and Stripe will automatically resolve the connected account's associated child configuration. Parent configurations are [managed in the dashboard](https://dashboard.stripe.com/settings/payment_methods/connected_accounts) and are not available in this API.
+  #
+  # Related guides:
+  # - [Payment Method Configurations API](https://stripe.com/docs/connect/payment-method-configurations)
+  # - [Multiple configurations on dynamic payment methods](https://stripe.com/docs/payments/multiple-payment-method-configs)
+  # - [Multiple configurations for your Connect accounts](https://stripe.com/docs/connect/multiple-payment-method-configurations)
+  class PaymentMethodConfiguration < APIResource
+    extend Stripe::APIOperations::Create
+    extend Stripe::APIOperations::List
+    include Stripe::APIOperations::Save
+
+    OBJECT_NAME = "payment_method_configuration"
+    def self.object_name
+      "payment_method_configuration"
+    end
+
+    # Creates a payment method configuration
+    def self.create(params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: "/v1/payment_method_configurations",
+        params: params,
+        opts: opts
+      )
+    end
+
+    # List payment method configurations
+    def self.list(params = {}, opts = {})
+      request_stripe_object(
+        method: :get,
+        path: "/v1/payment_method_configurations",
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Update payment method configuration
+    def self.update(configuration, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/payment_method_configurations/%<configuration>s", { configuration: CGI.escape(configuration) }),
+        params: params,
+        opts: opts
+      )
+    end
+  end
+end

data/lib/stripe/resources/payment_method_domain.rb

@@ -0,0 +1,79 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  # A payment method domain represents a web domain that you have registered with Stripe.
+  # Stripe Elements use registered payment method domains to control where certain payment methods are shown.
+  #
+  # Related guide: [Payment method domains](https://stripe.com/docs/payments/payment-methods/pmd-registration).
+  class PaymentMethodDomain < APIResource
+    extend Stripe::APIOperations::Create
+    extend Stripe::APIOperations::List
+    include Stripe::APIOperations::Save
+
+    OBJECT_NAME = "payment_method_domain"
+    def self.object_name
+      "payment_method_domain"
+    end
+
+    # Creates a payment method domain.
+    def self.create(params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: "/v1/payment_method_domains",
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Lists the details of existing payment method domains.
+    def self.list(params = {}, opts = {})
+      request_stripe_object(
+        method: :get,
+        path: "/v1/payment_method_domains",
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Updates an existing payment method domain.
+    def self.update(payment_method_domain, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/payment_method_domains/%<payment_method_domain>s", { payment_method_domain: CGI.escape(payment_method_domain) }),
+        params: params,
+        opts: opts
+      )
+    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(params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/payment_method_domains/%<payment_method_domain>s/validate", { payment_method_domain: CGI.escape(self["id"]) }),
+        params: params,
+        opts: opts
+      )
+    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 self.validate(payment_method_domain, params = {}, opts = {})
+      request_stripe_object(
+        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
+      )
+    end
+  end
+end

data/lib/stripe/resources/payout.rb

@@ -2,29 +2,87 @@
 # frozen_string_literal: true
 
 module Stripe
+  # A `Payout` object is created when you receive funds from Stripe, or when you
+  # initiate a payout to either a bank account or debit card of a [connected
+  # Stripe account](https://stripe.com/docs/connect/bank-debit-card-payouts). You can retrieve individual payouts,
+  # and list all payouts. Payouts are made on [varying
+  # schedules](https://stripe.com/docs/connect/manage-payout-schedule), depending on your country and
+  # industry.
+  #
+  # Related guide: [Receiving payouts](https://stripe.com/docs/payouts)
   class Payout < APIResource
     extend Stripe::APIOperations::Create
     extend Stripe::APIOperations::List
     include Stripe::APIOperations::Save
 
     OBJECT_NAME = "payout"
+    def self.object_name
+      "payout"
+    end
 
-    custom_method :cancel, http_verb: :post
-    custom_method :reverse, http_verb: :post
-
+    # You can cancel a previously created payout if its status is pending. Stripe refunds the funds to your available balance. You can't cancel automatic Stripe payouts.
     def cancel(params = {}, opts = {})
       request_stripe_object(
         method: :post,
-        path: resource_url + "/cancel",
+        path: format("/v1/payouts/%<payout>s/cancel", { payout: CGI.escape(self["id"]) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # You can cancel a previously created payout if its status is pending. Stripe refunds the funds to your available balance. You can't cancel automatic Stripe payouts.
+    def self.cancel(payout, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/payouts/%<payout>s/cancel", { payout: CGI.escape(payout) }),
         params: params,
         opts: opts
       )
     end
 
+    # To send funds to your own bank account, create a new payout object. Your [Stripe balance](https://stripe.com/docs/api#balance) must cover the payout amount. If it doesn't, you receive an “Insufficient Funds” error.
+    #
+    # If your API key is in test mode, money won't actually be sent, though every other action occurs as if you're in live mode.
+    #
+    # If you create a manual payout on a Stripe account that uses multiple payment source types, you need to specify the source type balance that the payout draws from. The [balance object](https://stripe.com/docs/api#balance_object) details available and pending amounts by source type.
+    def self.create(params = {}, opts = {})
+      request_stripe_object(method: :post, path: "/v1/payouts", params: params, opts: opts)
+    end
+
+    # Returns a list of existing payouts sent to third-party bank accounts or payouts that Stripe sent to you. The payouts return in sorted order, with the most recently created payouts appearing first.
+    def self.list(params = {}, opts = {})
+      request_stripe_object(method: :get, path: "/v1/payouts", params: params, opts: opts)
+    end
+
+    # Reverses a payout by debiting the destination bank account. At this time, you can only reverse payouts for connected accounts to US bank accounts. If the payout is manual and in the pending status, use /v1/payouts/:id/cancel instead.
+    #
+    # By requesting a reversal through /v1/payouts/:id/reverse, you confirm that the authorized signatory of the selected bank account authorizes the debit on the bank account and that no other authorization is required.
     def reverse(params = {}, opts = {})
       request_stripe_object(
         method: :post,
-        path: resource_url + "/reverse",
+        path: format("/v1/payouts/%<payout>s/reverse", { payout: CGI.escape(self["id"]) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Reverses a payout by debiting the destination bank account. At this time, you can only reverse payouts for connected accounts to US bank accounts. If the payout is manual and in the pending status, use /v1/payouts/:id/cancel instead.
+    #
+    # By requesting a reversal through /v1/payouts/:id/reverse, you confirm that the authorized signatory of the selected bank account authorizes the debit on the bank account and that no other authorization is required.
+    def self.reverse(payout, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/payouts/%<payout>s/reverse", { payout: CGI.escape(payout) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Updates the specified payout by setting the values of the parameters you pass. We don't change parameters that you don't provide. This request only accepts the metadata as arguments.
+    def self.update(payout, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/payouts/%<payout>s", { payout: CGI.escape(payout) }),
         params: params,
         opts: opts
       )

data/lib/stripe/resources/person.rb

@@ -2,11 +2,18 @@
 # frozen_string_literal: true
 
 module Stripe
+  # This is an object representing a person associated with a Stripe account.
+  #
+  # A platform cannot access a person for an account where [account.controller.requirement_collection](https://stripe.com/api/accounts/object#account_object-controller-requirement_collection) is `stripe`, which includes Standard and Express accounts, after creating an Account Link or Account Session to start Connect onboarding.
+  #
+  # See the [Standard onboarding](https://stripe.com/connect/standard-accounts) or [Express onboarding](https://stripe.com/connect/express-accounts) documentation for information about prefilling information and account onboarding steps. Learn more about [handling identity verification with the API](https://stripe.com/connect/handling-api-verification#person-information).
   class Person < APIResource
-    extend Stripe::APIOperations::List
     include Stripe::APIOperations::Save
 
     OBJECT_NAME = "person"
+    def self.object_name
+      "person"
+    end
 
     def resource_url
       if !respond_to?(:account) || account.nil?

data/lib/stripe/resources/plan.rb

@@ -2,6 +2,14 @@
 # frozen_string_literal: true
 
 module Stripe
+  # You can now model subscriptions more flexibly using the [Prices API](https://stripe.com/docs/api#prices). It replaces the Plans API and is backwards compatible to simplify your migration.
+  #
+  # Plans define the base price, currency, and billing cycle for recurring purchases of products.
+  # [Products](https://stripe.com/docs/api#products) help you track inventory or provisioning, and plans help you track pricing. Different physical goods or levels of service should be represented by products, and pricing options should be represented by plans. This approach lets you change prices without having to change your provisioning scheme.
+  #
+  # For example, you might have a single "gold" product that has plans for $10/month, $100/year, €9/month, and €90/year.
+  #
+  # Related guides: [Set up a subscription](https://stripe.com/docs/billing/subscriptions/set-up-subscription) and more about [products and prices](https://stripe.com/docs/products-prices/overview).
   class Plan < APIResource
     extend Stripe::APIOperations::Create
     include Stripe::APIOperations::Delete
@@ -9,5 +17,48 @@ module Stripe
     include Stripe::APIOperations::Save
 
     OBJECT_NAME = "plan"
+    def self.object_name
+      "plan"
+    end
+
+    # You can now model subscriptions more flexibly using the [Prices API](https://stripe.com/docs/api#prices). It replaces the Plans API and is backwards compatible to simplify your migration.
+    def self.create(params = {}, opts = {})
+      request_stripe_object(method: :post, path: "/v1/plans", params: params, opts: opts)
+    end
+
+    # Deleting plans means new subscribers can't be added. Existing subscribers aren't affected.
+    def self.delete(plan, params = {}, opts = {})
+      request_stripe_object(
+        method: :delete,
+        path: format("/v1/plans/%<plan>s", { plan: CGI.escape(plan) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Deleting plans means new subscribers can't be added. Existing subscribers aren't affected.
+    def delete(params = {}, opts = {})
+      request_stripe_object(
+        method: :delete,
+        path: format("/v1/plans/%<plan>s", { plan: CGI.escape(self["id"]) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Returns a list of your plans.
+    def self.list(params = {}, opts = {})
+      request_stripe_object(method: :get, path: "/v1/plans", params: params, opts: opts)
+    end
+
+    # Updates the specified plan by setting the values of the parameters passed. Any parameters not provided are left unchanged. By design, you cannot change a plan's ID, amount, currency, or billing cycle.
+    def self.update(plan, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/plans/%<plan>s", { plan: CGI.escape(plan) }),
+        params: params,
+        opts: opts
+      )
+    end
   end
 end

data/lib/stripe/resources/price.rb

@@ -2,6 +2,12 @@
 # frozen_string_literal: true
 
 module Stripe
+  # Prices define the unit cost, currency, and (optional) billing cycle for both recurring and one-time purchases of products.
+  # [Products](https://stripe.com/docs/api#products) help you track inventory or provisioning, and prices help you track payment terms. Different physical goods or levels of service should be represented by products, and pricing options should be represented by prices. This approach lets you change prices without having to change your provisioning scheme.
+  #
+  # For example, you might have a single "gold" product that has prices for $10/month, $100/year, and €9 once.
+  #
+  # Related guides: [Set up a subscription](https://stripe.com/docs/billing/subscriptions/set-up-subscription), [create an invoice](https://stripe.com/docs/billing/invoices/create), and more about [products and prices](https://stripe.com/docs/products-prices/overview).
   class Price < APIResource
     extend Stripe::APIOperations::Create
     extend Stripe::APIOperations::List
@@ -9,13 +15,36 @@ module Stripe
     include Stripe::APIOperations::Save
 
     OBJECT_NAME = "price"
+    def self.object_name
+      "price"
+    end
+
+    # Creates a new price for an existing product. The price can be recurring or one-time.
+    def self.create(params = {}, opts = {})
+      request_stripe_object(method: :post, path: "/v1/prices", params: params, opts: opts)
+    end
+
+    # Returns a list of your active prices, excluding [inline prices](https://stripe.com/docs/products-prices/pricing-models#inline-pricing). For the list of inactive prices, set active to false.
+    def self.list(params = {}, opts = {})
+      request_stripe_object(method: :get, path: "/v1/prices", params: params, opts: opts)
+    end
 
     def self.search(params = {}, opts = {})
-      _search("/v1/prices/search", params, opts)
+      request_stripe_object(method: :get, path: "/v1/prices/search", params: params, opts: opts)
     end
 
     def self.search_auto_paging_each(params = {}, opts = {}, &blk)
       search(params, opts).auto_paging_each(&blk)
     end
+
+    # Updates the specified price by setting the values of the parameters passed. Any parameters not provided are left unchanged.
+    def self.update(price, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/prices/%<price>s", { price: CGI.escape(price) }),
+        params: params,
+        opts: opts
+      )
+    end
   end
 end

data/lib/stripe/resources/product.rb

@@ -2,21 +2,75 @@
 # frozen_string_literal: true
 
 module Stripe
+  # Products describe the specific goods or services you offer to your customers.
+  # For example, you might offer a Standard and Premium version of your goods or service; each version would be a separate Product.
+  # They can be used in conjunction with [Prices](https://stripe.com/docs/api#prices) to configure pricing in Payment Links, Checkout, and Subscriptions.
+  #
+  # Related guides: [Set up a subscription](https://stripe.com/docs/billing/subscriptions/set-up-subscription),
+  # [share a Payment Link](https://stripe.com/docs/payment-links),
+  # [accept payments with Checkout](https://stripe.com/docs/payments/accept-a-payment#create-product-prices-upfront),
+  # and more about [Products and Prices](https://stripe.com/docs/products-prices/overview)
   class Product < APIResource
     extend Stripe::APIOperations::Create
     include Stripe::APIOperations::Delete
     extend Stripe::APIOperations::List
+    extend Stripe::APIOperations::NestedResource
     extend Stripe::APIOperations::Search
     include Stripe::APIOperations::Save
 
     OBJECT_NAME = "product"
+    def self.object_name
+      "product"
+    end
+
+    nested_resource_class_methods :feature, operations: %i[create retrieve delete list]
+
+    # Creates a new product object.
+    def self.create(params = {}, opts = {})
+      request_stripe_object(method: :post, path: "/v1/products", params: params, opts: opts)
+    end
+
+    # Delete a product. Deleting a product is only possible if it has no prices associated with it. Additionally, deleting a product with type=good is only possible if it has no SKUs associated with it.
+    def self.delete(id, params = {}, opts = {})
+      request_stripe_object(
+        method: :delete,
+        path: format("/v1/products/%<id>s", { id: CGI.escape(id) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Delete a product. Deleting a product is only possible if it has no prices associated with it. Additionally, deleting a product with type=good is only possible if it has no SKUs associated with it.
+    def delete(params = {}, opts = {})
+      request_stripe_object(
+        method: :delete,
+        path: format("/v1/products/%<id>s", { id: CGI.escape(self["id"]) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Returns a list of your products. The products are returned sorted by creation date, with the most recently created products appearing first.
+    def self.list(params = {}, opts = {})
+      request_stripe_object(method: :get, path: "/v1/products", params: params, opts: opts)
+    end
 
     def self.search(params = {}, opts = {})
-      _search("/v1/products/search", params, opts)
+      request_stripe_object(method: :get, path: "/v1/products/search", params: params, opts: opts)
     end
 
     def self.search_auto_paging_each(params = {}, opts = {}, &blk)
       search(params, opts).auto_paging_each(&blk)
     end
+
+    # Updates the specific product by setting the values of the parameters passed. Any parameters not provided will be left unchanged.
+    def self.update(id, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/products/%<id>s", { id: CGI.escape(id) }),
+        params: params,
+        opts: opts
+      )
+    end
   end
 end

data/lib/stripe/resources/product_feature.rb

@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  # A product_feature represents an attachment between a feature and a product.
+  # When a product is purchased that has a feature attached, Stripe will create an entitlement to the feature for the purchasing customer.
+  class ProductFeature < APIResource
+    OBJECT_NAME = "product_feature"
+    def self.object_name
+      "product_feature"
+    end
+  end
+end

data/lib/stripe/resources/promotion_code.rb

@@ -2,11 +2,36 @@
 # frozen_string_literal: true
 
 module Stripe
+  # A Promotion Code represents a customer-redeemable code for a [coupon](https://stripe.com/docs/api#coupons). It can be used to
+  # create multiple codes for a single coupon.
   class PromotionCode < APIResource
     extend Stripe::APIOperations::Create
     extend Stripe::APIOperations::List
     include Stripe::APIOperations::Save
 
     OBJECT_NAME = "promotion_code"
+    def self.object_name
+      "promotion_code"
+    end
+
+    # A promotion code points to a coupon. You can optionally restrict the code to a specific customer, redemption limit, and expiration date.
+    def self.create(params = {}, opts = {})
+      request_stripe_object(method: :post, path: "/v1/promotion_codes", params: params, opts: opts)
+    end
+
+    # Returns a list of your promotion codes.
+    def self.list(params = {}, opts = {})
+      request_stripe_object(method: :get, path: "/v1/promotion_codes", params: params, opts: opts)
+    end
+
+    # Updates the specified promotion code by setting the values of the parameters passed. Most fields are, by design, not editable.
+    def self.update(promotion_code, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/promotion_codes/%<promotion_code>s", { promotion_code: CGI.escape(promotion_code) }),
+        params: params,
+        opts: opts
+      )
+    end
   end
 end