stripe 5.55.0 → 13.5.1

data/lib/stripe/resources/credit_note.rb

@@ -2,32 +2,90 @@
 # frozen_string_literal: true
 
 module Stripe
+  # Issue a credit note to adjust an invoice's amount after the invoice is finalized.
+  #
+  # Related guide: [Credit notes](https://stripe.com/docs/billing/invoices/credit-notes)
   class CreditNote < APIResource
     extend Stripe::APIOperations::Create
     extend Stripe::APIOperations::List
     include Stripe::APIOperations::Save
 
     OBJECT_NAME = "credit_note"
+    def self.object_name
+      "credit_note"
+    end
 
-    custom_method :void_credit_note, http_verb: :post, http_path: "void"
+    # Issue a credit note to adjust the amount of a finalized invoice. For a status=open invoice, a credit note reduces
+    # its amount_due. For a status=paid invoice, a credit note does not affect its amount_due. Instead, it can result
+    # in any combination of the following:
+    #
+    #
+    # Refund: create a new refund (using refund_amount) or link an existing refund (using refund).
+    # Customer balance credit: credit the customer's balance (using credit_amount) which will be automatically applied to their next invoice when it's finalized.
+    # Outside of Stripe credit: record the amount that is or will be credited outside of Stripe (using out_of_band_amount).
+    #
+    #
+    # For post-payment credit notes the sum of the refund, credit and outside of Stripe amounts must equal the credit note total.
+    #
+    # You may issue multiple credit notes for an invoice. Each credit note will increment the invoice's pre_payment_credit_notes_amount
+    # or post_payment_credit_notes_amount depending on its status at the time of credit note creation.
+    def self.create(params = {}, opts = {})
+      request_stripe_object(method: :post, path: "/v1/credit_notes", params: params, opts: opts)
+    end
 
