stripe 5.55.0 → 13.5.1

data/lib/stripe/resources/setup_intent.rb

@@ -2,39 +2,145 @@
 # frozen_string_literal: true
 
 module Stripe
+  # A SetupIntent guides you through the process of setting up and saving a customer's payment credentials for future payments.
+  # For example, you can use a SetupIntent to set up and save your customer's card without immediately collecting a payment.
+  # Later, you can use [PaymentIntents](https://stripe.com/docs/api#payment_intents) to drive the payment flow.
+  #
+  # Create a SetupIntent when you're ready to collect your customer's payment credentials.
+  # Don't maintain long-lived, unconfirmed SetupIntents because they might not be valid.
+  # The SetupIntent transitions through multiple [statuses](https://docs.stripe.com/payments/intents#intent-statuses) as it guides
+  # you through the setup process.
+  #
+  # Successful SetupIntents result in payment credentials that are optimized for future payments.
+  # For example, cardholders in [certain regions](https://stripe.com/guides/strong-customer-authentication) might need to be run through
+  # [Strong Customer Authentication](https://docs.stripe.com/strong-customer-authentication) during payment method collection
+  # to streamline later [off-session payments](https://docs.stripe.com/payments/setup-intents).
+  # If you use the SetupIntent with a [Customer](https://stripe.com/docs/api#setup_intent_object-customer),
+  # it automatically attaches the resulting payment method to that Customer after successful setup.
+  # We recommend using SetupIntents or [setup_future_usage](https://stripe.com/docs/api#payment_intent_object-setup_future_usage) on
+  # PaymentIntents to save payment methods to prevent saving invalid or unoptimized payment methods.
+  #
+  # By using SetupIntents, you can reduce friction for your customers, even as regulations change over time.
+  #
+  # Related guide: [Setup Intents API](https://docs.stripe.com/payments/setup-intents)
   class SetupIntent < APIResource
     extend Stripe::APIOperations::Create
     extend Stripe::APIOperations::List
     include Stripe::APIOperations::Save
 
     OBJECT_NAME = "setup_intent"
+    def self.object_name
+      "setup_intent"
+    end
 
