stripe 14.1.0.pre.beta.1 → 15.0.0

data/rbi/stripe/resources/reporting/report_run.rbi

@@ -0,0 +1,191 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module Reporting
+    # The Report Run object represents an instance of a report type generated with
+    # specific run parameters. Once the object is created, Stripe begins processing the report.
+    # When the report has finished running, it will give you a reference to a file
+    # where you can retrieve your results. For an overview, see
+    # [API Access to Reports](https://stripe.com/docs/reporting/statements/api).
+    #
+    # Note that certain report types can only be run based on your live-mode data (not test-mode
+    # data), and will error when queried without a [live-mode API key](https://stripe.com/docs/keys#test-live-modes).
+    class ReportRun < APIResource
+      class Parameters < Stripe::StripeObject
+        # The set of output columns requested for inclusion in the report run.
+        sig { returns(T::Array[String]) }
+        attr_reader :columns
+        # Connected account ID by which to filter the report run.
+        sig { returns(String) }
+        attr_reader :connected_account
+        # Currency of objects to be included in the report run.
+        sig { returns(String) }
+        attr_reader :currency
+        # Ending timestamp of data to be included in the report run. Can be any UTC timestamp between 1 second after the user specified `interval_start` and 1 second before this report's last `data_available_end` value.
+        sig { returns(Integer) }
+        attr_reader :interval_end
+        # Starting timestamp of data to be included in the report run. Can be any UTC timestamp between 1 second after this report's `data_available_start` and 1 second before the user specified `interval_end` value.
+        sig { returns(Integer) }
+        attr_reader :interval_start
+        # Payout ID by which to filter the report run.
+        sig { returns(String) }
+        attr_reader :payout
+        # Category of balance transactions to be included in the report run.
+        sig { returns(String) }
+        attr_reader :reporting_category
+        # Defaults to `Etc/UTC`. The output timezone for all timestamps in the report. A list of possible time zone values is maintained at the [IANA Time Zone Database](http://www.iana.org/time-zones). Has no effect on `interval_start` or `interval_end`.
+        sig { returns(String) }
+        attr_reader :timezone
+      end
+      # Time at which the object was created. Measured in seconds since the Unix epoch.
+      sig { returns(Integer) }
+      attr_reader :created
+      # If something should go wrong during the run, a message about the failure (populated when
+      #  `status=failed`).
+      sig { returns(T.nilable(String)) }
+      attr_reader :error
+      # Unique identifier for the object.
+      sig { returns(String) }
+      attr_reader :id
+      # `true` if the report is run on live mode data and `false` if it is run on test mode data.
+      sig { returns(T::Boolean) }
+      attr_reader :livemode
+      # String representing the object's type. Objects of the same type share the same value.
+      sig { returns(String) }
+      attr_reader :object
+      # Attribute for field parameters
+      sig { returns(Parameters) }
+      attr_reader :parameters
+      # The ID of the [report type](https://stripe.com/docs/reports/report-types) to run, such as `"balance.summary.1"`.
+      sig { returns(String) }
+      attr_reader :report_type
+      # The file object representing the result of the report run (populated when
+      #  `status=succeeded`).
+      sig { returns(T.nilable(Stripe::File)) }
+      attr_reader :result
+      # Status of this report run. This will be `pending` when the run is initially created.
+      #  When the run finishes, this will be set to `succeeded` and the `result` field will be populated.
+      #  Rarely, we may encounter an error, at which point this will be set to `failed` and the `error` field will be populated.
+      sig { returns(String) }
+      attr_reader :status
+      # Timestamp at which this run successfully finished (populated when
+      #  `status=succeeded`). Measured in seconds since the Unix epoch.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :succeeded_at
+      class ListParams < Stripe::RequestParams
+        class Created < Stripe::RequestParams
+          # Minimum value to filter by (exclusive)
+          sig { returns(T.nilable(Integer)) }
+          attr_accessor :gt
+          # Minimum value to filter by (inclusive)
+          sig { returns(T.nilable(Integer)) }
+          attr_accessor :gte
+          # Maximum value to filter by (exclusive)
+          sig { returns(T.nilable(Integer)) }
+          attr_accessor :lt
+          # Maximum value to filter by (inclusive)
+          sig { returns(T.nilable(Integer)) }
+          attr_accessor :lte
+          sig {
+            params(gt: T.nilable(Integer), gte: T.nilable(Integer), lt: T.nilable(Integer), lte: T.nilable(Integer)).void
+           }
+          def initialize(gt: nil, gte: nil, lt: nil, lte: nil); end
+        end
+        # Only return Report Runs that were created during the given date interval.
+        sig {
+          returns(T.nilable(T.any(::Stripe::Reporting::ReportRun::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(T.nilable(String)) }
+        attr_accessor :ending_before
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_accessor :expand
+        # A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
+        sig { returns(T.nilable(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(T.nilable(String)) }
+        attr_accessor :starting_after
+        sig {
+          params(created: T.nilable(T.any(::Stripe::Reporting::ReportRun::ListParams::Created, Integer)), ending_before: T.nilable(String), expand: T.nilable(T::Array[String]), limit: T.nilable(Integer), starting_after: T.nilable(String)).void
+         }
+        def initialize(
+          created: nil,
+          ending_before: nil,
+          expand: nil,
+          limit: nil,
+          starting_after: nil
+        ); end
+      end
+      class CreateParams < Stripe::RequestParams
+        class Parameters < Stripe::RequestParams
+          # The set of report columns to include in the report output. If omitted, the Report Type is run with its default column set.
+          sig { returns(T.nilable(T::Array[String])) }
+          attr_accessor :columns
+          # Connected account ID to filter for in the report run.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :connected_account
+          # Currency of objects to be included in the report run.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :currency
+          # Ending timestamp of data to be included in the report run (exclusive).
+          sig { returns(T.nilable(Integer)) }
+          attr_accessor :interval_end
+          # Starting timestamp of data to be included in the report run.
+          sig { returns(T.nilable(Integer)) }
+          attr_accessor :interval_start
+          # Payout ID by which to filter the report run.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :payout
+          # Category of balance transactions to be included in the report run.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :reporting_category
+          # Defaults to `Etc/UTC`. The output timezone for all timestamps in the report. A list of possible time zone values is maintained at the [IANA Time Zone Database](http://www.iana.org/time-zones). Has no effect on `interval_start` or `interval_end`.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :timezone
+          sig {
+            params(columns: T.nilable(T::Array[String]), connected_account: T.nilable(String), currency: T.nilable(String), interval_end: T.nilable(Integer), interval_start: T.nilable(Integer), payout: T.nilable(String), reporting_category: T.nilable(String), timezone: T.nilable(String)).void
+           }
+          def initialize(
+            columns: nil,
+            connected_account: nil,
+            currency: nil,
+            interval_end: nil,
+            interval_start: nil,
+            payout: nil,
+            reporting_category: nil,
+            timezone: nil
+          ); end
+        end
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_accessor :expand
+        # Parameters specifying how the report should be run. Different Report Types have different required and optional parameters, listed in the [API Access to Reports](https://stripe.com/docs/reporting/statements/api) documentation.
+        sig { returns(T.nilable(::Stripe::Reporting::ReportRun::CreateParams::Parameters)) }
+        attr_accessor :parameters
+        # The ID of the [report type](https://stripe.com/docs/reporting/statements/api#report-types) to run, such as `"balance.summary.1"`.
+        sig { returns(String) }
+        attr_accessor :report_type
+        sig {
+          params(expand: T.nilable(T::Array[String]), parameters: T.nilable(::Stripe::Reporting::ReportRun::CreateParams::Parameters), report_type: String).void
+         }
+        def initialize(expand: nil, parameters: nil, report_type: nil); end
+      end
+      # Creates a new object and begin running the report. (Certain report types require a [live-mode API key](https://stripe.com/docs/keys#test-live-modes).)
+      sig {
+        params(params: T.any(::Stripe::Reporting::ReportRun::CreateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Reporting::ReportRun)
+       }
+      def self.create(params = {}, opts = {}); end
+
+      # Returns a list of Report Runs, with the most recent appearing first.
+      sig {
+        params(params: T.any(::Stripe::Reporting::ReportRun::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
+       }
+      def self.list(params = {}, opts = {}); end
+    end
+  end
+end

data/rbi/stripe/resources/reporting/report_type.rbi

@@ -0,0 +1,57 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module Reporting
+    # The Report Type resource corresponds to a particular type of report, such as
+    # the "Activity summary" or "Itemized payouts" reports. These objects are
+    # identified by an ID belonging to a set of enumerated values. See
+    # [API Access to Reports documentation](https://stripe.com/docs/reporting/statements/api)
+    # for those Report Type IDs, along with required and optional parameters.
+    #
+    # Note that certain report types can only be run based on your live-mode data (not test-mode
+    # data), and will error when queried without a [live-mode API key](https://stripe.com/docs/keys#test-live-modes).
+    class ReportType < APIResource
+      # Most recent time for which this Report Type is available. Measured in seconds since the Unix epoch.
+      sig { returns(Integer) }
+      attr_reader :data_available_end
+      # Earliest time for which this Report Type is available. Measured in seconds since the Unix epoch.
+      sig { returns(Integer) }
+      attr_reader :data_available_start
+      # List of column names that are included by default when this Report Type gets run. (If the Report Type doesn't support the `columns` parameter, this will be null.)
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :default_columns
+      # The [ID of the Report Type](https://stripe.com/docs/reporting/statements/api#available-report-types), such as `balance.summary.1`.
+      sig { returns(String) }
+      attr_reader :id
+      # Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
+      sig { returns(T::Boolean) }
+      attr_reader :livemode
+      # Human-readable name of the Report Type
+      sig { returns(String) }
+      attr_reader :name
+      # String representing the object's type. Objects of the same type share the same value.
+      sig { returns(String) }
+      attr_reader :object
+      # When this Report Type was latest updated. Measured in seconds since the Unix epoch.
+      sig { returns(Integer) }
+      attr_reader :updated
+      # Version of the Report Type. Different versions report with the same ID will have the same purpose, but may take different run parameters or have different result schemas.
+      sig { returns(Integer) }
+      attr_reader :version
+      class ListParams < Stripe::RequestParams
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_accessor :expand
+        sig { params(expand: T.nilable(T::Array[String])).void }
+        def initialize(expand: nil); end
+      end
+      # Returns a full list of Report Types.
+      sig {
+        params(params: T.any(::Stripe::Reporting::ReportType::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
+       }
+      def self.list(params = {}, opts = {}); end
+    end
+  end
+end

data/rbi/stripe/resources/reserve_transaction.rbi

@@ -0,0 +1,23 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  class ReserveTransaction < APIResource
+    # Attribute for field amount
+    sig { returns(Integer) }
+    attr_reader :amount
+    # Three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html), in lowercase. Must be a [supported currency](https://stripe.com/docs/currencies).
+    sig { returns(String) }
+    attr_reader :currency
+    # An arbitrary string attached to the object. Often useful for displaying to users.
+    sig { returns(T.nilable(String)) }
+    attr_reader :description
+    # Unique identifier for the object.
+    sig { returns(String) }
+    attr_reader :id
+    # String representing the object's type. Objects of the same type share the same value.
+    sig { returns(String) }
+    attr_reader :object
+  end
+end

data/rbi/stripe/resources/reversal.rbi

@@ -0,0 +1,51 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  # [Stripe Connect](https://stripe.com/docs/connect) platforms can reverse transfers made to a
+  # connected account, either entirely or partially, and can also specify whether
+  # to refund any related application fees. Transfer reversals add to the
+  # platform's balance and subtract from the destination account's balance.
+  #
+  # Reversing a transfer that was made for a [destination
+  # charge](https://stripe.com/docs/connect/destination-charges) is allowed only up to the amount of
+  # the charge. It is possible to reverse a
+  # [transfer_group](https://stripe.com/docs/connect/separate-charges-and-transfers#transfer-options)
+  # transfer only if the destination account has enough balance to cover the
+  # reversal.
+  #
+  # Related guide: [Reverse transfers](https://stripe.com/docs/connect/separate-charges-and-transfers#reverse-transfers)
+  class Reversal < APIResource
+    # Amount, in cents (or local equivalent).
+    sig { returns(Integer) }
+    attr_reader :amount
+    # Balance transaction that describes the impact on your account balance.
+    sig { returns(T.nilable(T.any(String, Stripe::BalanceTransaction))) }
+    attr_reader :balance_transaction
+    # Time at which the object was created. Measured in seconds since the Unix epoch.
+    sig { returns(Integer) }
+    attr_reader :created
+    # Three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html), in lowercase. Must be a [supported currency](https://stripe.com/docs/currencies).
+    sig { returns(String) }
+    attr_reader :currency
+    # Linked payment refund for the transfer reversal.
+    sig { returns(T.nilable(T.any(String, Stripe::Refund))) }
+    attr_reader :destination_payment_refund
+    # Unique identifier for the object.
+    sig { returns(String) }
+    attr_reader :id
+    # Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object. This can be useful for storing additional information about the object in a structured format.
+    sig { returns(T.nilable(T::Hash[String, String])) }
+    attr_reader :metadata
+    # String representing the object's type. Objects of the same type share the same value.
+    sig { returns(String) }
+    attr_reader :object
+    # ID of the refund responsible for the transfer reversal.
+    sig { returns(T.nilable(T.any(String, Stripe::Refund))) }
+    attr_reader :source_refund
+    # ID of the transfer that was reversed.
+    sig { returns(T.any(String, Stripe::Transfer)) }
+    attr_reader :transfer
+  end
+end

data/rbi/stripe/resources/review.rbi

@@ -0,0 +1,154 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  # Reviews can be used to supplement automated fraud detection with human expertise.
+  #
+  # Learn more about [Radar](https://stripe.com/radar) and reviewing payments
+  # [here](https://stripe.com/docs/radar/reviews).
+  class Review < APIResource
+    class IpAddressLocation < Stripe::StripeObject
+      # The city where the payment originated.
+      sig { returns(T.nilable(String)) }
+      attr_reader :city
+      # Two-letter ISO code representing the country where the payment originated.
+      sig { returns(T.nilable(String)) }
+      attr_reader :country
+      # The geographic latitude where the payment originated.
+      sig { returns(T.nilable(Float)) }
+      attr_reader :latitude
+      # The geographic longitude where the payment originated.
+      sig { returns(T.nilable(Float)) }
+      attr_reader :longitude
+      # The state/county/province/region where the payment originated.
+      sig { returns(T.nilable(String)) }
+      attr_reader :region
+    end
+    class Session < Stripe::StripeObject
+      # The browser used in this browser session (e.g., `Chrome`).
+      sig { returns(T.nilable(String)) }
+      attr_reader :browser
+      # Information about the device used for the browser session (e.g., `Samsung SM-G930T`).
+      sig { returns(T.nilable(String)) }
+      attr_reader :device
+      # The platform for the browser session (e.g., `Macintosh`).
+      sig { returns(T.nilable(String)) }
+      attr_reader :platform
+      # The version for the browser session (e.g., `61.0.3163.100`).
+      sig { returns(T.nilable(String)) }
+      attr_reader :version
+    end
+    # The ZIP or postal code of the card used, if applicable.
+    sig { returns(T.nilable(String)) }
+    attr_reader :billing_zip
+    # The charge associated with this review.
+    sig { returns(T.nilable(T.any(String, Stripe::Charge))) }
+    attr_reader :charge
+    # The reason the review was closed, or null if it has not yet been closed. One of `approved`, `refunded`, `refunded_as_fraud`, `disputed`, `redacted`, or `canceled`.
+    sig { returns(T.nilable(String)) }
+    attr_reader :closed_reason
+    # Time at which the object was created. Measured in seconds since the Unix epoch.
+    sig { returns(Integer) }
+    attr_reader :created
+    # Unique identifier for the object.
+    sig { returns(String) }
+    attr_reader :id
+    # The IP address where the payment originated.
+    sig { returns(T.nilable(String)) }
+    attr_reader :ip_address
+    # Information related to the location of the payment. Note that this information is an approximation and attempts to locate the nearest population center - it should not be used to determine a specific address.
+    sig { returns(T.nilable(IpAddressLocation)) }
+    attr_reader :ip_address_location
+    # Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
+    sig { returns(T::Boolean) }
+    attr_reader :livemode
+    # String representing the object's type. Objects of the same type share the same value.
+    sig { returns(String) }
+    attr_reader :object
+    # If `true`, the review needs action.
+    sig { returns(T::Boolean) }
+    attr_reader :open
+    # The reason the review was opened. One of `rule` or `manual`.
+    sig { returns(String) }
+    attr_reader :opened_reason
+    # The PaymentIntent ID associated with this review, if one exists.
+    sig { returns(T.any(String, Stripe::PaymentIntent)) }
+    attr_reader :payment_intent
+    # The reason the review is currently open or closed. One of `rule`, `manual`, `approved`, `refunded`, `refunded_as_fraud`, `disputed`, `redacted`, or `canceled`.
+    sig { returns(String) }
+    attr_reader :reason
+    # Information related to the browsing session of the user who initiated the payment.
+    sig { returns(T.nilable(Session)) }
+    attr_reader :session
+    class ListParams < Stripe::RequestParams
+      class Created < Stripe::RequestParams
+        # Minimum value to filter by (exclusive)
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :gt
+        # Minimum value to filter by (inclusive)
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :gte
+        # Maximum value to filter by (exclusive)
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :lt
+        # Maximum value to filter by (inclusive)
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :lte
+        sig {
+          params(gt: T.nilable(Integer), gte: T.nilable(Integer), lt: T.nilable(Integer), lte: T.nilable(Integer)).void
+         }
+        def initialize(gt: nil, gte: nil, lt: nil, lte: nil); end
+      end
+      # Only return reviews that were created during the given date interval.
+      sig { returns(T.nilable(T.any(::Stripe::Review::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(T.nilable(String)) }
+      attr_accessor :ending_before
+      # Specifies which fields in the response should be expanded.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :expand
+      # A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
+      sig { returns(T.nilable(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(T.nilable(String)) }
+      attr_accessor :starting_after
+      sig {
+        params(created: T.nilable(T.any(::Stripe::Review::ListParams::Created, Integer)), ending_before: T.nilable(String), expand: T.nilable(T::Array[String]), limit: T.nilable(Integer), starting_after: T.nilable(String)).void
+       }
+      def initialize(
+        created: nil,
+        ending_before: nil,
+        expand: nil,
+        limit: nil,
+        starting_after: nil
+      ); end
+    end
+    class ApproveParams < Stripe::RequestParams
+      # Specifies which fields in the response should be expanded.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :expand
+      sig { params(expand: T.nilable(T::Array[String])).void }
+      def initialize(expand: nil); end
+    end
+    # Approves a Review object, closing it and removing it from the list of reviews.
+    sig {
+      params(params: T.any(::Stripe::Review::ApproveParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Review)
+     }
+    def approve(params = {}, opts = {}); end
+
+    # Approves a Review object, closing it and removing it from the list of reviews.
+    sig {
+      params(review: String, params: T.any(::Stripe::Review::ApproveParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Review)
+     }
+    def self.approve(review, params = {}, opts = {}); end
+
+    # Returns a list of Review objects that have open set to true. The objects are sorted in descending order by creation date, with the most recently created object appearing first.
+    sig {
+      params(params: T.any(::Stripe::Review::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
+     }
+    def self.list(params = {}, opts = {}); end
+  end
+end