stripe 13.3.0 → 13.4.0.pre.beta.1

data/lib/stripe/services/apple_pay_domain_service.rb

@@ -3,6 +3,62 @@
 
 module Stripe
   class ApplePayDomainService < StripeService
+    class DeleteParams < Stripe::RequestParams
+    end
+
+    class RetrieveParams < Stripe::RequestParams
+      # Specifies which fields in the response should be expanded.
+      attr_accessor :expand
+
+      def initialize(expand: nil)
+        @expand = expand
+      end
+    end
+
+    class ListParams < Stripe::RequestParams
+      # Attribute for param field domain_name
+      attr_accessor :domain_name
+
+      # 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.
+      attr_accessor :ending_before
+
+      # Specifies which fields in the response should be expanded.
+      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.
+      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.
+      attr_accessor :starting_after
+
+      def initialize(
+        domain_name: nil,
+        ending_before: nil,
+        expand: nil,
+        limit: nil,
+        starting_after: nil
+      )
+        @domain_name = domain_name
+        @ending_before = ending_before
+        @expand = expand
+        @limit = limit
+        @starting_after = starting_after
+      end
+    end
+
+    class CreateParams < Stripe::RequestParams
+      # Attribute for param field domain_name
+      attr_accessor :domain_name
+
+      # Specifies which fields in the response should be expanded.
+      attr_accessor :expand
+
+      def initialize(domain_name: nil, expand: nil)
+        @domain_name = domain_name
+        @expand = expand
+      end
+    end
+
     # Create an apple pay domain.
     def create(params = {}, opts = {})
       request(

data/lib/stripe/services/application_fee_refund_service.rb

@@ -3,6 +3,66 @@
 
 module Stripe
   class ApplicationFeeRefundService < StripeService
+    class RetrieveParams < Stripe::RequestParams
+      # Specifies which fields in the response should be expanded.
+      attr_accessor :expand
+
+      def initialize(expand: nil)
+        @expand = expand
+      end
+    end
+
+    class UpdateParams < Stripe::RequestParams
+      # Specifies which fields in the response should be expanded.
+      attr_accessor :expand
+
+      # 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. Individual keys can be unset by posting an empty value to them. All keys can be unset by posting an empty value to `metadata`.
+      attr_accessor :metadata
+
+      def initialize(expand: nil, metadata: nil)
+        @expand = expand
+        @metadata = metadata
+      end
+    end
+
+    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.
+      attr_accessor :ending_before
+
+      # Specifies which fields in the response should be expanded.
+      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.
+      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.
+      attr_accessor :starting_after
+
+      def initialize(ending_before: nil, expand: nil, limit: nil, starting_after: nil)
+        @ending_before = ending_before
+        @expand = expand
+        @limit = limit
+        @starting_after = starting_after
+      end
+    end
+
+    class CreateParams < Stripe::RequestParams
+      # A positive integer, in _cents (or local equivalent)_, representing how much of this fee to refund. Can refund only up to the remaining unrefunded amount of the fee.
+      attr_accessor :amount
+
+      # Specifies which fields in the response should be expanded.
+      attr_accessor :expand
+
+      # 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. Individual keys can be unset by posting an empty value to them. All keys can be unset by posting an empty value to `metadata`.
+      attr_accessor :metadata
+
+      def initialize(amount: nil, expand: nil, metadata: nil)
+        @amount = amount
+        @expand = expand
+        @metadata = metadata
+      end
+    end
+
     # Refunds an application fee that has previously been collected but not yet refunded.
     # Funds will be refunded to the Stripe account from which the fee was originally collected.
     #

data/lib/stripe/services/application_fee_service.rb

@@ -10,6 +10,71 @@ module Stripe
       @refunds = Stripe::ApplicationFeeRefundService.new(@requestor)
     end
 
+    class ListParams < Stripe::RequestParams
+      class Created < Stripe::RequestParams
+        # Minimum value to filter by (exclusive)
+        attr_accessor :gt
+
+        # Minimum value to filter by (inclusive)
+        attr_accessor :gte
+
+        # Maximum value to filter by (exclusive)
+        attr_accessor :lt
+
+        # Maximum value to filter by (inclusive)
+        attr_accessor :lte
+
+        def initialize(gt: nil, gte: nil, lt: nil, lte: nil)
+          @gt = gt
+          @gte = gte
+          @lt = lt
+          @lte = lte
+        end
+      end
+      # Only return application fees for the charge specified by this charge ID.
+      attr_accessor :charge
+
+      # Only return applications fees that were created during the given date interval.
+      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.
+      attr_accessor :ending_before
+
+      # Specifies which fields in the response should be expanded.
+      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.
+      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.
+      attr_accessor :starting_after
+
+      def initialize(
+        charge: nil,
+        created: nil,
+        ending_before: nil,
+        expand: nil,
+        limit: nil,
+        starting_after: nil
+      )
+        @charge = charge
+        @created = created
+        @ending_before = ending_before
+        @expand = expand
+        @limit = limit
+        @starting_after = starting_after
+      end
+    end
+
+    class RetrieveParams < Stripe::RequestParams
+      # Specifies which fields in the response should be expanded.
+      attr_accessor :expand
+
+      def initialize(expand: nil)
+        @expand = expand
+      end
+    end
+
     # Returns a list of application fees you've previously collected. The application fees are returned in sorted order, with the most recent fees appearing first.
     def list(params = {}, opts = {})
       request(

data/lib/stripe/services/apps/secret_service.rb

@@ -4,6 +4,138 @@
 module Stripe
   module Apps
     class SecretService < StripeService
+      class ListParams < Stripe::RequestParams
+        class Scope < Stripe::RequestParams
+          # The secret scope type.
+          attr_accessor :type
+
+          # The user ID. This field is required if `type` is set to `user`, and should not be provided if `type` is set to `account`.
+          attr_accessor :user
+
+          def initialize(type: nil, user: nil)
+            @type = type
+            @user = user
+          end
+        end
+        # 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.
+        attr_accessor :ending_before
+
+        # Specifies which fields in the response should be expanded.
+        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.
+        attr_accessor :limit
+
+        # Specifies the scoping of the secret. Requests originating from UI extensions can only access account-scoped secrets or secrets scoped to their own user.
+        attr_accessor :scope
+
+        # 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.
+        attr_accessor :starting_after
+
+        def initialize(ending_before: nil, expand: nil, limit: nil, scope: nil, starting_after: nil)
+          @ending_before = ending_before
+          @expand = expand
+          @limit = limit
+          @scope = scope
+          @starting_after = starting_after
+        end
+      end
+
+      class CreateParams < Stripe::RequestParams
+        class Scope < Stripe::RequestParams
+          # The secret scope type.
+          attr_accessor :type
+
+          # The user ID. This field is required if `type` is set to `user`, and should not be provided if `type` is set to `account`.
+          attr_accessor :user
+
+          def initialize(type: nil, user: nil)
+            @type = type
+            @user = user
+          end
+        end
+        # Specifies which fields in the response should be expanded.
+        attr_accessor :expand
+
+        # The Unix timestamp for the expiry time of the secret, after which the secret deletes.
+        attr_accessor :expires_at
+
+        # A name for the secret that's unique within the scope.
+        attr_accessor :name
+
+        # The plaintext secret value to be stored.
+        attr_accessor :payload
+
+        # Specifies the scoping of the secret. Requests originating from UI extensions can only access account-scoped secrets or secrets scoped to their own user.
+        attr_accessor :scope
+
+        def initialize(expand: nil, expires_at: nil, name: nil, payload: nil, scope: nil)
+          @expand = expand
+          @expires_at = expires_at
+          @name = name
+          @payload = payload
+          @scope = scope
+        end
+      end
+
+      class FindParams < Stripe::RequestParams
+        class Scope < Stripe::RequestParams
+          # The secret scope type.
+          attr_accessor :type
+
+          # The user ID. This field is required if `type` is set to `user`, and should not be provided if `type` is set to `account`.
+          attr_accessor :user
+
+          def initialize(type: nil, user: nil)
+            @type = type
+            @user = user
+          end
+        end
+        # Specifies which fields in the response should be expanded.
+        attr_accessor :expand
+
+        # A name for the secret that's unique within the scope.
+        attr_accessor :name
+
+        # Specifies the scoping of the secret. Requests originating from UI extensions can only access account-scoped secrets or secrets scoped to their own user.
+        attr_accessor :scope
+
+        def initialize(expand: nil, name: nil, scope: nil)
+          @expand = expand
+          @name = name
+          @scope = scope
+        end
+      end
+
+      class DeleteWhereParams < Stripe::RequestParams
+        class Scope < Stripe::RequestParams
+          # The secret scope type.
+          attr_accessor :type
+
+          # The user ID. This field is required if `type` is set to `user`, and should not be provided if `type` is set to `account`.
+          attr_accessor :user
+
+          def initialize(type: nil, user: nil)
+            @type = type
+            @user = user
+          end
+        end
+        # Specifies which fields in the response should be expanded.
+        attr_accessor :expand
+
+        # A name for the secret that's unique within the scope.
+        attr_accessor :name
+
+        # Specifies the scoping of the secret. Requests originating from UI extensions can only access account-scoped secrets or secrets scoped to their own user.
+        attr_accessor :scope
+
+        def initialize(expand: nil, name: nil, scope: nil)
+          @expand = expand
+          @name = name
+          @scope = scope
+        end
+      end
+
       # Create or replace a secret in the secret store.
       def create(params = {}, opts = {})
         request(

data/lib/stripe/services/balance_service.rb

@@ -3,6 +3,15 @@
 
 module Stripe
   class BalanceService < StripeService
+    class RetrieveParams < Stripe::RequestParams
+      # Specifies which fields in the response should be expanded.
+      attr_accessor :expand
+
+      def initialize(expand: nil)
+        @expand = expand
+      end
+    end
+
     # Retrieves the current account balance, based on the authentication that was used to make the request.
     #  For a sample request, see [Accounting for negative balances](https://stripe.com/docs/connect/account-balances#accounting-for-negative-balances).
     def retrieve(params = {}, opts = {})

data/lib/stripe/services/balance_transaction_service.rb

@@ -3,6 +3,86 @@
 
 module Stripe
   class BalanceTransactionService < StripeService
+    class ListParams < Stripe::RequestParams
+      class Created < Stripe::RequestParams
+        # Minimum value to filter by (exclusive)
+        attr_accessor :gt
+
+        # Minimum value to filter by (inclusive)
+        attr_accessor :gte
+
+        # Maximum value to filter by (exclusive)
+        attr_accessor :lt
+
+        # Maximum value to filter by (inclusive)
+        attr_accessor :lte
+
+        def initialize(gt: nil, gte: nil, lt: nil, lte: nil)
+          @gt = gt
+          @gte = gte
+          @lt = lt
+          @lte = lte
+        end
+      end
+      # Only return transactions that were created during the given date interval.
+      attr_accessor :created
+
+      # Only return transactions in a certain currency. 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).
+      attr_accessor :currency
+
+      # 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.
+      attr_accessor :ending_before
+
+      # Specifies which fields in the response should be expanded.
+      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.
+      attr_accessor :limit
+
+      # For automatic Stripe payouts only, only returns transactions that were paid out on the specified payout ID.
+      attr_accessor :payout
+
+      # Only returns the original transaction.
+      attr_accessor :source
+
+      # 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.
+      attr_accessor :starting_after
+
+      # Only returns transactions of the given type. One of: `adjustment`, `advance`, `advance_funding`, `anticipation_repayment`, `application_fee`, `application_fee_refund`, `charge`, `climate_order_purchase`, `climate_order_refund`, `connect_collection_transfer`, `contribution`, `issuing_authorization_hold`, `issuing_authorization_release`, `issuing_dispute`, `issuing_transaction`, `obligation_outbound`, `obligation_reversal_inbound`, `payment`, `payment_failure_refund`, `payment_network_reserve_hold`, `payment_network_reserve_release`, `payment_refund`, `payment_reversal`, `payment_unreconciled`, `payout`, `payout_cancel`, `payout_failure`, `payout_minimum_balance_hold`, `payout_minimum_balance_release`, `refund`, `refund_failure`, `reserve_transaction`, `reserved_funds`, `stripe_fee`, `stripe_fx_fee`, `tax_fee`, `topup`, `topup_reversal`, `transfer`, `transfer_cancel`, `transfer_failure`, or `transfer_refund`.
+      attr_accessor :type
+
+      def initialize(
+        created: nil,
+        currency: nil,
+        ending_before: nil,
+        expand: nil,
+        limit: nil,
+        payout: nil,
+        source: nil,
+        starting_after: nil,
+        type: nil
+      )
+        @created = created
+        @currency = currency
+        @ending_before = ending_before
+        @expand = expand
+        @limit = limit
+        @payout = payout
+        @source = source
+        @starting_after = starting_after
+        @type = type
+      end
+    end
+
+    class RetrieveParams < Stripe::RequestParams
+      # Specifies which fields in the response should be expanded.
+      attr_accessor :expand
+
+      def initialize(expand: nil)
+        @expand = expand
+      end
+    end
+
     # Returns a list of transactions that have contributed to the Stripe account balance (e.g., charges, transfers, and so forth). The transactions are returned in sorted order, with the most recent transactions appearing first.
     #
     # Note that this endpoint was previously called “Balance history” and used the path /v1/balance/history.

data/lib/stripe/services/billing/alert_service.rb

@@ -4,6 +4,131 @@
 module Stripe
   module Billing
     class AlertService < StripeService
+      class ListParams < Stripe::RequestParams
+        # Filter results to only include this type of alert.
+        attr_accessor :alert_type
+
+        # 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.
+        attr_accessor :ending_before
+
+        # Specifies which fields in the response should be expanded.
+        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.
+        attr_accessor :limit
+
+        # Filter results to only include alerts with the given meter.
+        attr_accessor :meter
+
+        # 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.
+        attr_accessor :starting_after
+
+        def initialize(
+          alert_type: nil,
+          ending_before: nil,
+          expand: nil,
+          limit: nil,
+          meter: nil,
+          starting_after: nil
+        )
+          @alert_type = alert_type
+          @ending_before = ending_before
+          @expand = expand
+          @limit = limit
+          @meter = meter
+          @starting_after = starting_after
+        end
+      end
+
+      class CreateParams < Stripe::RequestParams
+        class UsageThreshold < Stripe::RequestParams
+          class Filter < Stripe::RequestParams
+            # Limit the scope to this usage alert only to this customer.
+            attr_accessor :customer
+
+            # What type of filter is being applied to this usage alert.
+            attr_accessor :type
+
+            def initialize(customer: nil, type: nil)
+              @customer = customer
+              @type = type
+            end
+          end
+          # The filters allows limiting the scope of this usage alert. You can only specify up to one filter at this time.
+          attr_accessor :filters
+
+          # Defines at which value the alert will fire.
+          attr_accessor :gte
+
+          # The [Billing Meter](/api/billing/meter) ID whose usage is monitored.
+          attr_accessor :meter
+
+          # Whether the alert should only fire only once, or once per billing cycle.
+          attr_accessor :recurrence
+
+          def initialize(filters: nil, gte: nil, meter: nil, recurrence: nil)
+            @filters = filters
+            @gte = gte
+            @meter = meter
+            @recurrence = recurrence
+          end
+        end
+        # The type of alert to create.
+        attr_accessor :alert_type
+
+        # Specifies which fields in the response should be expanded.
+        attr_accessor :expand
+
+        # The title of the alert.
+        attr_accessor :title
+
+        # The configuration of the usage threshold.
+        attr_accessor :usage_threshold
+
+        def initialize(alert_type: nil, expand: nil, title: nil, usage_threshold: nil)
+          @alert_type = alert_type
+          @expand = expand
+          @title = title
+          @usage_threshold = usage_threshold
+        end
+      end
+
+      class RetrieveParams < Stripe::RequestParams
+        # Specifies which fields in the response should be expanded.
+        attr_accessor :expand
+
+        def initialize(expand: nil)
+          @expand = expand
+        end
+      end
+
+      class ActivateParams < Stripe::RequestParams
+        # Specifies which fields in the response should be expanded.
+        attr_accessor :expand
+
+        def initialize(expand: nil)
+          @expand = expand
+        end
+      end
+
+      class ArchiveParams < Stripe::RequestParams
+        # Specifies which fields in the response should be expanded.
+        attr_accessor :expand
+
+        def initialize(expand: nil)
+          @expand = expand
+        end
+      end
+
+      class DeactivateParams < Stripe::RequestParams
+        # Specifies which fields in the response should be expanded.
+        attr_accessor :expand
+
+        def initialize(expand: nil)
+          @expand = expand
+        end
+      end
+
       # Reactivates this alert, allowing it to trigger again.
       def activate(id, params = {}, opts = {})
         request(

data/lib/stripe/services/billing/credit_balance_summary_service.rb

@@ -4,6 +4,47 @@
 module Stripe
   module Billing
     class CreditBalanceSummaryService < StripeService
+      class RetrieveParams < Stripe::RequestParams
+        class Filter < Stripe::RequestParams
+          class ApplicabilityScope < Stripe::RequestParams
+            # The price type that credit grants can apply to. We currently only support the `metered` price type.
+            attr_accessor :price_type
+
+            def initialize(price_type: nil)
+              @price_type = price_type
+            end
+          end
+          # The billing credit applicability scope for which to fetch credit balance summary.
+          attr_accessor :applicability_scope
+
+          # The credit grant for which to fetch credit balance summary.
+          attr_accessor :credit_grant
+
+          # Specify the type of this filter.
+          attr_accessor :type
+
+          def initialize(applicability_scope: nil, credit_grant: nil, type: nil)
+            @applicability_scope = applicability_scope
+            @credit_grant = credit_grant
+            @type = type
+          end
+        end
+        # The customer for which to fetch credit balance summary.
+        attr_accessor :customer
+
+        # Specifies which fields in the response should be expanded.
+        attr_accessor :expand
+
+        # The filter criteria for the credit balance summary.
+        attr_accessor :filter
+
+        def initialize(customer: nil, expand: nil, filter: nil)
+          @customer = customer
+          @expand = expand
+          @filter = filter
+        end
+      end
+
       # Retrieves the credit balance summary for a customer.
       def retrieve(params = {}, opts = {})
         request(

data/lib/stripe/services/billing/credit_balance_transaction_service.rb

@@ -4,6 +4,51 @@
 module Stripe
   module Billing
     class CreditBalanceTransactionService < StripeService
+      class ListParams < Stripe::RequestParams
+        # The credit grant for which to fetch credit balance transactions.
+        attr_accessor :credit_grant
+
+        # The customer for which to fetch credit balance transactions.
+        attr_accessor :customer
+
+        # 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.
+        attr_accessor :ending_before
+
+        # Specifies which fields in the response should be expanded.
+        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.
+        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.
+        attr_accessor :starting_after
+
+        def initialize(
+          credit_grant: nil,
+          customer: nil,
+          ending_before: nil,
+          expand: nil,
+          limit: nil,
+          starting_after: nil
+        )
+          @credit_grant = credit_grant
+          @customer = customer
+          @ending_before = ending_before
+          @expand = expand
+          @limit = limit
+          @starting_after = starting_after
+        end
+      end
+
+      class RetrieveParams < Stripe::RequestParams
+        # Specifies which fields in the response should be expanded.
+        attr_accessor :expand
+
+        def initialize(expand: nil)
+          @expand = expand
+        end
+      end
+
       # Retrieve a list of credit balance transactions.
       def list(params = {}, opts = {})
         request(