mega-pure-kit 0.0.1

data/stripe-19.3.0/lib/stripe/params/issuing/authorization_finalize_amount_params.rb

@@ -0,0 +1,223 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module Issuing
+    class AuthorizationFinalizeAmountParams < ::Stripe::RequestParams
+      class Fleet < ::Stripe::RequestParams
+        class CardholderPromptData < ::Stripe::RequestParams
+          # Driver ID.
+          attr_accessor :driver_id
+          # Odometer reading.
+          attr_accessor :odometer
+          # An alphanumeric ID. This field is used when a vehicle ID, driver ID, or generic ID is entered by the cardholder, but the merchant or card network did not specify the prompt type.
+          attr_accessor :unspecified_id
+          # User ID.
+          attr_accessor :user_id
+          # Vehicle number.
+          attr_accessor :vehicle_number
+
+          def initialize(
+            driver_id: nil,
+            odometer: nil,
+            unspecified_id: nil,
+            user_id: nil,
+            vehicle_number: nil
+          )
+            @driver_id = driver_id
+            @odometer = odometer
+            @unspecified_id = unspecified_id
+            @user_id = user_id
+            @vehicle_number = vehicle_number
+          end
+        end
+
+        class ReportedBreakdown < ::Stripe::RequestParams
+          class Fuel < ::Stripe::RequestParams
+            # Gross fuel amount that should equal Fuel Volume multipled by Fuel Unit Cost, inclusive of taxes.
+            attr_accessor :gross_amount_decimal
+
+            def initialize(gross_amount_decimal: nil)
+              @gross_amount_decimal = gross_amount_decimal
+            end
+
+            def self.field_encodings
+              @field_encodings = { gross_amount_decimal: :decimal_string }
+            end
+          end
+
+          class NonFuel < ::Stripe::RequestParams
+            # Gross non-fuel amount that should equal the sum of the line items, inclusive of taxes.
+            attr_accessor :gross_amount_decimal
+
+            def initialize(gross_amount_decimal: nil)
+              @gross_amount_decimal = gross_amount_decimal
+            end
+
+            def self.field_encodings
+              @field_encodings = { gross_amount_decimal: :decimal_string }
+            end
+          end
+
+          class Tax < ::Stripe::RequestParams
+            # Amount of state or provincial Sales Tax included in the transaction amount. Null if not reported by merchant or not subject to tax.
+            attr_accessor :local_amount_decimal
+            # Amount of national Sales Tax or VAT included in the transaction amount. Null if not reported by merchant or not subject to tax.
+            attr_accessor :national_amount_decimal
+
+            def initialize(local_amount_decimal: nil, national_amount_decimal: nil)
+              @local_amount_decimal = local_amount_decimal
+              @national_amount_decimal = national_amount_decimal
+            end
+
+            def self.field_encodings
+              @field_encodings = {
+                local_amount_decimal: :decimal_string,
+                national_amount_decimal: :decimal_string,
+              }
+            end
+          end
+          # Breakdown of fuel portion of the purchase.
+          attr_accessor :fuel
+          # Breakdown of non-fuel portion of the purchase.
+          attr_accessor :non_fuel
+          # Information about tax included in this transaction.
+          attr_accessor :tax
+
+          def initialize(fuel: nil, non_fuel: nil, tax: nil)
+            @fuel = fuel
+            @non_fuel = non_fuel
+            @tax = tax
+          end
+
+          def self.field_encodings
+            @field_encodings = {
+              fuel: { kind: :object, fields: { gross_amount_decimal: :decimal_string } },
+              non_fuel: { kind: :object, fields: { gross_amount_decimal: :decimal_string } },
+              tax: {
+                kind: :object,
+                fields: {
+                  local_amount_decimal: :decimal_string,
+                  national_amount_decimal: :decimal_string,
+                },
+              },
+            }
+          end
+        end
+        # Answers to prompts presented to the cardholder at the point of sale. Prompted fields vary depending on the configuration of your physical fleet cards. Typical points of sale support only numeric entry.
+        attr_accessor :cardholder_prompt_data
+        # The type of purchase. One of `fuel_purchase`, `non_fuel_purchase`, or `fuel_and_non_fuel_purchase`.
+        attr_accessor :purchase_type
+        # More information about the total amount. This information is not guaranteed to be accurate as some merchants may provide unreliable data.
+        attr_accessor :reported_breakdown
+        # The type of fuel service. One of `non_fuel_transaction`, `full_service`, or `self_service`.
+        attr_accessor :service_type
+
+        def initialize(
+          cardholder_prompt_data: nil,
+          purchase_type: nil,
+          reported_breakdown: nil,
+          service_type: nil
+        )
+          @cardholder_prompt_data = cardholder_prompt_data
+          @purchase_type = purchase_type
+          @reported_breakdown = reported_breakdown
+          @service_type = service_type
+        end
+
+        def self.field_encodings
+          @field_encodings = {
+            reported_breakdown: {
+              kind: :object,
+              fields: {
+                fuel: { kind: :object, fields: { gross_amount_decimal: :decimal_string } },
+                non_fuel: { kind: :object, fields: { gross_amount_decimal: :decimal_string } },
+                tax: {
+                  kind: :object,
+                  fields: {
+                    local_amount_decimal: :decimal_string,
+                    national_amount_decimal: :decimal_string,
+                  },
+                },
+              },
+            },
+          }
+        end
+      end
+
+      class Fuel < ::Stripe::RequestParams
+        # [Conexxus Payment System Product Code](https://www.conexxus.org/conexxus-payment-system-product-codes) identifying the primary fuel product purchased.
+        attr_accessor :industry_product_code
+        # The quantity of `unit`s of fuel that was dispensed, represented as a decimal string with at most 12 decimal places.
+        attr_accessor :quantity_decimal
+        # The type of fuel that was purchased. One of `diesel`, `unleaded_plus`, `unleaded_regular`, `unleaded_super`, or `other`.
+        attr_accessor :type
+        # The units for `quantity_decimal`. One of `charging_minute`, `imperial_gallon`, `kilogram`, `kilowatt_hour`, `liter`, `pound`, `us_gallon`, or `other`.
+        attr_accessor :unit
+        # The cost in cents per each unit of fuel, represented as a decimal string with at most 12 decimal places.
+        attr_accessor :unit_cost_decimal
+
+        def initialize(
+          industry_product_code: nil,
+          quantity_decimal: nil,
+          type: nil,
+          unit: nil,
+          unit_cost_decimal: nil
+        )
+          @industry_product_code = industry_product_code
+          @quantity_decimal = quantity_decimal
+          @type = type
+          @unit = unit
+          @unit_cost_decimal = unit_cost_decimal
+        end
+
+        def self.field_encodings
+          @field_encodings = { quantity_decimal: :decimal_string, unit_cost_decimal: :decimal_string }
+        end
+      end
+      # Specifies which fields in the response should be expanded.
+      attr_accessor :expand
+      # The final authorization amount that will be captured by the merchant. This amount is in the authorization currency and in the [smallest currency unit](https://docs.stripe.com/currencies#zero-decimal).
+      attr_accessor :final_amount
+      # Fleet-specific information for authorizations using Fleet cards.
+      attr_accessor :fleet
+      # Information about fuel that was purchased with this transaction.
+      attr_accessor :fuel
+
+      def initialize(expand: nil, final_amount: nil, fleet: nil, fuel: nil)
+        @expand = expand
+        @final_amount = final_amount
+        @fleet = fleet
+        @fuel = fuel
+      end
+
+      def self.field_encodings
+        @field_encodings = {
+          fleet: {
+            kind: :object,
+            fields: {
+              reported_breakdown: {
+                kind: :object,
+                fields: {
+                  fuel: { kind: :object, fields: { gross_amount_decimal: :decimal_string } },
+                  non_fuel: { kind: :object, fields: { gross_amount_decimal: :decimal_string } },
+                  tax: {
+                    kind: :object,
+                    fields: {
+                      local_amount_decimal: :decimal_string,
+                      national_amount_decimal: :decimal_string,
+                    },
+                  },
+                },
+              },
+            },
+          },
+          fuel: {
+            kind: :object,
+            fields: { quantity_decimal: :decimal_string, unit_cost_decimal: :decimal_string },
+          },
+        }
+      end
+    end
+  end
+end

