stripe 19.6.1 → 19.7.0.pre.alpha.2

data/lib/stripe/params/balance_settings_update_params.rb

@@ -85,12 +85,20 @@ module Stripe
       attr_accessor :debit_negative_balances
       # Settings specific to the account's payouts.
       attr_accessor :payouts
+      # A hash of settlement currencies to update. Each key is an ISO 4217 currency code, and the value is either `enabled` or `disabled`.
+      attr_accessor :settlement_currencies
       # Settings related to the account's balance settlement timing.
       attr_accessor :settlement_timing
 
-      def initialize(debit_negative_balances: nil, payouts: nil, settlement_timing: nil)
+      def initialize(
+        debit_negative_balances: nil,
+        payouts: nil,
+        settlement_currencies: nil,
+        settlement_timing: nil
+      )
         @debit_negative_balances = debit_negative_balances
         @payouts = payouts
+        @settlement_currencies = settlement_currencies
         @settlement_timing = settlement_timing
       end
     end

data/lib/stripe/params/balance_transfer_create_params.rb

@@ -0,0 +1,66 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class BalanceTransferCreateParams < ::Stripe::RequestParams
+    class DestinationBalance < ::Stripe::RequestParams
+      # Destination balance type to push funds into for the Balance Transfer.
+      attr_accessor :type
+
+      def initialize(type: nil)
+        @type = type
+      end
+    end
+
+    class SourceBalance < ::Stripe::RequestParams
+      class AllocatedFunds < ::Stripe::RequestParams
+        # The charge ID that the funds are originally sourced from. Required if `type` is `charge`.
+        attr_accessor :charge
+        # The type of object that the funds are originally sourced from. One of `charge`.
+        attr_accessor :type
+
+        def initialize(charge: nil, type: nil)
+          @charge = charge
+          @type = type
+        end
+      end
+      # Attribute for param field allocated_funds
+      attr_accessor :allocated_funds
+      # Source balance type to pull funds from for the Balance Transfer.
+      attr_accessor :type
+
+      def initialize(allocated_funds: nil, type: nil)
+        @allocated_funds = allocated_funds
+        @type = type
+      end
+    end
+    # A positive integer representing how much to transfer in the smallest currency unit.
+    attr_accessor :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).
+    attr_accessor :currency
+    # The balance to which funds are transferred.
+    attr_accessor :destination_balance
+    # Specifies which fields in the response should be expanded.
+    attr_accessor :expand
+    # Set of [key-value pairs](https://docs.stripe.com/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
+    # The balance from which funds are transferred, including details specific to the balance you choose.
+    attr_accessor :source_balance
+
+    def initialize(
+      amount: nil,
+      currency: nil,
+      destination_balance: nil,
+      expand: nil,
+      metadata: nil,
+      source_balance: nil
+    )
+      @amount = amount
+      @currency = currency
+      @destination_balance = destination_balance
+      @expand = expand
+      @metadata = metadata
+      @source_balance = source_balance
+    end
+  end
+end

data/lib/stripe/params/billing/alert_create_params.rb

@@ -4,6 +4,233 @@
 module Stripe
   module Billing
     class AlertCreateParams < ::Stripe::RequestParams
