stripe 12.7.0.pre.beta.2 → 13.1.0.pre.beta.2

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

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://stripe.com/docs/api/setup_intents)
+    # or a PaymentIntent with [setup_future_usage](https://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://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://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://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://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 PaymentMethods for Treasury flows. If you want to list the PaymentMethods attached to a Customer for payments, you should use the [List a Customer's PaymentMethods](https://stripe.com/docs/api/payment_methods/customer_list) API instead.
+    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://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 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/payout_service.rb

@@ -0,0 +1,66 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class PayoutService < StripeService
+    # 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(payout, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payouts/%<payout>s/cancel", { payout: CGI.escape(payout) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    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 create(params = {}, opts = {})
+      request(method: :post, path: "/v1/payouts", params: params, opts: opts, base_address: :api)
+    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 list(params = {}, opts = {})
+      request(method: :get, path: "/v1/payouts", params: params, opts: opts, base_address: :api)
+    end
+
+    # Retrieves the details of an existing payout. Supply the unique payout ID from either a payout creation request or the payout list. Stripe returns the corresponding payout information.
+    def retrieve(payout, params = {}, opts = {})
+      request(
+        method: :get,
+        path: format("/v1/payouts/%<payout>s", { payout: CGI.escape(payout) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    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(payout, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payouts/%<payout>s/reverse", { payout: CGI.escape(payout) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    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 update(payout, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payouts/%<payout>s", { payout: CGI.escape(payout) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+  end
+end

data/lib/stripe/services/plan_service.rb

@@ -0,0 +1,49 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class PlanService < StripeService
+    # 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 create(params = {}, opts = {})
+      request(method: :post, path: "/v1/plans", params: params, opts: opts, base_address: :api)
+    end
+
+    # Deleting plans means new subscribers can't be added. Existing subscribers aren't affected.
+    def delete(plan, params = {}, opts = {})
+      request(
+        method: :delete,
+        path: format("/v1/plans/%<plan>s", { plan: CGI.escape(plan) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Returns a list of your plans.
+    def list(params = {}, opts = {})
+      request(method: :get, path: "/v1/plans", params: params, opts: opts, base_address: :api)
+    end
+
+    # Retrieves the plan with the given ID.
+    def retrieve(plan, params = {}, opts = {})
+      request(
+        method: :get,
+        path: format("/v1/plans/%<plan>s", { plan: CGI.escape(plan) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    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 update(plan, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/plans/%<plan>s", { plan: CGI.escape(plan) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+  end
+end

data/lib/stripe/services/price_service.rb

@@ -0,0 +1,52 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class PriceService < StripeService
+    # Creates a new price for an existing product. The price can be recurring or one-time.
+    def create(params = {}, opts = {})
+      request(method: :post, path: "/v1/prices", params: params, opts: opts, base_address: :api)
+    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 list(params = {}, opts = {})
+      request(method: :get, path: "/v1/prices", params: params, opts: opts, base_address: :api)
+    end
+
+    # Retrieves the price with the given ID.
+    def retrieve(price, params = {}, opts = {})
+      request(
+        method: :get,
+        path: format("/v1/prices/%<price>s", { price: CGI.escape(price) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Search for prices 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/prices/search",
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Updates the specified price by setting the values of the parameters passed. Any parameters not provided are left unchanged.
+    def update(price, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/prices/%<price>s", { price: CGI.escape(price) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+  end
+end

data/lib/stripe/services/product_feature_service.rb

@@ -0,0 +1,50 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class ProductFeatureService < StripeService
+    # Creates a product_feature, which represents a feature attachment to a product
+    def create(product, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/products/%<product>s/features", { product: CGI.escape(product) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Deletes the feature attachment to a product
+    def delete(product, id, params = {}, opts = {})
+      request(
+        method: :delete,
+        path: format("/v1/products/%<product>s/features/%<id>s", { product: CGI.escape(product), id: CGI.escape(id) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Retrieve a list of features for a product
+    def list(product, params = {}, opts = {})
+      request(
+        method: :get,
+        path: format("/v1/products/%<product>s/features", { product: CGI.escape(product) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Retrieves a product_feature, which represents a feature attachment to a product
+    def retrieve(product, id, params = {}, opts = {})
+      request(
+        method: :get,
+        path: format("/v1/products/%<product>s/features/%<id>s", { product: CGI.escape(product), id: CGI.escape(id) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+  end
+end

data/lib/stripe/services/product_service.rb

@@ -0,0 +1,70 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class ProductService < StripeService
+    attr_reader :features
+
+    def initialize(requestor)
+      super(requestor)
+      @features = Stripe::ProductFeatureService.new(@requestor)
+    end
+
+    # Creates a new product object.
+    def create(params = {}, opts = {})
+      request(method: :post, path: "/v1/products", params: params, opts: opts, base_address: :api)
+    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(id, params = {}, opts = {})
+      request(
+        method: :delete,
+        path: format("/v1/products/%<id>s", { id: CGI.escape(id) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Returns a list of your products. The products are returned sorted by creation date, with the most recently created products appearing first.
+    def list(params = {}, opts = {})
+      request(method: :get, path: "/v1/products", params: params, opts: opts, base_address: :api)
+    end
+
+    # Retrieves the details of an existing product. Supply the unique product ID from either a product creation request or the product list, and Stripe will return the corresponding product information.
+    def retrieve(id, params = {}, opts = {})
+      request(
+        method: :get,
+        path: format("/v1/products/%<id>s", { id: CGI.escape(id) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Search for products 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/products/search",
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Updates the specific product by setting the values of the parameters passed. Any parameters not provided will be left unchanged.
+    def update(id, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/products/%<id>s", { id: CGI.escape(id) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+  end
+end

data/lib/stripe/services/promotion_code_service.rb

@@ -0,0 +1,50 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class PromotionCodeService < StripeService
+    # A promotion code points to a coupon. You can optionally restrict the code to a specific customer, redemption limit, and expiration date.
+    def create(params = {}, opts = {})
+      request(
+        method: :post,
+        path: "/v1/promotion_codes",
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Returns a list of your promotion codes.
+    def list(params = {}, opts = {})
+      request(
+        method: :get,
+        path: "/v1/promotion_codes",
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Retrieves the promotion code with the given ID. In order to retrieve a promotion code by the customer-facing code use [list](https://stripe.com/docs/api/promotion_codes/list) with the desired code.
+    def retrieve(promotion_code, params = {}, opts = {})
+      request(
+        method: :get,
+        path: format("/v1/promotion_codes/%<promotion_code>s", { promotion_code: CGI.escape(promotion_code) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Updates the specified promotion code by setting the values of the parameters passed. Most fields are, by design, not editable.
+    def update(promotion_code, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/promotion_codes/%<promotion_code>s", { promotion_code: CGI.escape(promotion_code) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+  end
+end

data/lib/stripe/services/quote_computed_upfront_line_items_service.rb

@@ -0,0 +1,17 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class QuoteComputedUpfrontLineItemsService < StripeService
+    # When retrieving a quote, there is an includable [computed.upfront.line_items](https://stripe.com/docs/api/quotes/object#quote_object-computed-upfront-line_items) property containing the first handful of those items. There is also a URL where you can retrieve the full (paginated) list of upfront line items.
+    def list(quote, params = {}, opts = {})
+      request(
+        method: :get,
+        path: format("/v1/quotes/%<quote>s/computed_upfront_line_items", { quote: CGI.escape(quote) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+  end
+end

data/lib/stripe/services/quote_line_item_service.rb

@@ -0,0 +1,17 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class QuoteLineItemService < StripeService
+    # When retrieving a quote, 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(quote, params = {}, opts = {})
+      request(
+        method: :get,
+        path: format("/v1/quotes/%<quote>s/line_items", { quote: CGI.escape(quote) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+  end
+end

data/lib/stripe/services/quote_line_service.rb

@@ -0,0 +1,17 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class QuoteLineService < StripeService
+    # Retrieves a paginated list of lines for a quote. These lines describe changes that will be used to create new subscription schedules or update existing subscription schedules when the quote is accepted.
+    def list(quote, params = {}, opts = {})
+      request(
+        method: :get,
+        path: format("/v1/quotes/%<quote>s/lines", { quote: CGI.escape(quote) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+  end
+end

data/lib/stripe/services/quote_preview_invoice_service.rb

@@ -0,0 +1,17 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class QuotePreviewInvoiceService < StripeService
+    # Preview the invoices that would be generated by accepting the quote.
+    def list(quote, params = {}, opts = {})
+      request(
+        method: :get,
+        path: format("/v1/quotes/%<quote>s/preview_invoices", { quote: CGI.escape(quote) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+  end
+end