data/stripe-19.3.0/lib/stripe/params/issuing/authorization_increment_params.rb

@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module Issuing
+    class AuthorizationIncrementParams < ::Stripe::RequestParams
+      # Specifies which fields in the response should be expanded.
+      attr_accessor :expand
+      # The amount to increment the authorization by. This amount is in the authorization currency and in the [smallest currency unit](https://docs.stripe.com/currencies#zero-decimal).
+      attr_accessor :increment_amount
+      # If set `true`, you may provide [amount](https://docs.stripe.com/api/issuing/authorizations/approve#approve_issuing_authorization-amount) to control how much to hold for the authorization.
+      attr_accessor :is_amount_controllable
+
+      def initialize(expand: nil, increment_amount: nil, is_amount_controllable: nil)
+        @expand = expand
+        @increment_amount = increment_amount
+        @is_amount_controllable = is_amount_controllable
+      end
+    end
+  end
+end

data/stripe-19.3.0/lib/stripe/params/issuing/authorization_list_params.rb

@@ -0,0 +1,62 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module Issuing
+    class AuthorizationListParams < ::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 authorizations that belong to the given card.
+      attr_accessor :card
+      # Only return authorizations that belong to the given cardholder.
+      attr_accessor :cardholder
+      # Only return authorizations 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
+      # Only return authorizations with the given status. One of `pending`, `closed`, or `reversed`.
+      attr_accessor :status
+
+      def initialize(
+        card: nil,
+        cardholder: nil,
+        created: nil,
+        ending_before: nil,
+        expand: nil,
+        limit: nil,
+        starting_after: nil,
+        status: nil
+      )
+        @card = card
+        @cardholder = cardholder
+        @created = created
+        @ending_before = ending_before
+        @expand = expand
+        @limit = limit
+        @starting_after = starting_after
+        @status = status
+      end
+    end
+  end
+end