+      class CreditBalanceThreshold < ::Stripe::RequestParams
+        class Filter < ::Stripe::RequestParams
+          class CreditGrants < ::Stripe::RequestParams
+            class ApplicabilityConfig < ::Stripe::RequestParams
+              class Scope < ::Stripe::RequestParams
+                class BillableItem < ::Stripe::RequestParams
+                  # The billable item ID this credit grant should apply to.
+                  attr_accessor :id
+
+                  def initialize(id: nil)
+                    @id = id
+                  end
+                end
+
+                class Price < ::Stripe::RequestParams
+                  # The price ID this credit grant should apply to.
+                  attr_accessor :id
+
+                  def initialize(id: nil)
+                    @id = id
+                  end
+                end
+                # A list of billable items that the credit grant can apply to. We currently only support metered billable items. Cannot be used in combination with `price_type` or `prices`.
+                attr_accessor :billable_items
+                # The price type that credit grants can apply to. We currently only support the `metered` price type. Cannot be used in combination with `prices`.
+                attr_accessor :price_type
+                # A list of prices that the credit grant can apply to. We currently only support the `metered` prices. Cannot be used in combination with `price_type`.
+                attr_accessor :prices
+
+                def initialize(billable_items: nil, price_type: nil, prices: nil)
+                  @billable_items = billable_items
+                  @price_type = price_type
+                  @prices = prices
+                end
+              end
+              # Specify the scope of this applicability config.
+              attr_accessor :scope
+
+              def initialize(scope: nil)
+                @scope = scope
+              end
+            end
+            # The applicability configuration for this credit grants filter.
+            attr_accessor :applicability_config
+
+            def initialize(applicability_config: nil)
+              @applicability_config = applicability_config
+            end
+          end
+          # The credit grants for which to configure the credit balance alert.
+          attr_accessor :credit_grants
+          # Limit the scope to this credit balance alert only to this customer.
+          attr_accessor :customer
+          # What type of filter is being applied to this credit balance alert.
+          attr_accessor :type
+
+          def initialize(credit_grants: nil, customer: nil, type: nil)
+            @credit_grants = credit_grants
+            @customer = customer
+            @type = type
+          end
+        end
+
+        class Lte < ::Stripe::RequestParams
+          class CustomPricingUnit < ::Stripe::RequestParams
+            # The ID of the custom pricing unit.
+            attr_accessor :id
+            # A positive decimal string representing the amount of the custom pricing unit threshold.
+            attr_accessor :value
+
+            def initialize(id: nil, value: nil)
+              @id = id
+              @value = value
+            end
+
+            def self.field_encodings
+              @field_encodings = { value: :decimal_string }
+            end
+          end
+
+          class Monetary < ::Stripe::RequestParams
+            # Three-letter [ISO code for the currency](https://stripe.com/docs/currencies) of the `value` parameter.
+            attr_accessor :currency
+            # An integer representing the amount of the threshold.
+            attr_accessor :value
+
+            def initialize(currency: nil, value: nil)
+              @currency = currency
+              @value = value
+            end
+          end
+          # Specify the type of this balance. We currently only support `monetary` billing credits.
+          attr_accessor :balance_type
+          # The custom pricing unit amount.
+          attr_accessor :custom_pricing_unit
+          # The monetary amount.
+          attr_accessor :monetary
+
+          def initialize(balance_type: nil, custom_pricing_unit: nil, monetary: nil)
+            @balance_type = balance_type
+            @custom_pricing_unit = custom_pricing_unit
+            @monetary = monetary
+          end
+
+          def self.field_encodings
+            @field_encodings = {
+              custom_pricing_unit: { kind: :object, fields: { value: :decimal_string } },
+            }
+          end
+        end
+        # The filters allows limiting the scope of this credit balance alert. You must specify a customer filter at this time.
+        attr_accessor :filters
+        # Defines at which value the alert will fire.
+        attr_accessor :lte
+
+        def initialize(filters: nil, lte: nil)
+          @filters = filters
+          @lte = lte
+        end
+
+        def self.field_encodings
+          @field_encodings = {
+            lte: {
+              kind: :object,
+              fields: { custom_pricing_unit: { kind: :object, fields: { value: :decimal_string } } },
+            },
+          }
+        end
+      end
+
+      class SpendThreshold < ::Stripe::RequestParams
+        class Filters < ::Stripe::RequestParams
+          # Filter by billable item IDs. Maximum of 20 billable items.
+          attr_accessor :billable_items
+          # Filter by billing cadence ID.
+          attr_accessor :billing_cadence
+          # Filter by pricing plan ID.
+          attr_accessor :pricing_plan
+          # Filter by pricing plan subscription ID.
+          attr_accessor :pricing_plan_subscription
+
+          def initialize(
+            billable_items: nil,
+            billing_cadence: nil,
+            pricing_plan: nil,
+            pricing_plan_subscription: nil
+          )
+            @billable_items = billable_items
+            @billing_cadence = billing_cadence
+            @pricing_plan = pricing_plan
+            @pricing_plan_subscription = pricing_plan_subscription
+          end
+        end
+
+        class Gte < ::Stripe::RequestParams
+          class Amount < ::Stripe::RequestParams
+            # Three-letter [ISO code for the currency](https://stripe.com/docs/currencies) of the `value` parameter.
+            attr_accessor :currency
+            # An integer representing the amount of the threshold.
+            attr_accessor :value
+
+            def initialize(currency: nil, value: nil)
+              @currency = currency
+              @value = value
+            end
+          end
+
+          class CustomPricingUnit < ::Stripe::RequestParams
+            # The ID of the custom pricing unit.
+            attr_accessor :id
+            # A positive decimal string representing the amount of the custom pricing unit threshold.
+            attr_accessor :value
+
+            def initialize(id: nil, value: nil)
+              @id = id
+              @value = value
+            end
+
+            def self.field_encodings
+              @field_encodings = { value: :decimal_string }
+            end
+          end
+          # The monetary amount. Required when type is `amount`. The threshold is the total_before_tax, the amount consumed after all credits and discounts are applied, but before tax is applied.
+          attr_accessor :amount
+          # The custom pricing unit amount. Required when type is `custom_pricing_unit`.
+          attr_accessor :custom_pricing_unit
+          # The type of the threshold amount.
+          attr_accessor :type
+
+          def initialize(amount: nil, custom_pricing_unit: nil, type: nil)
+            @amount = amount
+            @custom_pricing_unit = custom_pricing_unit
+            @type = type
+          end
+
+          def self.field_encodings
+            @field_encodings = {
+              custom_pricing_unit: { kind: :object, fields: { value: :decimal_string } },
+            }
+          end
+        end
+        # Defines the period over which spend is aggregated.
+        attr_accessor :aggregation_period
+        # Filters to scope the spend calculation.
+        attr_accessor :filters
+        # Defines the granularity of spend aggregation. Defaults to `pricing_plan_subscription`.
+        attr_accessor :group_by
+        # Defines at which value the alert will fire.
+        attr_accessor :gte
+
+        def initialize(aggregation_period: nil, filters: nil, group_by: nil, gte: nil)
+          @aggregation_period = aggregation_period
+          @filters = filters
+          @group_by = group_by
+          @gte = gte
+        end
+
+        def self.field_encodings
+          @field_encodings = {
+            gte: {
+              kind: :object,
+              fields: { custom_pricing_unit: { kind: :object, fields: { value: :decimal_string } } },
+            },
+          }
+        end
+      end
+
       class UsageThreshold < ::Stripe::RequestParams
         class Filter < ::Stripe::RequestParams
           # Limit the scope to this usage alert only to this customer.