-    def void_credit_note(params = {}, opts = {})
+    # Returns a list of credit notes.
+    def self.list(params = {}, opts = {})
+      request_stripe_object(method: :get, path: "/v1/credit_notes", params: params, opts: opts)
+    end
+
+    # When retrieving a credit note preview, you'll get a lines property containing the first handful of those items. This URL you can retrieve the full (paginated) list of line items.
+    def self.list_preview_line_items(params = {}, opts = {})
+      request_stripe_object(
+        method: :get,
+        path: "/v1/credit_notes/preview/lines",
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Get a preview of a credit note without creating it.
+    def self.preview(params = {}, opts = {})
+      request_stripe_object(
+        method: :get,
+        path: "/v1/credit_notes/preview",
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Updates an existing credit note.
+    def self.update(id, params = {}, opts = {})
       request_stripe_object(
         method: :post,
-        path: resource_url + "/void",
+        path: format("/v1/credit_notes/%<id>s", { id: CGI.escape(id) }),
         params: params,
         opts: opts
       )
     end
 
-    def self.preview(params, opts = {})
-      resp, opts = execute_resource_request(:get, resource_url + "/preview", params, opts)
-      Util.convert_to_stripe_object(resp.data, opts)
+    # Marks a credit note as void. Learn more about [voiding credit notes](https://stripe.com/docs/billing/invoices/credit-notes#voiding).
+    def void_credit_note(params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/credit_notes/%<id>s/void", { id: CGI.escape(self["id"]) }),
+        params: params,
+        opts: opts
+      )
     end
 
-    def self.list_preview_line_items(params, opts = {})
-      resp, opts = execute_resource_request(:get, resource_url + "/preview/lines", params, opts)
-      Util.convert_to_stripe_object(resp.data, opts)
+    # Marks a credit note as void. Learn more about [voiding credit notes](https://stripe.com/docs/billing/invoices/credit-notes#voiding).
+    def self.void_credit_note(id, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/credit_notes/%<id>s/void", { id: CGI.escape(id) }),
+        params: params,
+        opts: opts
+      )
     end
   end
 end

data/lib/stripe/resources/credit_note_line_item.rb

@@ -2,7 +2,11 @@
 # frozen_string_literal: true
 
 module Stripe
+  # The credit note line item object
   class CreditNoteLineItem < StripeObject
     OBJECT_NAME = "credit_note_line_item"
+    def self.object_name
+      "credit_note_line_item"
+    end
   end
 end

data/lib/stripe/resources/customer.rb

@@ -2,50 +2,181 @@
 # frozen_string_literal: true
 
 module Stripe
+  # This object represents a customer of your business. Use it to [create recurring charges](https://stripe.com/docs/invoicing/customer), [save payment](https://stripe.com/docs/payments/save-during-payment) and contact information,
+  # and track payments that belong to the same customer.
   class Customer < 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
-    extend Stripe::APIOperations::NestedResource
 
     OBJECT_NAME = "customer"
+    def self.object_name
+      "customer"
+    end
 
-    custom_method :create_funding_instructions, http_verb: :post, http_path: "funding_instructions"
-    custom_method :list_payment_methods, http_verb: :get, http_path: "payment_methods"
+    nested_resource_class_methods :balance_transaction, operations: %i[create retrieve update list]
+    nested_resource_class_methods :cash_balance_transaction, operations: %i[retrieve list]
+    nested_resource_class_methods :source, operations: %i[create retrieve update delete list]
+    nested_resource_class_methods :tax_id, operations: %i[create retrieve delete list]
 
-    nested_resource_class_methods :cash_balance,
-                                  operations: %i[retrieve update],
-                                  resource_plural: "cash_balance"
-    nested_resource_class_methods :balance_transaction,
-                                  operations: %i[create retrieve update list]
-    nested_resource_class_methods :tax_id,
-                                  operations: %i[create retrieve delete list]
+    # Creates a new customer object.
+    def self.create(params = {}, opts = {})
+      request_stripe_object(method: :post, path: "/v1/customers", params: params, opts: opts)
+    end
 
+    # Retrieve funding instructions for a customer cash balance. If funding instructions do not yet exist for the customer, new
+    # funding instructions will be created. If funding instructions have already been created for a given customer, the same
+    # funding instructions will be retrieved. In other words, we will return the same funding instructions each time.
     def create_funding_instructions(params = {}, opts = {})
       request_stripe_object(
         method: :post,
-        path: resource_url + "/funding_instructions",
+        path: format("/v1/customers/%<customer>s/funding_instructions", { customer: CGI.escape(self["id"]) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Retrieve funding instructions for a customer cash balance. If funding instructions do not yet exist for the customer, new
+    # funding instructions will be created. If funding instructions have already been created for a given customer, the same
+    # funding instructions will be retrieved. In other words, we will return the same funding instructions each time.
+    def self.create_funding_instructions(customer, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/customers/%<customer>s/funding_instructions", { customer: CGI.escape(customer) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Permanently deletes a customer. It cannot be undone. Also immediately cancels any active subscriptions on the customer.
+    def self.delete(customer, params = {}, opts = {})
+      request_stripe_object(
+        method: :delete,
+        path: format("/v1/customers/%<customer>s", { customer: CGI.escape(customer) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Permanently deletes a customer. It cannot be undone. Also immediately cancels any active subscriptions on the customer.
+    def delete(params = {}, opts = {})
+      request_stripe_object(
+        method: :delete,
+        path: format("/v1/customers/%<customer>s", { customer: CGI.escape(self["id"]) }),
         params: params,
         opts: opts
       )
     end
 
+    # Removes the currently applied discount on a customer.
+    def delete_discount(params = {}, opts = {})
+      request_stripe_object(
+        method: :delete,
+        path: format("/v1/customers/%<customer>s/discount", { customer: CGI.escape(self["id"]) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Removes the currently applied discount on a customer.
+    def self.delete_discount(customer, params = {}, opts = {})
+      request_stripe_object(
+        method: :delete,
+        path: format("/v1/customers/%<customer>s/discount", { customer: CGI.escape(customer) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Returns a list of your customers. The customers are returned sorted by creation date, with the most recent customers appearing first.
+    def self.list(params = {}, opts = {})
+      request_stripe_object(method: :get, path: "/v1/customers", params: params, opts: opts)
+    end
+
+    # Returns a list of PaymentMethods for a given Customer
     def list_payment_methods(params = {}, opts = {})
       request_stripe_object(
         method: :get,
-        path: resource_url + "/payment_methods",
+        path: format("/v1/customers/%<customer>s/payment_methods", { customer: CGI.escape(self["id"]) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Returns a list of PaymentMethods for a given Customer
+    def self.list_payment_methods(customer, params = {}, opts = {})
+      request_stripe_object(
+        method: :get,
+        path: format("/v1/customers/%<customer>s/payment_methods", { customer: CGI.escape(customer) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Retrieves a customer's cash balance.
+    def self.retrieve_cash_balance(customer, params = {}, opts = {})
+      request_stripe_object(
+        method: :get,
+        path: format("/v1/customers/%<customer>s/cash_balance", { customer: CGI.escape(customer) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Retrieves a PaymentMethod object for a given Customer.
+    def retrieve_payment_method(payment_method, params = {}, opts = {})
+      request_stripe_object(
+        method: :get,
+        path: format("/v1/customers/%<customer>s/payment_methods/%<payment_method>s", { customer: CGI.escape(self["id"]), payment_method: CGI.escape(payment_method) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Retrieves a PaymentMethod object for a given Customer.
+    def self.retrieve_payment_method(customer, payment_method, params = {}, opts = {})
+      request_stripe_object(
+        method: :get,
+        path: format("/v1/customers/%<customer>s/payment_methods/%<payment_method>s", { customer: CGI.escape(customer), payment_method: CGI.escape(payment_method) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    def self.search(params = {}, opts = {})
+      request_stripe_object(method: :get, path: "/v1/customers/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 customer by setting the values of the parameters passed. Any parameters not provided will be left unchanged. For example, if you pass the source parameter, that becomes the customer's active source (e.g., a card) to be used for all charges in the future. When you update a customer to a new valid card source by passing the source parameter: for each of the customer's current subscriptions, if the subscription bills automatically and is in the past_due state, then the latest open invoice for the subscription with automatic collection enabled will be retried. This retry will not count as an automatic retry, and will not affect the next regularly scheduled payment for the invoice. Changing the default_source for a customer will not trigger this behavior.
+    #
+    # This request accepts mostly the same arguments as the customer creation call.
+    def self.update(customer, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/customers/%<customer>s", { customer: CGI.escape(customer) }),
         params: params,
         opts: opts
       )
     end
 
-    custom_method :delete_discount, http_verb: :delete, http_path: "discount"
+    # Changes the settings on a customer's cash balance.
+    def self.update_cash_balance(customer, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/customers/%<customer>s/cash_balance", { customer: CGI.escape(customer) }),
+        params: params,
+        opts: opts
+      )
+    end
 
     save_nested_resource :source
-    nested_resource_class_methods :source,
-                                  operations: %i[create retrieve update delete list]
 
     # The API request for deleting a card or bank account and for detaching a
     # source object are the same.
@@ -53,22 +184,35 @@ module Stripe
       alias detach_source delete_source
     end
 
-    # Deletes a discount associated with the customer.
-    #
-    # Returns the deleted discount. The customer object is not updated,
-    # so you must call `refresh` on it to get a new version with the
-    # discount removed.
-    def delete_discount
-      resp, opts = execute_resource_request(:delete, resource_url + "/discount")
-      Util.convert_to_stripe_object(resp.data, opts)
+    def test_helpers
+      TestHelpers.new(self)
     end
 
-    def self.search(params = {}, opts = {})
-      _search("/v1/customers/search", params, opts)
-    end
+    class TestHelpers < APIResourceTestHelpers
+      RESOURCE_CLASS = Customer
+      def self.resource_class
+        "Customer"
+      end
 
-    def self.search_auto_paging_each(params = {}, opts = {}, &blk)
-      search(params, opts).auto_paging_each(&blk)
+      # Create an incoming testmode bank transfer
+      def self.fund_cash_balance(customer, params = {}, opts = {})
+        request_stripe_object(
+          method: :post,
+          path: format("/v1/test_helpers/customers/%<customer>s/fund_cash_balance", { customer: CGI.escape(customer) }),
+          params: params,
+          opts: opts
+        )
+      end
+
+      # Create an incoming testmode bank transfer
+      def fund_cash_balance(params = {}, opts = {})
+        @resource.request_stripe_object(
+          method: :post,
+          path: format("/v1/test_helpers/customers/%<customer>s/fund_cash_balance", { customer: CGI.escape(@resource["id"]) }),
+          params: params,
+          opts: opts
+        )
+      end
     end
   end
 end

data/lib/stripe/resources/customer_balance_transaction.rb

@@ -2,11 +2,19 @@
 # frozen_string_literal: true
 
 module Stripe
+  # Each customer has a [Balance](https://stripe.com/docs/api/customers/object#customer_object-balance) value,
+  # which denotes a debit or credit that's automatically applied to their next invoice upon finalization.
+  # You may modify the value directly by using the [update customer API](https://stripe.com/docs/api/customers/update),
+  # or by creating a Customer Balance Transaction, which increments or decrements the customer's `balance` by the specified `amount`.
+  #
+  # Related guide: [Customer balance](https://stripe.com/docs/billing/customer/balance)
   class CustomerBalanceTransaction < APIResource
-    extend Stripe::APIOperations::List
     include Stripe::APIOperations::Save
 
     OBJECT_NAME = "customer_balance_transaction"
+    def self.object_name
+      "customer_balance_transaction"
+    end
 
     def resource_url
       if !respond_to?(:customer) || customer.nil?

data/lib/stripe/resources/customer_cash_balance_transaction.rb

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  # Customers with certain payments enabled have a cash balance, representing funds that were paid
+  # by the customer to a merchant, but have not yet been allocated to a payment. Cash Balance Transactions
+  # represent when funds are moved into or out of this balance. This includes funding by the customer, allocation
+  # to payments, and refunds to the customer.
+  class CustomerCashBalanceTransaction < APIResource
+    OBJECT_NAME = "customer_cash_balance_transaction"
+    def self.object_name
+      "customer_cash_balance_transaction"
+    end
+  end
+end

data/lib/stripe/resources/customer_session.rb

@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  # A Customer Session allows you to grant Stripe's frontend SDKs (like Stripe.js) client-side access
+  # control over a Customer.
+  #
+  # Related guides: [Customer Session with the Payment Element](https://stripe.com/payments/accept-a-payment-deferred?platform=web&type=payment#save-payment-methods),
+  # [Customer Session with the Pricing Table](https://stripe.com/payments/checkout/pricing-table#customer-session),
+  # [Customer Session with the Buy Button](https://stripe.com/payment-links/buy-button#pass-an-existing-customer).
+  class CustomerSession < APIResource
+    extend Stripe::APIOperations::Create
+
+    OBJECT_NAME = "customer_session"
+    def self.object_name
+      "customer_session"
+    end
+
+    # Creates a Customer Session object that includes a single-use client secret that you can use on your front-end to grant client-side API access for certain customer resources.
+    def self.create(params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: "/v1/customer_sessions",
+        params: params,
+        opts: opts
+      )
+    end
+  end
+end

data/lib/stripe/resources/discount.rb

@@ -2,7 +2,14 @@
 # frozen_string_literal: true
 
 module Stripe
+  # A discount represents the actual application of a [coupon](https://stripe.com/docs/api#coupons) or [promotion code](https://stripe.com/docs/api#promotion_codes).
+  # It contains information about when the discount began, when it will end, and what it is applied to.
+  #
+  # Related guide: [Applying discounts to subscriptions](https://stripe.com/docs/billing/subscriptions/discounts)
   class Discount < StripeObject
     OBJECT_NAME = "discount"
+    def self.object_name
+      "discount"
+    end
   end
 end

data/lib/stripe/resources/dispute.rb

@@ -2,18 +2,56 @@
 # frozen_string_literal: true
 
 module Stripe
+  # A dispute occurs when a customer questions your charge with their card issuer.
+  # When this happens, you have the opportunity to respond to the dispute with
+  # evidence that shows that the charge is legitimate.
+  #
+  # Related guide: [Disputes and fraud](https://stripe.com/docs/disputes)
   class Dispute < APIResource
     extend Stripe::APIOperations::List
     include Stripe::APIOperations::Save
 
     OBJECT_NAME = "dispute"
+    def self.object_name
+      "dispute"
+    end
 
-    custom_method :close, http_verb: :post
-
+    # Closing the dispute for a charge indicates that you do not have any evidence to submit and are essentially dismissing the dispute, acknowledging it as lost.
+    #
+    # The status of the dispute will change from needs_response to lost. Closing a dispute is irreversible.
     def close(params = {}, opts = {})
       request_stripe_object(
         method: :post,
-        path: resource_url + "/close",
+        path: format("/v1/disputes/%<dispute>s/close", { dispute: CGI.escape(self["id"]) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Closing the dispute for a charge indicates that you do not have any evidence to submit and are essentially dismissing the dispute, acknowledging it as lost.
+    #
+    # The status of the dispute will change from needs_response to lost. Closing a dispute is irreversible.
+    def self.close(dispute, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/disputes/%<dispute>s/close", { dispute: CGI.escape(dispute) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Returns a list of your disputes.
+    def self.list(params = {}, opts = {})
+      request_stripe_object(method: :get, path: "/v1/disputes", params: params, opts: opts)
+    end
+
+    # When you get a dispute, contacting your customer is always the best first step. If that doesn't work, you can submit evidence to help us resolve the dispute in your favor. You can do this in your [dashboard](https://dashboard.stripe.com/disputes), but if you prefer, you can use the API to submit evidence programmatically.
+    #
+    # Depending on your dispute type, different evidence fields will give you a better chance of winning your dispute. To figure out which evidence fields to provide, see our [guide to dispute types](https://stripe.com/docs/disputes/categories).
+    def self.update(dispute, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/disputes/%<dispute>s", { dispute: CGI.escape(dispute) }),
         params: params,
         opts: opts
       )

data/lib/stripe/resources/entitlements/active_entitlement.rb

@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module Entitlements
+    # An active entitlement describes access to a feature for a customer.
+    class ActiveEntitlement < APIResource
+      extend Stripe::APIOperations::List
+
+      OBJECT_NAME = "entitlements.active_entitlement"
+      def self.object_name
+        "entitlements.active_entitlement"
+      end
+
+      # Retrieve a list of active entitlements for a customer
+      def self.list(params = {}, opts = {})
+        request_stripe_object(
+          method: :get,
+          path: "/v1/entitlements/active_entitlements",
+          params: params,
+          opts: opts
+        )
+      end
+    end
+  end
+end

data/lib/stripe/resources/entitlements/feature.rb

@@ -0,0 +1,49 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module Entitlements
+    # A feature represents a monetizable ability or functionality in your system.
+    # Features can be assigned to products, and when those products are purchased, Stripe will create an entitlement to the feature for the purchasing customer.
+    class Feature < APIResource
+      extend Stripe::APIOperations::Create
+      extend Stripe::APIOperations::List
+      include Stripe::APIOperations::Save
+
+      OBJECT_NAME = "entitlements.feature"
+      def self.object_name
+        "entitlements.feature"
+      end
+
+      # Creates a feature
+      def self.create(params = {}, opts = {})
+        request_stripe_object(
+          method: :post,
+          path: "/v1/entitlements/features",
+          params: params,
+          opts: opts
+        )
+      end
+
+      # Retrieve a list of features
+      def self.list(params = {}, opts = {})
+        request_stripe_object(
+          method: :get,
+          path: "/v1/entitlements/features",
+          params: params,
+          opts: opts
+        )
+      end
+
+      # Update a feature's metadata or permanently deactivate it.
+      def self.update(id, params = {}, opts = {})
+        request_stripe_object(
+          method: :post,
+          path: format("/v1/entitlements/features/%<id>s", { id: CGI.escape(id) }),
+          params: params,
+          opts: opts
+        )
+      end
+    end
+  end
+end

data/lib/stripe/resources/ephemeral_key.rb

@@ -7,6 +7,29 @@ module Stripe
     include Stripe::APIOperations::Delete
 
     OBJECT_NAME = "ephemeral_key"
+    def self.object_name
+      "ephemeral_key"
+    end
+
+    # Invalidates a short-lived API key for a given resource.
+    def self.delete(key, params = {}, opts = {})
+      request_stripe_object(
+        method: :delete,
+        path: format("/v1/ephemeral_keys/%<key>s", { key: CGI.escape(key) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # Invalidates a short-lived API key for a given resource.
+    def delete(params = {}, opts = {})
+      request_stripe_object(
+        method: :delete,
+        path: format("/v1/ephemeral_keys/%<key>s", { key: CGI.escape(self["id"]) }),
+        params: params,
+        opts: opts
+      )
+    end
 
     def self.create(params = {}, opts = {})
       opts = Util.normalize_opts(opts)

data/lib/stripe/resources/event.rb

@@ -2,9 +2,47 @@
 # frozen_string_literal: true
 
 module Stripe
+  # Events are our way of letting you know when something interesting happens in
+  # your account. When an interesting event occurs, we create a new `Event`
+  # object. For example, when a charge succeeds, we create a `charge.succeeded`
+  # event, and when an invoice payment attempt fails, we create an
+  # `invoice.payment_failed` event. Certain API requests might create multiple
+  # events. For example, if you create a new subscription for a
+  # customer, you receive both a `customer.subscription.created` event and a
+  # `charge.succeeded` event.
+  #
+  # Events occur when the state of another API resource changes. The event's data
+  # field embeds the resource's state at the time of the change. For
+  # example, a `charge.succeeded` event contains a charge, and an
+  # `invoice.payment_failed` event contains an invoice.
+  #
+  # As with other API resources, you can use endpoints to retrieve an
+  # [individual event](https://stripe.com/docs/api#retrieve_event) or a [list of events](https://stripe.com/docs/api#list_events)
+  # from the API. We also have a separate
+  # [webhooks](http://en.wikipedia.org/wiki/Webhook) system for sending the
+  # `Event` objects directly to an endpoint on your server. You can manage
+  # webhooks in your
+  # [account settings](https://dashboard.stripe.com/account/webhooks). Learn how
+  # to [listen for events](https://docs.stripe.com/webhooks)
+  # so that your integration can automatically trigger reactions.
+  #
+  # When using [Connect](https://docs.stripe.com/connect), you can also receive event notifications
+  # that occur in connected accounts. For these events, there's an
+  # additional `account` attribute in the received `Event` object.
+  #
+  # We only guarantee access to events through the [Retrieve Event API](https://stripe.com/docs/api#retrieve_event)
+  # for 30 days.
   class Event < APIResource
     extend Stripe::APIOperations::List
 
     OBJECT_NAME = "event"
+    def self.object_name
+      "event"
+    end
+
+    # List events, going back up to 30 days. Each event data is rendered according to Stripe API version at its creation time, specified in [event object](https://docs.stripe.com/api/events/object) api_version attribute (not according to your current Stripe API version or Stripe-Version header).
+    def self.list(params = {}, opts = {})
+      request_stripe_object(method: :get, path: "/v1/events", params: params, opts: opts)
+    end
   end
 end