data/stripe-19.3.0/lib/stripe/params/issuing/authorization_respond_params.rb

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module Issuing
+    class AuthorizationRespondParams < ::Stripe::RequestParams
+      # Whether to simulate the user confirming that the transaction was legitimate (true) or telling Stripe that it was fraudulent (false).
+      attr_accessor :confirmed
+      # Specifies which fields in the response should be expanded.
+      attr_accessor :expand
+
+      def initialize(confirmed: nil, expand: nil)
+        @confirmed = confirmed
+        @expand = expand
+      end
+    end
+  end
+end

data/stripe-19.3.0/lib/stripe/params/issuing/authorization_retrieve_params.rb

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module Issuing
+    class AuthorizationRetrieveParams < ::Stripe::RequestParams
+      # Specifies which fields in the response should be expanded.
+      attr_accessor :expand
+
+      def initialize(expand: nil)
+        @expand = expand
+      end
+    end
+  end
+end

data/stripe-19.3.0/lib/stripe/params/issuing/authorization_reverse_params.rb

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module Issuing
+    class AuthorizationReverseParams < ::Stripe::RequestParams
+      # Specifies which fields in the response should be expanded.
+      attr_accessor :expand
+      # The amount to reverse from the authorization. If not provided, the full amount of the authorization will be reversed. This amount is in the authorization currency and in the [smallest currency unit](https://docs.stripe.com/currencies#zero-decimal).
+      attr_accessor :reverse_amount
+
+      def initialize(expand: nil, reverse_amount: nil)
+        @expand = expand
+        @reverse_amount = reverse_amount
+      end
+    end
+  end
+end

data/stripe-19.3.0/lib/stripe/params/issuing/authorization_update_params.rb

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module Issuing
+    class AuthorizationUpdateParams < ::Stripe::RequestParams
+      # 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
+
+      def initialize(expand: nil, metadata: nil)
+        @expand = expand
+        @metadata = metadata
+      end
+    end
+  end
+end

data/stripe-19.3.0/lib/stripe/params/issuing/card_create_params.rb