@@ -34,19 +261,55 @@ module Stripe
       end
       # The type of alert to create.
       attr_accessor :alert_type
+      # The configuration of the credit balance threshold.
+      attr_accessor :credit_balance_threshold
       # Specifies which fields in the response should be expanded.
       attr_accessor :expand
+      # The configuration of the spend threshold. An event fires when the amount consumed exceeds the threshold, after all credits and discounts are applied but before tax is applied.
+      attr_accessor :spend_threshold
       # 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)
+      def initialize(
+        alert_type: nil,
+        credit_balance_threshold: nil,
+        expand: nil,
+        spend_threshold: nil,
+        title: nil,
+        usage_threshold: nil
+      )
         @alert_type = alert_type
+        @credit_balance_threshold = credit_balance_threshold
         @expand = expand
+        @spend_threshold = spend_threshold
         @title = title
         @usage_threshold = usage_threshold
       end
+
+      def self.field_encodings
+        @field_encodings = {
+          credit_balance_threshold: {
+            kind: :object,
+            fields: {
+              lte: {
+                kind: :object,
+                fields: { custom_pricing_unit: { kind: :object, fields: { value: :decimal_string } } },
+              },
+            },
+          },
+          spend_threshold: {
+            kind: :object,
+            fields: {
+              gte: {
+                kind: :object,
+                fields: { custom_pricing_unit: { kind: :object, fields: { value: :decimal_string } } },
+              },
+            },
+          },
+        }
+      end
     end
   end
 end

data/lib/stripe/params/billing/alert_list_params.rb

@@ -6,6 +6,8 @@ module Stripe
     class AlertListParams < ::Stripe::RequestParams
       # Filter results to only include this type of alert.
       attr_accessor :alert_type
+      # Filter results to only include alerts for the given customer.
+      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.
@@ -19,6 +21,7 @@ module Stripe
 
       def initialize(
         alert_type: nil,
+        customer: nil,
         ending_before: nil,
         expand: nil,
         limit: nil,
@@ -26,6 +29,7 @@ module Stripe
         starting_after: nil
       )
         @alert_type = alert_type
+        @customer = customer
         @ending_before = ending_before
         @expand = expand
         @limit = limit

data/lib/stripe/params/billing/alert_notification_list_params.rb

@@ -0,0 +1,70 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module Billing
+    class AlertNotificationListParams < ::Stripe::RequestParams
+      class NotifiedAt < ::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
+      # Filter results to only include triggered or recovered notifications.
+      attr_accessor :action
+      # Filter results to only include notifications for the given billing cadence.
+      attr_accessor :cadence
+      # The customer to list notifications for.
+      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
+      # Filter results to only include notifications for the given meter.
+      attr_accessor :meter
+      # Filter results according to when the notification was sent.
+      attr_accessor :notified_at
+      # 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
+      # Filter results to only include notifications for the given subscription.
+      attr_accessor :subscription
+
+      def initialize(
+        action: nil,
+        cadence: nil,
+        customer: nil,
+        ending_before: nil,
+        expand: nil,
+        limit: nil,
+        meter: nil,
+        notified_at: nil,
+        starting_after: nil,
+        subscription: nil
+      )
+        @action = action
+        @cadence = cadence
+        @customer = customer
+        @ending_before = ending_before
+        @expand = expand
+        @limit = limit
+        @meter = meter
+        @notified_at = notified_at
+        @starting_after = starting_after
+        @subscription = subscription
+      end
+    end
+  end
+end

data/lib/stripe/params/billing/analytics/meter_usage_retrieve_params.rb

