stripe 13.4.0 → 13.5.0.pre.beta.1

data/rbi/stripe/services/treasury/received_debit_service.rbi

@@ -0,0 +1,59 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module Treasury
+    class ReceivedDebitService < StripeService
+      class ListParams < Stripe::RequestParams
+        # A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with `obj_bar`, your subsequent call can include `ending_before=obj_bar` in order to fetch the previous page of the list.
+        sig { returns(String) }
+        attr_accessor :ending_before
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T::Array[String]) }
+        attr_accessor :expand
+        # The FinancialAccount that funds were pulled from.
+        sig { returns(String) }
+        attr_accessor :financial_account
+        # A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
+        sig { returns(Integer) }
+        attr_accessor :limit
+        # A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with `obj_foo`, your subsequent call can include `starting_after=obj_foo` in order to fetch the next page of the list.
+        sig { returns(String) }
+        attr_accessor :starting_after
+        # Only return ReceivedDebits that have the given status: `succeeded` or `failed`.
+        sig { returns(String) }
+        attr_accessor :status
+        sig {
+          params(ending_before: String, expand: T::Array[String], financial_account: String, limit: Integer, starting_after: String, status: String).void
+         }
+        def initialize(
+          ending_before: nil,
+          expand: nil,
+          financial_account: nil,
+          limit: nil,
+          starting_after: nil,
+          status: nil
+        ); end
+      end
+      class RetrieveParams < Stripe::RequestParams
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T::Array[String]) }
+        attr_accessor :expand
+        sig { params(expand: T::Array[String]).void }
+        def initialize(expand: nil); end
+      end
+      # Returns a list of ReceivedDebits.
+      sig {
+        params(params: T.any(::Stripe::Treasury::ReceivedDebitService::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
+       }
+      def list(params = {}, opts = {}); end
+
+      # Retrieves the details of an existing ReceivedDebit by passing the unique ReceivedDebit ID from the ReceivedDebit list
+      sig {
+        params(id: String, params: T.any(::Stripe::Treasury::ReceivedDebitService::RetrieveParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Treasury::ReceivedDebit)
+       }
+      def retrieve(id, params = {}, opts = {}); end
+    end
+  end
+end

data/rbi/stripe/services/treasury/transaction_entry_service.rbi

@@ -0,0 +1,107 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module Treasury
+    class TransactionEntryService < StripeService
+      class ListParams < Stripe::RequestParams
+        class Created < Stripe::RequestParams
+          # Minimum value to filter by (exclusive)
+          sig { returns(Integer) }
+          attr_accessor :gt
+          # Minimum value to filter by (inclusive)
+          sig { returns(Integer) }
+          attr_accessor :gte
+          # Maximum value to filter by (exclusive)
+          sig { returns(Integer) }
+          attr_accessor :lt
+          # Maximum value to filter by (inclusive)
+          sig { returns(Integer) }
+          attr_accessor :lte
+          sig { params(gt: Integer, gte: Integer, lt: Integer, lte: Integer).void }
+          def initialize(gt: nil, gte: nil, lt: nil, lte: nil); end
+        end
+        class EffectiveAt < Stripe::RequestParams
+          # Minimum value to filter by (exclusive)
+          sig { returns(Integer) }
+          attr_accessor :gt
+          # Minimum value to filter by (inclusive)
+          sig { returns(Integer) }
+          attr_accessor :gte
+          # Maximum value to filter by (exclusive)
+          sig { returns(Integer) }
+          attr_accessor :lt
+          # Maximum value to filter by (inclusive)
+          sig { returns(Integer) }
+          attr_accessor :lte
+          sig { params(gt: Integer, gte: Integer, lt: Integer, lte: Integer).void }
+          def initialize(gt: nil, gte: nil, lt: nil, lte: nil); end
+        end
+        # Only return TransactionEntries that were created during the given date interval.
+        sig {
+          returns(T.any(::Stripe::Treasury::TransactionEntryService::ListParams::Created, Integer))
+         }
+        attr_accessor :created
+        # Attribute for param field effective_at
+        sig {
+          returns(T.any(::Stripe::Treasury::TransactionEntryService::ListParams::EffectiveAt, Integer))
+         }
+        attr_accessor :effective_at
+        # A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with `obj_bar`, your subsequent call can include `ending_before=obj_bar` in order to fetch the previous page of the list.
+        sig { returns(String) }
+        attr_accessor :ending_before
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T::Array[String]) }
+        attr_accessor :expand
+        # Returns objects associated with this FinancialAccount.
+        sig { returns(String) }
+        attr_accessor :financial_account
+        # A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
+        sig { returns(Integer) }
+        attr_accessor :limit
+        # The results are in reverse chronological order by `created` or `effective_at`. The default is `created`.
+        sig { returns(String) }
+        attr_accessor :order_by
+        # A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with `obj_foo`, your subsequent call can include `starting_after=obj_foo` in order to fetch the next page of the list.
+        sig { returns(String) }
+        attr_accessor :starting_after
+        # Only return TransactionEntries associated with this Transaction.
+        sig { returns(String) }
+        attr_accessor :transaction
+        sig {
+          params(created: T.any(::Stripe::Treasury::TransactionEntryService::ListParams::Created, Integer), effective_at: T.any(::Stripe::Treasury::TransactionEntryService::ListParams::EffectiveAt, Integer), ending_before: String, expand: T::Array[String], financial_account: String, limit: Integer, order_by: String, starting_after: String, transaction: String).void
+         }
+        def initialize(
+          created: nil,
+          effective_at: nil,
+          ending_before: nil,
+          expand: nil,
+          financial_account: nil,
+          limit: nil,
+          order_by: nil,
+          starting_after: nil,
+          transaction: nil
+        ); end
+      end
+      class RetrieveParams < Stripe::RequestParams
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T::Array[String]) }
+        attr_accessor :expand
+        sig { params(expand: T::Array[String]).void }
+        def initialize(expand: nil); end
+      end
+      # Retrieves a list of TransactionEntry objects.
+      sig {
+        params(params: T.any(::Stripe::Treasury::TransactionEntryService::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
+       }
+      def list(params = {}, opts = {}); end
+
+      # Retrieves a TransactionEntry object.
+      sig {
+        params(id: String, params: T.any(::Stripe::Treasury::TransactionEntryService::RetrieveParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Treasury::TransactionEntry)
+       }
+      def retrieve(id, params = {}, opts = {}); end
+    end
+  end
+end

data/rbi/stripe/services/treasury/transaction_service.rbi

@@ -0,0 +1,114 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module Treasury
+    class TransactionService < StripeService
+      class ListParams < Stripe::RequestParams
+        class Created < Stripe::RequestParams
+          # Minimum value to filter by (exclusive)
+          sig { returns(Integer) }
+          attr_accessor :gt
+          # Minimum value to filter by (inclusive)
+          sig { returns(Integer) }
+          attr_accessor :gte
+          # Maximum value to filter by (exclusive)
+          sig { returns(Integer) }
+          attr_accessor :lt
+          # Maximum value to filter by (inclusive)
+          sig { returns(Integer) }
+          attr_accessor :lte
+          sig { params(gt: Integer, gte: Integer, lt: Integer, lte: Integer).void }
+          def initialize(gt: nil, gte: nil, lt: nil, lte: nil); end
+        end
+        class StatusTransitions < Stripe::RequestParams
+          class PostedAt < Stripe::RequestParams
+            # Minimum value to filter by (exclusive)
+            sig { returns(Integer) }
+            attr_accessor :gt
+            # Minimum value to filter by (inclusive)
+            sig { returns(Integer) }
+            attr_accessor :gte
+            # Maximum value to filter by (exclusive)
+            sig { returns(Integer) }
+            attr_accessor :lt
+            # Maximum value to filter by (inclusive)
+            sig { returns(Integer) }
+            attr_accessor :lte
+            sig { params(gt: Integer, gte: Integer, lt: Integer, lte: Integer).void }
+            def initialize(gt: nil, gte: nil, lt: nil, lte: nil); end
+          end
+          # Returns Transactions with `posted_at` within the specified range.
+          sig {
+            returns(T.any(::Stripe::Treasury::TransactionService::ListParams::StatusTransitions::PostedAt, Integer))
+           }
+          attr_accessor :posted_at
+          sig {
+            params(posted_at: T.any(::Stripe::Treasury::TransactionService::ListParams::StatusTransitions::PostedAt, Integer)).void
+           }
+          def initialize(posted_at: nil); end
+        end
+        # Only return Transactions that were created during the given date interval.
+        sig { returns(T.any(::Stripe::Treasury::TransactionService::ListParams::Created, Integer)) }
+        attr_accessor :created
+        # A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with `obj_bar`, your subsequent call can include `ending_before=obj_bar` in order to fetch the previous page of the list.
+        sig { returns(String) }
+        attr_accessor :ending_before
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T::Array[String]) }
+        attr_accessor :expand
+        # Returns objects associated with this FinancialAccount.
+        sig { returns(String) }
+        attr_accessor :financial_account
+        # A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
+        sig { returns(Integer) }
+        attr_accessor :limit
+        # The results are in reverse chronological order by `created` or `posted_at`. The default is `created`.
+        sig { returns(String) }
+        attr_accessor :order_by
+        # A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with `obj_foo`, your subsequent call can include `starting_after=obj_foo` in order to fetch the next page of the list.
+        sig { returns(String) }
+        attr_accessor :starting_after
+        # Only return Transactions that have the given status: `open`, `posted`, or `void`.
+        sig { returns(String) }
+        attr_accessor :status
+        # A filter for the `status_transitions.posted_at` timestamp. When using this filter, `status=posted` and `order_by=posted_at` must also be specified.
+        sig { returns(::Stripe::Treasury::TransactionService::ListParams::StatusTransitions) }
+        attr_accessor :status_transitions
+        sig {
+          params(created: T.any(::Stripe::Treasury::TransactionService::ListParams::Created, Integer), ending_before: String, expand: T::Array[String], financial_account: String, limit: Integer, order_by: String, starting_after: String, status: String, status_transitions: ::Stripe::Treasury::TransactionService::ListParams::StatusTransitions).void
+         }
+        def initialize(
+          created: nil,
+          ending_before: nil,
+          expand: nil,
+          financial_account: nil,
+          limit: nil,
+          order_by: nil,
+          starting_after: nil,
+          status: nil,
+          status_transitions: nil
+        ); end
+      end
+      class RetrieveParams < Stripe::RequestParams
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T::Array[String]) }
+        attr_accessor :expand
+        sig { params(expand: T::Array[String]).void }
+        def initialize(expand: nil); end
+      end
+      # Retrieves a list of Transaction objects.
+      sig {
+        params(params: T.any(::Stripe::Treasury::TransactionService::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
+       }
+      def list(params = {}, opts = {}); end
+
+      # Retrieves the details of an existing Transaction.
+      sig {
+        params(id: String, params: T.any(::Stripe::Treasury::TransactionService::RetrieveParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Treasury::Transaction)
+       }
+      def retrieve(id, params = {}, opts = {}); end
+    end
+  end
+end

data/rbi/stripe/services/treasury_service.rbi

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  class TreasuryService < StripeService
+    attr_reader :credit_reversals
+    attr_reader :debit_reversals
+    attr_reader :financial_accounts
+    attr_reader :inbound_transfers
+    attr_reader :outbound_payments
+    attr_reader :outbound_transfers
+    attr_reader :received_credits
+    attr_reader :received_debits
+    attr_reader :transactions
+    attr_reader :transaction_entries
+  end
+end

data/rbi/stripe/services/v1_services.rbi

@@ -0,0 +1,83 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  class V1Services < StripeService
+    attr_reader :accounts
+    attr_reader :account_links
+    attr_reader :account_notices
+    attr_reader :account_sessions
+    attr_reader :apple_pay_domains
+    attr_reader :application_fees
+    attr_reader :apps
+    attr_reader :balance
+    attr_reader :balance_transactions
+    attr_reader :billing
+    attr_reader :billing_portal
+    attr_reader :capital
+    attr_reader :charges
+    attr_reader :checkout
+    attr_reader :climate
+    attr_reader :confirmation_tokens
+    attr_reader :test_helpers
+    attr_reader :country_specs
+    attr_reader :coupons
+    attr_reader :credit_notes
+    attr_reader :customers
+    attr_reader :customer_sessions
+    attr_reader :disputes
+    attr_reader :entitlements
+    attr_reader :ephemeral_keys
+    attr_reader :events
+    attr_reader :exchange_rates
+    attr_reader :files
+    attr_reader :file_links
+    attr_reader :financial_connections
+    attr_reader :forwarding
+    attr_reader :gift_cards
+    attr_reader :identity
+    attr_reader :invoices
+    attr_reader :invoice_rendering_templates
+    attr_reader :invoice_items
+    attr_reader :issuing
+    attr_reader :mandates
+    attr_reader :margins
+    attr_reader :orders
+    attr_reader :payment_attempt_records
+    attr_reader :payment_intents
+    attr_reader :payment_links
+    attr_reader :payment_methods
+    attr_reader :payment_method_configurations
+    attr_reader :payment_method_domains
+    attr_reader :payment_records
+    attr_reader :payouts
+    attr_reader :plans
+    attr_reader :prices
+    attr_reader :products
+    attr_reader :promotion_codes
+    attr_reader :quotes
+    attr_reader :radar
+    attr_reader :refunds
+    attr_reader :reporting
+    attr_reader :reviews
+    attr_reader :sigma
+    attr_reader :setup_attempts
+    attr_reader :setup_intents
+    attr_reader :shipping_rates
+    attr_reader :sources
+    attr_reader :subscriptions
+    attr_reader :subscription_items
+    attr_reader :subscription_schedules
+    attr_reader :tax
+    attr_reader :tax_codes
+    attr_reader :tax_ids
+    attr_reader :tax_rates
+    attr_reader :terminal
+    attr_reader :tokens
+    attr_reader :topups
+    attr_reader :transfers
+    attr_reader :treasury
+    attr_reader :webhook_endpoints
+  end
+end

data/rbi/stripe/services/v2/billing/meter_event_adjustment_service.rbi

@@ -0,0 +1,39 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module V2
+    module Billing
+      class MeterEventAdjustmentService < StripeService
+        class CreateParams < Stripe::RequestParams
+          class Cancel < Stripe::RequestParams
+            # Unique identifier for the event. You can only cancel events within 24 hours of Stripe receiving them.
+            sig { returns(String) }
+            attr_accessor :identifier
+            sig { params(identifier: String).void }
+            def initialize(identifier: nil); end
+          end
+          # Specifies which event to cancel.
+          sig { returns(::Stripe::V2::Billing::MeterEventAdjustmentService::CreateParams::Cancel) }
+          attr_accessor :cancel
+          # The name of the meter event. Corresponds with the `event_name` field on a meter.
+          sig { returns(String) }
+          attr_accessor :event_name
+          # Specifies whether to cancel a single event or a range of events for a time period. Time period cancellation is not supported yet.
+          sig { returns(String) }
+          attr_accessor :type
+          sig {
+            params(cancel: ::Stripe::V2::Billing::MeterEventAdjustmentService::CreateParams::Cancel, event_name: String, type: String).void
+           }
+          def initialize(cancel: nil, event_name: nil, type: nil); end
+        end
+        # Creates a meter event adjustment to cancel a previously sent meter event.
+        sig {
+          params(params: T.any(::Stripe::V2::Billing::MeterEventAdjustmentService::CreateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::V2::Billing::MeterEventAdjustment)
+         }
+        def create(params = {}, opts = {}); end
+      end
+    end
+  end
+end

data/rbi/stripe/services/v2/billing/meter_event_service.rbi

@@ -0,0 +1,42 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module V2
+    module Billing
+      class MeterEventService < StripeService
+        class CreateParams < Stripe::RequestParams
+          # The name of the meter event. Corresponds with the `event_name` field on a meter.
+          sig { returns(String) }
+          attr_accessor :event_name
+          # A unique identifier for the event. If not provided, one will be generated.
+          # We recommend using a globally unique identifier for this. We’ll enforce
+          # uniqueness within a rolling 24 hour period.
+          sig { returns(String) }
+          attr_accessor :identifier
+          # The payload of the event. This must contain the fields corresponding to a meter’s
+          # `customer_mapping.event_payload_key` (default is `stripe_customer_id`) and
+          # `value_settings.event_payload_key` (default is `value`). Read more about
+          # the
+          # [payload](https://docs.stripe.com/billing/subscriptions/usage-based/recording-usage#payload-key-overrides).
+          sig { returns(T::Hash[String, String]) }
+          attr_accessor :payload
+          # The time of the event. Must be within the past 35 calendar days or up to
+          # 5 minutes in the future. Defaults to current timestamp if not specified.
+          sig { returns(String) }
+          attr_accessor :timestamp
+          sig {
+            params(event_name: String, identifier: String, payload: T::Hash[String, String], timestamp: String).void
+           }
+          def initialize(event_name: nil, identifier: nil, payload: nil, timestamp: nil); end
+        end
+        # Creates a meter event. Events are validated synchronously, but are processed asynchronously. Supports up to 1,000 events per second in livemode. For higher rate-limits, please use meter event streams instead.
+        sig {
+          params(params: T.any(::Stripe::V2::Billing::MeterEventService::CreateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::V2::Billing::MeterEvent)
+         }
+        def create(params = {}, opts = {}); end
+      end
+    end
+  end
+end

data/rbi/stripe/services/v2/billing/meter_event_session_service.rbi

@@ -0,0 +1,20 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module V2
+    module Billing
+      class MeterEventSessionService < StripeService
+        class CreateParams < Stripe::RequestParams
+
+        end
+        # Creates a meter event session to send usage on the high-throughput meter event stream. Authentication tokens are only valid for 15 minutes, so you will need to create a new meter event session when your token expires.
+        sig {
+          params(params: T.any(::Stripe::V2::Billing::MeterEventSessionService::CreateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::V2::Billing::MeterEventSession)
+         }
+        def create(params = {}, opts = {}); end
+      end
+    end
+  end
+end

data/rbi/stripe/services/v2/billing/meter_event_stream_service.rbi

@@ -0,0 +1,55 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module V2
+    module Billing
+      class MeterEventStreamService < StripeService
+        class CreateParams < Stripe::RequestParams
+          class Event < Stripe::RequestParams
+            # The name of the meter event. Corresponds with the `event_name` field on a meter.
+            sig { returns(String) }
+            attr_accessor :event_name
+            # A unique identifier for the event. If not provided, one will be generated.
+            # We recommend using a globally unique identifier for this. We’ll enforce
+            # uniqueness within a rolling 24 hour period.
+            sig { returns(String) }
+            attr_accessor :identifier
+            # The payload of the event. This must contain the fields corresponding to a meter’s
+            # `customer_mapping.event_payload_key` (default is `stripe_customer_id`) and
+            # `value_settings.event_payload_key` (default is `value`). Read more about
+            # the
+            # [payload](https://docs.stripe.com/billing/subscriptions/usage-based/recording-usage#payload-key-overrides).
+            sig { returns(T::Hash[String, String]) }
+            attr_accessor :payload
+            # The time of the event. Must be within the past 35 calendar days or up to
+            # 5 minutes in the future. Defaults to current timestamp if not specified.
+            sig { returns(String) }
+            attr_accessor :timestamp
+            sig {
+              params(event_name: String, identifier: String, payload: T::Hash[String, String], timestamp: String).void
+             }
+            def initialize(event_name: nil, identifier: nil, payload: nil, timestamp: nil); end
+          end
+          # List of meter events to include in the request.
+          sig {
+            returns(T::Array[::Stripe::V2::Billing::MeterEventStreamService::CreateParams::Event])
+           }
+          attr_accessor :events
+          sig {
+            params(events: T::Array[::Stripe::V2::Billing::MeterEventStreamService::CreateParams::Event]).void
+           }
+          def initialize(events: nil); end
+        end
+        # Creates meter events. Events are processed asynchronously, including validation. Requires a meter event session for authentication. Supports up to 10,000 requests per second in livemode. For even higher rate-limits, contact sales.
+        #
+        # ** raises TemporarySessionExpiredError
+        sig {
+          params(params: T.any(::Stripe::V2::Billing::MeterEventStreamService::CreateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).void
+         }
+        def create(params = {}, opts = {}); end
+      end
+    end
+  end
+end

data/rbi/stripe/services/v2/billing_service.rbi

@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module V2
+    class BillingService < StripeService
+      attr_reader :meter_event_session
+      attr_reader :meter_event_adjustments
+      attr_reader :meter_event_stream
+      attr_reader :meter_events
+    end
+  end
+end