@@ -0,0 +1,242 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module Issuing
+    class CardCreateParams < ::Stripe::RequestParams
+      class LifecycleControls < ::Stripe::RequestParams
+        class CancelAfter < ::Stripe::RequestParams
+          # The card is automatically cancelled when it makes this number of non-zero payment authorizations and transactions. The count includes penny authorizations, but doesn't include non-payment actions, such as authorization advice.
+          attr_accessor :payment_count
+
+          def initialize(payment_count: nil)
+            @payment_count = payment_count
+          end
+        end
+        # Cancels the card after the specified conditions are met.
+        attr_accessor :cancel_after
+
+        def initialize(cancel_after: nil)
+          @cancel_after = cancel_after
+        end
+      end
+
+      class Pin < ::Stripe::RequestParams
+        # The card's desired new PIN, encrypted under Stripe's public key.
+        attr_accessor :encrypted_number
+
+        def initialize(encrypted_number: nil)
+          @encrypted_number = encrypted_number
+        end
+      end
+
+      class Shipping < ::Stripe::RequestParams
+        class Address < ::Stripe::RequestParams
+          # City, district, suburb, town, or village.
+          attr_accessor :city
+          # Two-letter country code ([ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2)).
+          attr_accessor :country
+          # Address line 1, such as the street, PO Box, or company name.
+          attr_accessor :line1
+          # Address line 2, such as the apartment, suite, unit, or building.
+          attr_accessor :line2
+          # ZIP or postal code.
+          attr_accessor :postal_code
+          # State, county, province, or region ([ISO 3166-2](https://en.wikipedia.org/wiki/ISO_3166-2)).
+          attr_accessor :state
+
+          def initialize(
+            city: nil,
+            country: nil,
+            line1: nil,
+            line2: nil,
+            postal_code: nil,
+            state: nil
+          )
+            @city = city
+            @country = country
+            @line1 = line1
+            @line2 = line2
+            @postal_code = postal_code
+            @state = state
+          end
+        end
+
+        class AddressValidation < ::Stripe::RequestParams
+          # The address validation capabilities to use.
+          attr_accessor :mode
+
+          def initialize(mode: nil)
+            @mode = mode
+          end
+        end
+
+        class Customs < ::Stripe::RequestParams
+          # The Economic Operators Registration and Identification (EORI) number to use for Customs. Required for bulk shipments to Europe.
+          attr_accessor :eori_number
+
+          def initialize(eori_number: nil)
+            @eori_number = eori_number
+          end
+        end
+        # The address that the card is shipped to.
+        attr_accessor :address
+        # Address validation settings.
+        attr_accessor :address_validation
+        # Customs information for the shipment.
+        attr_accessor :customs
+        # The name printed on the shipping label when shipping the card.
+        attr_accessor :name
+        # Phone number of the recipient of the shipment.
+        attr_accessor :phone_number
+        # Whether a signature is required for card delivery.
+        attr_accessor :require_signature
+        # Shipment service.
+        attr_accessor :service
+        # Packaging options.
+        attr_accessor :type
+
+        def initialize(
+          address: nil,
+          address_validation: nil,
+          customs: nil,
+          name: nil,
+          phone_number: nil,
+          require_signature: nil,
+          service: nil,
+          type: nil
+        )
+          @address = address
+          @address_validation = address_validation
+          @customs = customs
+          @name = name
+          @phone_number = phone_number
+          @require_signature = require_signature
+          @service = service
+          @type = type
+        end
+      end
+
+      class SpendingControls < ::Stripe::RequestParams
+        class SpendingLimit < ::Stripe::RequestParams
+          # Maximum amount allowed to spend per interval.
+          attr_accessor :amount
+          # Array of strings containing [categories](https://docs.stripe.com/api#issuing_authorization_object-merchant_data-category) this limit applies to. Omitting this field will apply the limit to all categories.
+          attr_accessor :categories
+          # Interval (or event) to which the amount applies.
+          attr_accessor :interval
+
+          def initialize(amount: nil, categories: nil, interval: nil)
+            @amount = amount
+            @categories = categories
+            @interval = interval
+          end
+        end
+        # Array of card presence statuses from which authorizations will be allowed. Possible options are `present`, `not_present`. All other statuses will be blocked. Cannot be set with `blocked_card_presences`. Provide an empty value to unset this control.
+        attr_accessor :allowed_card_presences
+        # Array of strings containing [categories](https://docs.stripe.com/api#issuing_authorization_object-merchant_data-category) of authorizations to allow. All other categories will be blocked. Cannot be set with `blocked_categories`.
+        attr_accessor :allowed_categories
+        # Array of strings containing representing countries from which authorizations will be allowed. Authorizations from merchants in all other countries will be declined. Country codes should be ISO 3166 alpha-2 country codes (e.g. `US`). Cannot be set with `blocked_merchant_countries`. Provide an empty value to unset this control.
+        attr_accessor :allowed_merchant_countries
+        # Array of card presence statuses from which authorizations will be declined. Possible options are `present`, `not_present`. Cannot be set with `allowed_card_presences`. Provide an empty value to unset this control.
+        attr_accessor :blocked_card_presences
+        # Array of strings containing [categories](https://docs.stripe.com/api#issuing_authorization_object-merchant_data-category) of authorizations to decline. All other categories will be allowed. Cannot be set with `allowed_categories`.
+        attr_accessor :blocked_categories
+        # Array of strings containing representing countries from which authorizations will be declined. Country codes should be ISO 3166 alpha-2 country codes (e.g. `US`). Cannot be set with `allowed_merchant_countries`. Provide an empty value to unset this control.
+        attr_accessor :blocked_merchant_countries
+        # Limit spending with amount-based rules that apply across any cards this card replaced (i.e., its `replacement_for` card and _that_ card's `replacement_for` card, up the chain).
+        attr_accessor :spending_limits
+
+        def initialize(
+          allowed_card_presences: nil,
+          allowed_categories: nil,
+          allowed_merchant_countries: nil,
+          blocked_card_presences: nil,
+          blocked_categories: nil,
+          blocked_merchant_countries: nil,
+          spending_limits: nil
+        )
+          @allowed_card_presences = allowed_card_presences
+          @allowed_categories = allowed_categories
+          @allowed_merchant_countries = allowed_merchant_countries
+          @blocked_card_presences = blocked_card_presences
+          @blocked_categories = blocked_categories
+          @blocked_merchant_countries = blocked_merchant_countries
+          @spending_limits = spending_limits
+        end
+      end
+      # The [Cardholder](https://docs.stripe.com/api#issuing_cardholder_object) object with which the card will be associated.
+      attr_accessor :cardholder
+      # The currency for the card.
+      attr_accessor :currency
+      # The desired expiration month (1-12) for this card if [specifying a custom expiration date](/issuing/cards/virtual/issue-cards?testing-method=with-code#exp-dates).
+      attr_accessor :exp_month
+      # The desired 4-digit expiration year for this card if [specifying a custom expiration date](/issuing/cards/virtual/issue-cards?testing-method=with-code#exp-dates).
+      attr_accessor :exp_year
+      # Specifies which fields in the response should be expanded.
+      attr_accessor :expand
+      # The new financial account ID the card will be associated with. This field allows a card to be reassigned to a different financial account.
+      attr_accessor :financial_account
+      # Rules that control the lifecycle of this card, such as automatic cancellation. Refer to our [documentation](/issuing/controls/lifecycle-controls) for more details.
+      attr_accessor :lifecycle_controls
+      # 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 personalization design object belonging to this card.
+      attr_accessor :personalization_design
+      # The desired PIN for this card.
+      attr_accessor :pin
+      # The card this is meant to be a replacement for (if any).
+      attr_accessor :replacement_for
+      # If `replacement_for` is specified, this should indicate why that card is being replaced.
+      attr_accessor :replacement_reason
+      # The second line to print on the card. Max length: 24 characters.
+      attr_accessor :second_line
+      # The address where the card will be shipped.
+      attr_accessor :shipping
+      # Rules that control spending for this card. Refer to our [documentation](https://docs.stripe.com/issuing/controls/spending-controls) for more details.
+      attr_accessor :spending_controls
+      # Whether authorizations can be approved on this card. May be blocked from activating cards depending on past-due Cardholder requirements. Defaults to `inactive`.
+      attr_accessor :status
+      # The type of card to issue. Possible values are `physical` or `virtual`.
+      attr_accessor :type
+
+      def initialize(
+        cardholder: nil,
+        currency: nil,
+        exp_month: nil,
+        exp_year: nil,
+        expand: nil,
+        financial_account: nil,
+        lifecycle_controls: nil,
+        metadata: nil,
+        personalization_design: nil,
+        pin: nil,
+        replacement_for: nil,
+        replacement_reason: nil,
+        second_line: nil,
+        shipping: nil,
+        spending_controls: nil,
+        status: nil,
+        type: nil
+      )
+        @cardholder = cardholder
+        @currency = currency
+        @exp_month = exp_month
+        @exp_year = exp_year
+        @expand = expand
+        @financial_account = financial_account
+        @lifecycle_controls = lifecycle_controls
+        @metadata = metadata
+        @personalization_design = personalization_design
+        @pin = pin
+        @replacement_for = replacement_for
+        @replacement_reason = replacement_reason
+        @second_line = second_line
+        @shipping = shipping
+        @spending_controls = spending_controls
+        @status = status
+        @type = type
+      end
+    end
+  end
+end

data/stripe-19.3.0/lib/stripe/params/issuing/card_deliver_card_params.rb

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module Issuing
+    class CardDeliverCardParams < ::Stripe::RequestParams
+      # Specifies which fields in the response should be expanded.
+      attr_accessor :expand
+
+      def initialize(expand: nil)
+        @expand = expand
+      end
+    end
+  end
+end

data/stripe-19.3.0/lib/stripe/params/issuing/card_fail_card_params.rb

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module Issuing
+    class CardFailCardParams < ::Stripe::RequestParams
+      # Specifies which fields in the response should be expanded.
+      attr_accessor :expand
+
+      def initialize(expand: nil)
+        @expand = expand
+      end
+    end
+  end
+end