-    custom_method :cancel, http_verb: :post
-    custom_method :confirm, http_verb: :post
-    custom_method :verify_microdeposits, http_verb: :post
-
+    # You can cancel a SetupIntent object when it's in one of these statuses: requires_payment_method, requires_confirmation, or requires_action.
+    #
+    # After you cancel it, setup is abandoned and any operations on the SetupIntent fail with an error. You can't cancel the SetupIntent for a Checkout Session. [Expire the Checkout Session](https://stripe.com/docs/api/checkout/sessions/expire) instead.
     def cancel(params = {}, opts = {})
       request_stripe_object(
         method: :post,
-        path: resource_url + "/cancel",
+        path: format("/v1/setup_intents/%<intent>s/cancel", { intent: CGI.escape(self["id"]) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # You can cancel a SetupIntent object when it's in one of these statuses: requires_payment_method, requires_confirmation, or requires_action.
+    #
+    # After you cancel it, setup is abandoned and any operations on the SetupIntent fail with an error. You can't cancel the SetupIntent for a Checkout Session. [Expire the Checkout Session](https://stripe.com/docs/api/checkout/sessions/expire) instead.
+    def self.cancel(intent, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/setup_intents/%<intent>s/cancel", { intent: CGI.escape(intent) }),
         params: params,
         opts: opts
       )
     end
 
+    # Confirm that your customer intends to set up the current or
+    # provided payment method. For example, you would confirm a SetupIntent
+    # when a customer hits the “Save” button on a payment method management
+    # page on your website.
+    #
+    # If the selected payment method does not require any additional
+    # steps from the customer, the SetupIntent will transition to the
+    # succeeded status.
+    #
+    # Otherwise, it will transition to the requires_action status and
+    # suggest additional actions via next_action. If setup fails,
+    # the SetupIntent will transition to the
+    # requires_payment_method status or the canceled status if the
+    # confirmation limit is reached.
     def confirm(params = {}, opts = {})
       request_stripe_object(
         method: :post,
-        path: resource_url + "/confirm",
+        path: format("/v1/setup_intents/%<intent>s/confirm", { intent: CGI.escape(self["id"]) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Confirm that your customer intends to set up the current or
+    # provided payment method. For example, you would confirm a SetupIntent
+    # when a customer hits the “Save” button on a payment method management
+    # page on your website.
+    #
+    # If the selected payment method does not require any additional
+    # steps from the customer, the SetupIntent will transition to the
+    # succeeded status.
+    #
+    # Otherwise, it will transition to the requires_action status and
+    # suggest additional actions via next_action. If setup fails,
+    # the SetupIntent will transition to the
+    # requires_payment_method status or the canceled status if the
+    # confirmation limit is reached.
+    def self.confirm(intent, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/setup_intents/%<intent>s/confirm", { intent: CGI.escape(intent) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Creates a SetupIntent object.
+    #
+    # After you create the SetupIntent, attach a payment method and [confirm](https://stripe.com/docs/api/setup_intents/confirm)
+    # it to collect any required permissions to charge the payment method later.
+    def self.create(params = {}, opts = {})
+      request_stripe_object(method: :post, path: "/v1/setup_intents", params: params, opts: opts)
+    end
+
+    # Returns a list of SetupIntents.
+    def self.list(params = {}, opts = {})
+      request_stripe_object(method: :get, path: "/v1/setup_intents", params: params, opts: opts)
+    end
+
+    # Updates a SetupIntent object.
+    def self.update(intent, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/setup_intents/%<intent>s", { intent: CGI.escape(intent) }),
         params: params,
         opts: opts
       )
     end
 
+    # Verifies microdeposits on a SetupIntent object.
     def verify_microdeposits(params = {}, opts = {})
       request_stripe_object(
         method: :post,
-        path: resource_url + "/verify_microdeposits",
+        path: format("/v1/setup_intents/%<intent>s/verify_microdeposits", { intent: CGI.escape(self["id"]) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Verifies microdeposits on a SetupIntent object.
+    def self.verify_microdeposits(intent, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/setup_intents/%<intent>s/verify_microdeposits", { intent: CGI.escape(intent) }),
         params: params,
         opts: opts
       )

data/lib/stripe/resources/shipping_rate.rb

@@ -2,11 +2,36 @@
 # frozen_string_literal: true
 
 module Stripe
+  # Shipping rates describe the price of shipping presented to your customers and
+  # applied to a purchase. For more information, see [Charge for shipping](https://stripe.com/docs/payments/during-payment/charge-shipping).
   class ShippingRate < APIResource
     extend Stripe::APIOperations::Create
     extend Stripe::APIOperations::List
     include Stripe::APIOperations::Save
 
     OBJECT_NAME = "shipping_rate"
+    def self.object_name
+      "shipping_rate"
+    end
+
+    # Creates a new shipping rate object.
+    def self.create(params = {}, opts = {})
+      request_stripe_object(method: :post, path: "/v1/shipping_rates", params: params, opts: opts)
+    end
+
+    # Returns a list of your shipping rates.
+    def self.list(params = {}, opts = {})
+      request_stripe_object(method: :get, path: "/v1/shipping_rates", params: params, opts: opts)
+    end
+
+    # Updates an existing shipping rate object.
+    def self.update(shipping_rate_token, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/shipping_rates/%<shipping_rate_token>s", { shipping_rate_token: CGI.escape(shipping_rate_token) }),
+        params: params,
+        opts: opts
+      )
+    end
   end
 end

data/lib/stripe/resources/sigma/scheduled_query_run.rb

@@ -3,10 +3,27 @@
 
 module Stripe
   module Sigma
+    # If you have [scheduled a Sigma query](https://stripe.com/docs/sigma/scheduled-queries), you'll
+    # receive a `sigma.scheduled_query_run.created` webhook each time the query
+    # runs. The webhook contains a `ScheduledQueryRun` object, which you can use to
+    # retrieve the query results.
     class ScheduledQueryRun < APIResource
       extend Stripe::APIOperations::List
 
       OBJECT_NAME = "scheduled_query_run"
+      def self.object_name
+        "scheduled_query_run"
+      end
+
+      # Returns a list of scheduled query runs.
+      def self.list(params = {}, opts = {})
+        request_stripe_object(
+          method: :get,
+          path: "/v1/sigma/scheduled_query_runs",
+          params: params,
+          opts: opts
+        )
+      end
 
       def self.resource_url
         "/v1/sigma/scheduled_query_runs"

data/lib/stripe/resources/source.rb

@@ -2,22 +2,60 @@
 # frozen_string_literal: true
 
 module Stripe
+  # `Source` objects allow you to accept a variety of payment methods. They
+  # represent a customer's payment instrument, and can be used with the Stripe API
+  # just like a `Card` object: once chargeable, they can be charged, or can be
+  # attached to customers.
+  #
+  # Stripe doesn't recommend using the deprecated [Sources API](https://stripe.com/docs/api/sources).
+  # We recommend that you adopt the [PaymentMethods API](https://stripe.com/docs/api/payment_methods).
+  # This newer API provides access to our latest features and payment method types.
+  #
+  # Related guides: [Sources API](https://stripe.com/docs/sources) and [Sources & Customers](https://stripe.com/docs/sources/customers).
   class Source < APIResource
     extend Stripe::APIOperations::Create
-    include Stripe::APIOperations::Save
     extend Stripe::APIOperations::NestedResource
+    include Stripe::APIOperations::Save
 
     OBJECT_NAME = "source"
+    def self.object_name
+      "source"
+    end
 
-    custom_method :verify, http_verb: :post
+    nested_resource_class_methods :source_transaction, operations: %i[retrieve list]
 
-    nested_resource_class_methods :source_transaction,
-                                  operations: %i[retrieve list]
+    # Creates a new source object.
+    def self.create(params = {}, opts = {})
+      request_stripe_object(method: :post, path: "/v1/sources", params: params, opts: opts)
+    end
+
+    # Updates the specified source by setting the values of the parameters passed. Any parameters not provided will be left unchanged.
+    #
+    # This request accepts the metadata and owner as arguments. It is also possible to update type specific information for selected payment methods. Please refer to our [payment method guides](https://stripe.com/docs/sources) for more detail.
+    def self.update(source, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/sources/%<source>s", { source: CGI.escape(source) }),
+        params: params,
+        opts: opts
+      )
+    end
 
+    # Verify a given source.
     def verify(params = {}, opts = {})
       request_stripe_object(
         method: :post,
-        path: resource_url + "/verify",
+        path: format("/v1/sources/%<source>s/verify", { source: CGI.escape(self["id"]) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Verify a given source.
+    def self.verify(source, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/sources/%<source>s/verify", { source: CGI.escape(source) }),
         params: params,
         opts: opts
       )
@@ -32,14 +70,18 @@ module Stripe
 
       url = "#{Customer.resource_url}/#{CGI.escape(customer)}/sources" \
             "/#{CGI.escape(id)}"
-      resp, opts = execute_resource_request(:delete, url, params, opts)
-      initialize_from(resp.data, opts)
+      opts = Util.normalize_opts(opts)
+      APIRequestor.active_requestor.execute_request_initialize_from(:delete, url, :api, self,
+                                                                    params: params, opts: RequestOptions.extract_opts_from_hash(opts))
     end
 
     def source_transactions(params = {}, opts = {})
-      resp, opts = execute_resource_request(:get, resource_url + "/source_transactions", params,
-                                            opts)
-      Util.convert_to_stripe_object(resp.data, opts)
+      request_stripe_object(
+        method: :get,
+        path: resource_url + "/source_transactions",
+        params: params,
+        opts: opts
+      )
     end
     extend Gem::Deprecate
     deprecate :source_transactions, :"Source.list_source_transactions", 2020, 1

data/lib/stripe/resources/source_transaction.rb

@@ -2,7 +2,14 @@
 # frozen_string_literal: true
 
 module Stripe
+  # Some payment methods have no required amount that a customer must send.
+  # Customers can be instructed to send any amount, and it can be made up of
+  # multiple transactions. As such, sources can have multiple associated
+  # transactions.
   class SourceTransaction < StripeObject
     OBJECT_NAME = "source_transaction"
+    def self.object_name
+      "source_transaction"
+    end
   end
 end

data/lib/stripe/resources/subscription.rb

@@ -2,34 +2,147 @@
 # frozen_string_literal: true
 
 module Stripe
+  # Subscriptions allow you to charge a customer on a recurring basis.
+  #
+  # Related guide: [Creating subscriptions](https://stripe.com/docs/billing/subscriptions/creating)
   class Subscription < APIResource
     extend Stripe::APIOperations::Create
-    include Stripe::APIOperations::Delete
     extend Stripe::APIOperations::List
     extend Stripe::APIOperations::Search
     include Stripe::APIOperations::Save
 
     OBJECT_NAME = "subscription"
+    def self.object_name
+      "subscription"
+    end
 
-    custom_method :delete_discount, http_verb: :delete, http_path: "discount"
+    # Cancels a customer's subscription immediately. The customer won't be charged again for the subscription. After it's canceled, you can no longer update the subscription or its [metadata](https://stripe.com/metadata).
+    #
+    # Any pending invoice items that you've created are still charged at the end of the period, unless manually [deleted](https://stripe.com/docs/api#delete_invoiceitem). If you've set the subscription to cancel at the end of the period, any pending prorations are also left in place and collected at the end of the period. But if the subscription is set to cancel immediately, pending prorations are removed.
+    #
+    # By default, upon subscription cancellation, Stripe stops automatic collection of all finalized invoices for the customer. This is intended to prevent unexpected payment attempts after the customer has canceled a subscription. However, you can resume automatic collection of the invoices manually after subscription cancellation to have us proceed. Or, you could check for unpaid invoices before allowing the customer to cancel the subscription at all.
+    def cancel(params = {}, opts = {})
+      request_stripe_object(
+        method: :delete,
+        path: format("/v1/subscriptions/%<subscription_exposed_id>s", { subscription_exposed_id: CGI.escape(self["id"]) }),
+        params: params,
+        opts: opts
+      )
+    end
 
+    # Cancels a customer's subscription immediately. The customer won't be charged again for the subscription. After it's canceled, you can no longer update the subscription or its [metadata](https://stripe.com/metadata).
+    #
+    # Any pending invoice items that you've created are still charged at the end of the period, unless manually [deleted](https://stripe.com/docs/api#delete_invoiceitem). If you've set the subscription to cancel at the end of the period, any pending prorations are also left in place and collected at the end of the period. But if the subscription is set to cancel immediately, pending prorations are removed.
+    #
+    # By default, upon subscription cancellation, Stripe stops automatic collection of all finalized invoices for the customer. This is intended to prevent unexpected payment attempts after the customer has canceled a subscription. However, you can resume automatic collection of the invoices manually after subscription cancellation to have us proceed. Or, you could check for unpaid invoices before allowing the customer to cancel the subscription at all.
+    def self.cancel(subscription_exposed_id, params = {}, opts = {})
+      request_stripe_object(
+        method: :delete,
+        path: format("/v1/subscriptions/%<subscription_exposed_id>s", { subscription_exposed_id: CGI.escape(subscription_exposed_id) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Creates a new subscription on an existing customer. Each customer can have up to 500 active or scheduled subscriptions.
+    #
+    # When you create a subscription with collection_method=charge_automatically, the first invoice is finalized as part of the request.
+    # The payment_behavior parameter determines the exact behavior of the initial payment.
+    #
+    # To start subscriptions where the first invoice always begins in a draft status, use [subscription schedules](https://stripe.com/docs/billing/subscriptions/subscription-schedules#managing) instead.
+    # Schedules provide the flexibility to model more complex billing configurations that change over time.
+    def self.create(params = {}, opts = {})
+      request_stripe_object(method: :post, path: "/v1/subscriptions", params: params, opts: opts)
+    end
+
+    # Removes the currently applied discount on a subscription.
     def delete_discount(params = {}, opts = {})
       request_stripe_object(
         method: :delete,
-        path: resource_url + "/discount",
+        path: format("/v1/subscriptions/%<subscription_exposed_id>s/discount", { subscription_exposed_id: CGI.escape(self["id"]) }),
         params: params,
         opts: opts
       )
     end
 
-    save_nested_resource :source
+    # Removes the currently applied discount on a subscription.
+    def self.delete_discount(subscription_exposed_id, params = {}, opts = {})
+      request_stripe_object(
+        method: :delete,
+        path: format("/v1/subscriptions/%<subscription_exposed_id>s/discount", { subscription_exposed_id: CGI.escape(subscription_exposed_id) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # By default, returns a list of subscriptions that have not been canceled. In order to list canceled subscriptions, specify status=canceled.
+    def self.list(params = {}, opts = {})
+      request_stripe_object(method: :get, path: "/v1/subscriptions", params: params, opts: opts)
+    end
+
+    # Initiates resumption of a paused subscription, optionally resetting the billing cycle anchor and creating prorations. If a resumption invoice is generated, it must be paid or marked uncollectible before the subscription will be unpaused. If payment succeeds the subscription will become active, and if payment fails the subscription will be past_due. The resumption invoice will void automatically if not paid by the expiration date.
+    def resume(params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/subscriptions/%<subscription>s/resume", { subscription: CGI.escape(self["id"]) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Initiates resumption of a paused subscription, optionally resetting the billing cycle anchor and creating prorations. If a resumption invoice is generated, it must be paid or marked uncollectible before the subscription will be unpaused. If payment succeeds the subscription will become active, and if payment fails the subscription will be past_due. The resumption invoice will void automatically if not paid by the expiration date.
+    def self.resume(subscription, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/subscriptions/%<subscription>s/resume", { subscription: CGI.escape(subscription) }),
+        params: params,
+        opts: opts
+      )
+    end
 
     def self.search(params = {}, opts = {})
-      _search("/v1/subscriptions/search", params, opts)
+      request_stripe_object(
+        method: :get,
+        path: "/v1/subscriptions/search",
+        params: params,
+        opts: opts
+      )
     end
 
     def self.search_auto_paging_each(params = {}, opts = {}, &blk)
       search(params, opts).auto_paging_each(&blk)
     end
+
+    # Updates an existing subscription to match the specified parameters.
+    # When changing prices or quantities, we optionally prorate the price we charge next month to make up for any price changes.
+    # To preview how the proration is calculated, use the [create preview](https://stripe.com/docs/api/invoices/create_preview) endpoint.
+    #
+    # By default, we prorate subscription changes. For example, if a customer signs up on May 1 for a 100 price, they'll be billed 100 immediately. If on May 15 they switch to a 200 price, then on June 1 they'll be billed 250 (200 for a renewal of her subscription, plus a 50 prorating adjustment for half of the previous month's 100 difference). Similarly, a downgrade generates a credit that is applied to the next invoice. We also prorate when you make quantity changes.
+    #
+    # Switching prices does not normally change the billing date or generate an immediate charge unless:
+    #
+    #
+    # The billing interval is changed (for example, from monthly to yearly).
+    # The subscription moves from free to paid.
+    # A trial starts or ends.
+    #
+    #
+    # In these cases, we apply a credit for the unused time on the previous price, immediately charge the customer using the new price, and reset the billing date. Learn about how [Stripe immediately attempts payment for subscription changes](https://stripe.com/docs/billing/subscriptions/upgrade-downgrade#immediate-payment).
+    #
+    # If you want to charge for an upgrade immediately, pass proration_behavior as always_invoice to create prorations, automatically invoice the customer for those proration adjustments, and attempt to collect payment. If you pass create_prorations, the prorations are created but not automatically invoiced. If you want to bill the customer for the prorations before the subscription's renewal date, you need to manually [invoice the customer](https://stripe.com/docs/api/invoices/create).
+    #
+    # If you don't want to prorate, set the proration_behavior option to none. With this option, the customer is billed 100 on May 1 and 200 on June 1. Similarly, if you set proration_behavior to none when switching between different billing intervals (for example, from monthly to yearly), we don't generate any credits for the old subscription's unused time. We still reset the billing date and bill immediately for the new subscription.
+    #
+    # Updating the quantity on a subscription many times in an hour may result in [rate limiting. If you need to bill for a frequently changing quantity, consider integrating <a href="/docs/billing/subscriptions/usage-based">usage-based billing](https://stripe.com/docs/rate-limits) instead.
+    def self.update(subscription_exposed_id, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/subscriptions/%<subscription_exposed_id>s", { subscription_exposed_id: CGI.escape(subscription_exposed_id) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    save_nested_resource :source
   end
 end

data/lib/stripe/resources/subscription_item.rb

@@ -2,25 +2,73 @@
 # frozen_string_literal: true
 
 module Stripe
+  # Subscription items allow you to create customer subscriptions with more than
+  # one plan, making it easy to represent complex billing relationships.
   class SubscriptionItem < APIResource
     extend Stripe::APIOperations::Create
     include Stripe::APIOperations::Delete
     extend Stripe::APIOperations::List
-    include Stripe::APIOperations::Save
     extend Stripe::APIOperations::NestedResource
+    include Stripe::APIOperations::Save
 
     OBJECT_NAME = "subscription_item"
+    def self.object_name
+      "subscription_item"
+    end
 
     nested_resource_class_methods :usage_record, operations: %i[create]
     nested_resource_class_methods :usage_record_summary,
                                   operations: %i[list],
                                   resource_plural: "usage_record_summaries"
 
-    def usage_record_summaries(params = {}, opts = {})
-      resp, opts = execute_resource_request(:get, resource_url + "/usage_record_summaries", params, opts)
-      Util.convert_to_stripe_object(resp.data, opts)
+    # Adds a new item to an existing subscription. No existing items will be changed or replaced.
+    def self.create(params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: "/v1/subscription_items",
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Deletes an item from the subscription. Removing a subscription item from a subscription will not cancel the subscription.
+    def self.delete(item, params = {}, opts = {})
+      request_stripe_object(
+        method: :delete,
+        path: format("/v1/subscription_items/%<item>s", { item: CGI.escape(item) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Deletes an item from the subscription. Removing a subscription item from a subscription will not cancel the subscription.
+    def delete(params = {}, opts = {})
+      request_stripe_object(
+        method: :delete,
+        path: format("/v1/subscription_items/%<item>s", { item: CGI.escape(self["id"]) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Returns a list of your subscription items for a given subscription.
+    def self.list(params = {}, opts = {})
+      request_stripe_object(
+        method: :get,
+        path: "/v1/subscription_items",
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Updates the plan or quantity of an item on a current subscription.
+    def self.update(item, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/subscription_items/%<item>s", { item: CGI.escape(item) }),
+        params: params,
+        opts: opts
+      )
     end
-    extend Gem::Deprecate
-    deprecate :usage_record_summaries, :"SubscriptionItem.list_usage_record_summaries", 2020, 1
   end
 end

data/lib/stripe/resources/subscription_schedule.rb

@@ -2,29 +2,84 @@
 # frozen_string_literal: true
 
 module Stripe
+  # A subscription schedule allows you to create and manage the lifecycle of a subscription by predefining expected changes.
+  #
+  # Related guide: [Subscription schedules](https://stripe.com/docs/billing/subscriptions/subscription-schedules)
   class SubscriptionSchedule < APIResource
     extend Stripe::APIOperations::Create
     extend Stripe::APIOperations::List
     include Stripe::APIOperations::Save
 
     OBJECT_NAME = "subscription_schedule"
+    def self.object_name
+      "subscription_schedule"
+    end
 
-    custom_method :cancel, http_verb: :post
-    custom_method :release, http_verb: :post
-
+    # Cancels a subscription schedule and its associated subscription immediately (if the subscription schedule has an active subscription). A subscription schedule can only be canceled if its status is not_started or active.
     def cancel(params = {}, opts = {})
       request_stripe_object(
         method: :post,
-        path: resource_url + "/cancel",
+        path: format("/v1/subscription_schedules/%<schedule>s/cancel", { schedule: CGI.escape(self["id"]) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Cancels a subscription schedule and its associated subscription immediately (if the subscription schedule has an active subscription). A subscription schedule can only be canceled if its status is not_started or active.
+    def self.cancel(schedule, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/subscription_schedules/%<schedule>s/cancel", { schedule: CGI.escape(schedule) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Creates a new subscription schedule object. Each customer can have up to 500 active or scheduled subscriptions.
+    def self.create(params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: "/v1/subscription_schedules",
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Retrieves the list of your subscription schedules.
+    def self.list(params = {}, opts = {})
+      request_stripe_object(
+        method: :get,
+        path: "/v1/subscription_schedules",
         params: params,
         opts: opts
       )
     end
 
+    # Releases the subscription schedule immediately, which will stop scheduling of its phases, but leave any existing subscription in place. A schedule can only be released if its status is not_started or active. If the subscription schedule is currently associated with a subscription, releasing it will remove its subscription property and set the subscription's ID to the released_subscription property.
     def release(params = {}, opts = {})
       request_stripe_object(
         method: :post,
-        path: resource_url + "/release",
+        path: format("/v1/subscription_schedules/%<schedule>s/release", { schedule: CGI.escape(self["id"]) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Releases the subscription schedule immediately, which will stop scheduling of its phases, but leave any existing subscription in place. A schedule can only be released if its status is not_started or active. If the subscription schedule is currently associated with a subscription, releasing it will remove its subscription property and set the subscription's ID to the released_subscription property.
+    def self.release(schedule, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/subscription_schedules/%<schedule>s/release", { schedule: CGI.escape(schedule) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Updates an existing subscription schedule.
+    def self.update(schedule, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/subscription_schedules/%<schedule>s", { schedule: CGI.escape(schedule) }),
         params: params,
         opts: opts
       )