@@ -0,0 +1,69 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module Billing
+    module Analytics
+      class MeterUsageRetrieveParams < ::Stripe::RequestParams
+        class Meter < ::Stripe::RequestParams
+          # Key-value pairs used to filter usage events by meter dimension values. Each value is an array that can include multiple values for the key. If specified, usage is filtered for matching usage events.
+          attr_accessor :dimension_filters
+          # List of meter dimension keys to group by. If specified, usage events will be grouped by the given meter dimension key's values.
+          attr_accessor :dimension_group_by_keys
+          # Meter id to query usage for.
+          attr_accessor :meter
+          # Key-value pairs used to filter usage events by high cardinality tenant dimension values. Each value is an array that can include multiple values for the key. If specified, usage is filtered for matching usage events.
+          attr_accessor :tenant_filters
+          # List of high cardinality tenant dimension keys to group by. If specified, usage events will be grouped by the given tenant dimension key's values.
+          attr_accessor :tenant_group_by_keys
+
+          def initialize(
+            dimension_filters: nil,
+            dimension_group_by_keys: nil,
+            meter: nil,
+            tenant_filters: nil,
+            tenant_group_by_keys: nil
+          )
+            @dimension_filters = dimension_filters
+            @dimension_group_by_keys = dimension_group_by_keys
+            @meter = meter
+            @tenant_filters = tenant_filters
+            @tenant_group_by_keys = tenant_group_by_keys
+          end
+        end
+        # The customer id to fetch meter usage data for.
+        attr_accessor :customer
+        # The timestamp from when to stop aggregating meter events (exclusive). Must be aligned with minute boundaries.
+        attr_accessor :ends_at
+        # Specifies which fields in the response should be expanded.
+        attr_accessor :expand
+        # An array of meter parameters to specify which meters to include in the usage data. If not specified, usage across all meters for the customer is included.
+        attr_accessor :meters
+        # The timestamp from when to start aggregating meter events (inclusive). Must be aligned with minute boundaries.
+        attr_accessor :starts_at
+        # The timezone to use for the start and end times. Defaults to UTC if not specified.
+        attr_accessor :timezone
+        # Specifies what granularity to use when aggregating meter usage events. If not specified, a single event would be returned for the specified time range.
+        attr_accessor :value_grouping_window
+
+        def initialize(
+          customer: nil,
+          ends_at: nil,
+          expand: nil,
+          meters: nil,
+          starts_at: nil,
+          timezone: nil,
+          value_grouping_window: nil
+        )
+          @customer = customer
+          @ends_at = ends_at
+          @expand = expand
+          @meters = meters
+          @starts_at = starts_at
+          @timezone = timezone
+          @value_grouping_window = value_grouping_window
+        end
+      end
+    end
+  end
+end

data/lib/stripe/params/billing/credit_balance_summary_retrieve_params.rb

@@ -6,6 +6,15 @@ module Stripe
     class CreditBalanceSummaryRetrieveParams < ::Stripe::RequestParams
       class Filter < ::Stripe::RequestParams
         class ApplicabilityScope < ::Stripe::RequestParams
+          class BillableItem < ::Stripe::RequestParams
+            # The billable item ID this credit grant should apply to.
+            attr_accessor :id
+
+            def initialize(id: nil)
+              @id = id
+            end
+          end
+
           class Price < ::Stripe::RequestParams
             # The price ID this credit grant should apply to.
             attr_accessor :id
@@ -14,14 +23,29 @@ module Stripe
               @id = id
             end
           end
+
+          class RateCard < ::Stripe::RequestParams
+            # The rate card ID this credit grant should apply to.
+            attr_accessor :id
+
+            def initialize(id: nil)
+              @id = id
+            end
+          end
+          # A list of billable items that the credit grant can apply to. We currently only support metered billable items. Cannot be used in combination with `price_type` or `prices`.
+          attr_accessor :billable_items
           # The price type that credit grants can apply to. We currently only support the `metered` price type. Cannot be used in combination with `prices`.
           attr_accessor :price_type
           # A list of prices that the credit grant can apply to. We currently only support the `metered` prices. Cannot be used in combination with `price_type`. Limit 20 prices.
           attr_accessor :prices
+          # A list of rate cards that the credit grant can apply to. The credit grant applies to any metered item billed under one of these rate cards. Cannot be used in combination with `price_type`, `prices`, or `billable_items`.
+          attr_accessor :rate_cards
 
-          def initialize(price_type: nil, prices: nil)
+          def initialize(billable_items: nil, price_type: nil, prices: nil, rate_cards: nil)
+            @billable_items = billable_items
             @price_type = price_type
             @prices = prices
+            @rate_cards = rate_cards
           end
         end
         # The billing credit applicability scope for which to fetch credit balance summary.