orb-billing 1.13.0 → 1.14.0

data/rbi/orb/models/customers/credits/ledger_create_entry_params.rbi

@@ -16,206 +16,50 @@ module Orb
               )
             end
 
-          # The number of credits to effect. Note that this is required for increment,
-          # decrement or void operations.
-          sig { returns(Float) }
-          attr_accessor :amount
-
-          sig do
-            returns(
-              Orb::Customers::Credits::LedgerCreateEntryParams::EntryType::OrSymbol
-            )
-          end
-          attr_accessor :entry_type
-
-          # The currency or custom pricing unit to use for this ledger entry. If this is a
-          # real-world currency, it must match the customer's invoicing currency.
-          sig { returns(T.nilable(String)) }
-          attr_accessor :currency
-
-          # Optional metadata that can be specified when adding ledger results via the API.
-          # For example, this can be used to note an increment refers to trial credits, or
-          # for noting corrections as a result of an incident, etc.
-          sig { returns(T.nilable(String)) }
-          attr_accessor :description
-
-          # An ISO 8601 format date that denotes when this credit balance should become
-          # available for use.
-          sig { returns(T.nilable(Time)) }
-          attr_accessor :effective_date
-
-          # An ISO 8601 format date that identifies the origination credit block to expire
-          sig { returns(T.nilable(Time)) }
-          attr_accessor :expiry_date
-
-          # Optional filter to specify which items this credit block applies to. If not
-          # specified, the block will apply to all items for the pricing unit.
-          sig do
-            returns(
-              T.nilable(
-                T::Array[
-                  Orb::Customers::Credits::LedgerCreateEntryParams::Filter
-                ]
-              )
-            )
-          end
-          attr_accessor :filters
-
-          # Passing `invoice_settings` automatically generates an invoice for the newly
-          # added credits. If `invoice_settings` is passed, you must specify
-          # per_unit_cost_basis, as the calculation of the invoice total is done on that
-          # basis.
-          sig do
-            returns(
-              T.nilable(
-                Orb::Customers::Credits::LedgerCreateEntryParams::InvoiceSettings
-              )
-            )
-          end
-          attr_reader :invoice_settings
-
-          sig do
-            params(
-              invoice_settings:
-                T.nilable(
-                  Orb::Customers::Credits::LedgerCreateEntryParams::InvoiceSettings::OrHash
-                )
-            ).void
-          end
-          attr_writer :invoice_settings
-
-          # User-specified key/value pairs for the resource. Individual keys can be removed
-          # by setting the value to `null`, and the entire metadata mapping can be cleared
-          # by setting `metadata` to `null`.
-          sig { returns(T.nilable(T::Hash[Symbol, T.nilable(String)])) }
-          attr_accessor :metadata
-
-          # Can only be specified when entry_type=increment. How much, in the customer's
-          # currency, a customer paid for a single credit in this block
-          sig { returns(T.nilable(String)) }
-          attr_accessor :per_unit_cost_basis
-
-          # A future date (specified in YYYY-MM-DD format) used for expiration change,
-          # denoting when credits transferred (as part of a partial block expiration) should
-          # expire.
-          sig { returns(Date) }
-          attr_accessor :target_expiry_date
-
-          # The ID of the block to reverse a decrement from.
           sig { returns(String) }
-          attr_accessor :block_id
+          attr_accessor :customer_id
 
-          # Can only be specified when `entry_type=void`. The reason for the void.
           sig do
             returns(
-              T.nilable(
-                Orb::Customers::Credits::LedgerCreateEntryParams::VoidReason::OrSymbol
+              T.any(
+                Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment,
+                Orb::Customers::Credits::LedgerCreateEntryParams::Body::Decrement,
+                Orb::Customers::Credits::LedgerCreateEntryParams::Body::ExpirationChange,
+                Orb::Customers::Credits::LedgerCreateEntryParams::Body::Void,
+                Orb::Customers::Credits::LedgerCreateEntryParams::Body::Amendment
               )
             )
           end
-          attr_accessor :void_reason
+          attr_accessor :body
 
           sig do
             params(
-              amount: Float,
-              entry_type:
-                Orb::Customers::Credits::LedgerCreateEntryParams::EntryType::OrSymbol,
-              target_expiry_date: Date,
-              block_id: String,
-              currency: T.nilable(String),
-              description: T.nilable(String),
-              effective_date: T.nilable(Time),
-              expiry_date: T.nilable(Time),
-              filters:
-                T.nilable(
-                  T::Array[
-                    Orb::Customers::Credits::LedgerCreateEntryParams::Filter::OrHash
-                  ]
-                ),
-              invoice_settings:
-                T.nilable(
-                  Orb::Customers::Credits::LedgerCreateEntryParams::InvoiceSettings::OrHash
-                ),
-              metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
-              per_unit_cost_basis: T.nilable(String),
-              void_reason:
-                T.nilable(
-                  Orb::Customers::Credits::LedgerCreateEntryParams::VoidReason::OrSymbol
+              customer_id: String,
+              body:
+                T.any(
+                  Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::OrHash,
+                  Orb::Customers::Credits::LedgerCreateEntryParams::Body::Decrement::OrHash,
+                  Orb::Customers::Credits::LedgerCreateEntryParams::Body::ExpirationChange::OrHash,
+                  Orb::Customers::Credits::LedgerCreateEntryParams::Body::Void::OrHash,
+                  Orb::Customers::Credits::LedgerCreateEntryParams::Body::Amendment::OrHash
                 ),
               request_options: Orb::RequestOptions::OrHash
             ).returns(T.attached_class)
           end
-          def self.new(
-            # The number of credits to effect. Note that this is required for increment,
-            # decrement or void operations.
-            amount:,
-            entry_type:,
-            # A future date (specified in YYYY-MM-DD format) used for expiration change,
-            # denoting when credits transferred (as part of a partial block expiration) should
-            # expire.
-            target_expiry_date:,
-            # The ID of the block to reverse a decrement from.
-            block_id:,
-            # The currency or custom pricing unit to use for this ledger entry. If this is a
-            # real-world currency, it must match the customer's invoicing currency.
-            currency: nil,
-            # Optional metadata that can be specified when adding ledger results via the API.
-            # For example, this can be used to note an increment refers to trial credits, or
-            # for noting corrections as a result of an incident, etc.
-            description: nil,
-            # An ISO 8601 format date that denotes when this credit balance should become
-            # available for use.
-            effective_date: nil,
-            # An ISO 8601 format date that identifies the origination credit block to expire
-            expiry_date: nil,
-            # Optional filter to specify which items this credit block applies to. If not
-            # specified, the block will apply to all items for the pricing unit.
-            filters: nil,
-            # Passing `invoice_settings` automatically generates an invoice for the newly
-            # added credits. If `invoice_settings` is passed, you must specify
-            # per_unit_cost_basis, as the calculation of the invoice total is done on that
-            # basis.
-            invoice_settings: nil,
-            # User-specified key/value pairs for the resource. Individual keys can be removed
-            # by setting the value to `null`, and the entire metadata mapping can be cleared
-            # by setting `metadata` to `null`.
-            metadata: nil,
-            # Can only be specified when entry_type=increment. How much, in the customer's
-            # currency, a customer paid for a single credit in this block
-            per_unit_cost_basis: nil,
-            # Can only be specified when `entry_type=void`. The reason for the void.
-            void_reason: nil,
-            request_options: {}
-          )
+          def self.new(customer_id:, body:, request_options: {})
           end
 
           sig do
             override.returns(
               {
-                amount: Float,
-                entry_type:
-                  Orb::Customers::Credits::LedgerCreateEntryParams::EntryType::OrSymbol,
-                currency: T.nilable(String),
-                description: T.nilable(String),
-                effective_date: T.nilable(Time),
-                expiry_date: T.nilable(Time),
-                filters:
-                  T.nilable(
-                    T::Array[
-                      Orb::Customers::Credits::LedgerCreateEntryParams::Filter
-                    ]
-                  ),
-                invoice_settings:
-                  T.nilable(
-                    Orb::Customers::Credits::LedgerCreateEntryParams::InvoiceSettings
-                  ),
-                metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
-                per_unit_cost_basis: T.nilable(String),
-                target_expiry_date: Date,
-                block_id: String,
-                void_reason:
-                  T.nilable(
-                    Orb::Customers::Credits::LedgerCreateEntryParams::VoidReason::OrSymbol
+                customer_id: String,
+                body:
+                  T.any(
+                    Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment,
+                    Orb::Customers::Credits::LedgerCreateEntryParams::Body::Decrement,
+                    Orb::Customers::Credits::LedgerCreateEntryParams::Body::ExpirationChange,
+                    Orb::Customers::Credits::LedgerCreateEntryParams::Body::Void,
+                    Orb::Customers::Credits::LedgerCreateEntryParams::Body::Amendment
                   ),
                 request_options: Orb::RequestOptions
               }
@@ -224,375 +68,914 @@ module Orb
           def to_hash
           end
 
-          module EntryType
-            extend Orb::Internal::Type::Enum
+          module Body
+            extend Orb::Internal::Type::Union
 
-            TaggedSymbol =
+            Variants =
               T.type_alias do
-                T.all(
-                  Symbol,
-                  Orb::Customers::Credits::LedgerCreateEntryParams::EntryType
+                T.any(
+                  Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment,
+                  Orb::Customers::Credits::LedgerCreateEntryParams::Body::Decrement,
+                  Orb::Customers::Credits::LedgerCreateEntryParams::Body::ExpirationChange,
+                  Orb::Customers::Credits::LedgerCreateEntryParams::Body::Void,
+                  Orb::Customers::Credits::LedgerCreateEntryParams::Body::Amendment
                 )
               end
-            OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-            AMENDMENT =
-              T.let(
-                :amendment,
-                Orb::Customers::Credits::LedgerCreateEntryParams::EntryType::TaggedSymbol
-              )
+            class Increment < Orb::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment,
+                    Orb::Internal::AnyHash
+                  )
+                end
 
-            sig do
-              override.returns(
-                T::Array[
-                  Orb::Customers::Credits::LedgerCreateEntryParams::EntryType::TaggedSymbol
-                ]
-              )
-            end
-            def self.values
-            end
-          end
+              # The number of credits to effect. Note that this is required for increment,
+              # decrement, void, or undo operations.
+              sig { returns(Float) }
+              attr_accessor :amount
 
-          class Filter < Orb::Internal::Type::BaseModel
-            OrHash =
-              T.type_alias do
-                T.any(
-                  Orb::Customers::Credits::LedgerCreateEntryParams::Filter,
-                  Orb::Internal::AnyHash
+              sig { returns(Symbol) }
+              attr_accessor :entry_type
+
+              # The currency or custom pricing unit to use for this ledger entry. If this is a
+              # real-world currency, it must match the customer's invoicing currency.
+              sig { returns(T.nilable(String)) }
+              attr_accessor :currency
+
+              # Optional metadata that can be specified when adding ledger results via the API.
+              # For example, this can be used to note an increment refers to trial credits, or
+              # for noting corrections as a result of an incident, etc.
+              sig { returns(T.nilable(String)) }
+              attr_accessor :description
+
+              # An ISO 8601 format date that denotes when this credit balance should become
+              # available for use.
+              sig { returns(T.nilable(Time)) }
+              attr_accessor :effective_date
+
+              # An ISO 8601 format date that denotes when this credit balance should expire.
+              sig { returns(T.nilable(Time)) }
+              attr_accessor :expiry_date
+
+              # Optional filter to specify which items this credit block applies to. If not
+              # specified, the block will apply to all items for the pricing unit.
+              sig do
+                returns(
+                  T.nilable(
+                    T::Array[
+                      Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::Filter
+                    ]
+                  )
                 )
               end
+              attr_accessor :filters
 
-            # The property of the price the block applies to. Only item_id is supported.
-            sig do
-              returns(
-                Orb::Customers::Credits::LedgerCreateEntryParams::Filter::Field::OrSymbol
-              )
-            end
-            attr_accessor :field
+              # Passing `invoice_settings` automatically generates an invoice for the newly
+              # added credits. If `invoice_settings` is passed, you must specify
+              # per_unit_cost_basis, as the calculation of the invoice total is done on that
+              # basis.
+              sig do
+                returns(
+                  T.nilable(
+                    Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::InvoiceSettings
+                  )
+                )
+              end
+              attr_reader :invoice_settings
 
-            # Should prices that match the filter be included or excluded.
-            sig do
-              returns(
-                Orb::Customers::Credits::LedgerCreateEntryParams::Filter::Operator::OrSymbol
-              )
-            end
-            attr_accessor :operator
+              sig do
+                params(
+                  invoice_settings:
+                    T.nilable(
+                      Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::InvoiceSettings::OrHash
+                    )
+                ).void
+              end
+              attr_writer :invoice_settings
 
-            # The IDs or values that match this filter.
-            sig { returns(T::Array[String]) }
-            attr_accessor :values
+              # User-specified key/value pairs for the resource. Individual keys can be removed
+              # by setting the value to `null`, and the entire metadata mapping can be cleared
+              # by setting `metadata` to `null`.
+              sig { returns(T.nilable(T::Hash[Symbol, T.nilable(String)])) }
+              attr_accessor :metadata
 
-            # A PriceFilter that only allows item_id field for block filters.
-            sig do
-              params(
-                field:
-                  Orb::Customers::Credits::LedgerCreateEntryParams::Filter::Field::OrSymbol,
-                operator:
-                  Orb::Customers::Credits::LedgerCreateEntryParams::Filter::Operator::OrSymbol,
-                values: T::Array[String]
-              ).returns(T.attached_class)
-            end
-            def self.new(
-              # The property of the price the block applies to. Only item_id is supported.
-              field:,
-              # Should prices that match the filter be included or excluded.
-              operator:,
-              # The IDs or values that match this filter.
-              values:
-            )
-            end
+              # Can only be specified when entry_type=increment. How much, in the customer's
+              # currency, a customer paid for a single credit in this block
+              sig { returns(T.nilable(String)) }
+              attr_accessor :per_unit_cost_basis
 
-            sig do
-              override.returns(
-                {
-                  field:
-                    Orb::Customers::Credits::LedgerCreateEntryParams::Filter::Field::OrSymbol,
-                  operator:
-                    Orb::Customers::Credits::LedgerCreateEntryParams::Filter::Operator::OrSymbol,
-                  values: T::Array[String]
-                }
+              sig do
+                params(
+                  amount: Float,
+                  currency: T.nilable(String),
+                  description: T.nilable(String),
+                  effective_date: T.nilable(Time),
+                  expiry_date: T.nilable(Time),
+                  filters:
+                    T.nilable(
+                      T::Array[
+                        Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::Filter::OrHash
+                      ]
+                    ),
+                  invoice_settings:
+                    T.nilable(
+                      Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::InvoiceSettings::OrHash
+                    ),
+                  metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
+                  per_unit_cost_basis: T.nilable(String),
+                  entry_type: Symbol
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                # The number of credits to effect. Note that this is required for increment,
+                # decrement, void, or undo operations.
+                amount:,
+                # The currency or custom pricing unit to use for this ledger entry. If this is a
+                # real-world currency, it must match the customer's invoicing currency.
+                currency: nil,
+                # Optional metadata that can be specified when adding ledger results via the API.
+                # For example, this can be used to note an increment refers to trial credits, or
+                # for noting corrections as a result of an incident, etc.
+                description: nil,
+                # An ISO 8601 format date that denotes when this credit balance should become
+                # available for use.
+                effective_date: nil,
+                # An ISO 8601 format date that denotes when this credit balance should expire.
+                expiry_date: nil,
+                # Optional filter to specify which items this credit block applies to. If not
+                # specified, the block will apply to all items for the pricing unit.
+                filters: nil,
+                # Passing `invoice_settings` automatically generates an invoice for the newly
+                # added credits. If `invoice_settings` is passed, you must specify
+                # per_unit_cost_basis, as the calculation of the invoice total is done on that
+                # basis.
+                invoice_settings: nil,
+                # User-specified key/value pairs for the resource. Individual keys can be removed
+                # by setting the value to `null`, and the entire metadata mapping can be cleared
+                # by setting `metadata` to `null`.
+                metadata: nil,
+                # Can only be specified when entry_type=increment. How much, in the customer's
+                # currency, a customer paid for a single credit in this block
+                per_unit_cost_basis: nil,
+                entry_type: :increment
               )
-            end
-            def to_hash
-            end
+              end
 
-            # The property of the price the block applies to. Only item_id is supported.
-            module Field
-              extend Orb::Internal::Type::Enum
+              sig do
+                override.returns(
+                  {
+                    amount: Float,
+                    entry_type: Symbol,
+                    currency: T.nilable(String),
+                    description: T.nilable(String),
+                    effective_date: T.nilable(Time),
+                    expiry_date: T.nilable(Time),
+                    filters:
+                      T.nilable(
+                        T::Array[
+                          Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::Filter
+                        ]
+                      ),
+                    invoice_settings:
+                      T.nilable(
+                        Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::InvoiceSettings
+                      ),
+                    metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
+                    per_unit_cost_basis: T.nilable(String)
+                  }
+                )
+              end
+              def to_hash
+              end
 
-              TaggedSymbol =
-                T.type_alias do
-                  T.all(
-                    Symbol,
-                    Orb::Customers::Credits::LedgerCreateEntryParams::Filter::Field
+              class Filter < Orb::Internal::Type::BaseModel
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::Filter,
+                      Orb::Internal::AnyHash
+                    )
+                  end
+
+                # The property of the price the block applies to. Only item_id is supported.
+                sig do
+                  returns(
+                    Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::Filter::Field::OrSymbol
                   )
                 end
-              OrSymbol = T.type_alias { T.any(Symbol, String) }
+                attr_accessor :field
 
-              ITEM_ID =
-                T.let(
-                  :item_id,
-                  Orb::Customers::Credits::LedgerCreateEntryParams::Filter::Field::TaggedSymbol
+                # Should prices that match the filter be included or excluded.
+                sig do
+                  returns(
+                    Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::Filter::Operator::OrSymbol
+                  )
+                end
+                attr_accessor :operator
+
+                # The IDs or values that match this filter.
+                sig { returns(T::Array[String]) }
+                attr_accessor :values
+
+                # A PriceFilter that only allows item_id field for block filters.
+                sig do
+                  params(
+                    field:
+                      Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::Filter::Field::OrSymbol,
+                    operator:
+                      Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::Filter::Operator::OrSymbol,
+                    values: T::Array[String]
+                  ).returns(T.attached_class)
+                end
+                def self.new(
+                  # The property of the price the block applies to. Only item_id is supported.
+                  field:,
+                  # Should prices that match the filter be included or excluded.
+                  operator:,
+                  # The IDs or values that match this filter.
+                  values:
                 )
+                end
 
-              sig do
-                override.returns(
-                  T::Array[
-                    Orb::Customers::Credits::LedgerCreateEntryParams::Filter::Field::TaggedSymbol
-                  ]
-                )
+                sig do
+                  override.returns(
+                    {
+                      field:
+                        Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::Filter::Field::OrSymbol,
+                      operator:
+                        Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::Filter::Operator::OrSymbol,
+                      values: T::Array[String]
+                    }
+                  )
+                end
+                def to_hash
+                end
+
+                # The property of the price the block applies to. Only item_id is supported.
+                module Field
+                  extend Orb::Internal::Type::Enum
+
+                  TaggedSymbol =
+                    T.type_alias do
+                      T.all(
+                        Symbol,
+                        Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::Filter::Field
+                      )
+                    end
+                  OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+                  ITEM_ID =
+                    T.let(
+                      :item_id,
+                      Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::Filter::Field::TaggedSymbol
+                    )
+
+                  sig do
+                    override.returns(
+                      T::Array[
+                        Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::Filter::Field::TaggedSymbol
+                      ]
+                    )
+                  end
+                  def self.values
+                  end
+                end
+
+                # Should prices that match the filter be included or excluded.
+                module Operator
+                  extend Orb::Internal::Type::Enum
+
+                  TaggedSymbol =
+                    T.type_alias do
+                      T.all(
+                        Symbol,
+                        Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::Filter::Operator
+                      )
+                    end
+                  OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+                  INCLUDES =
+                    T.let(
+                      :includes,
+                      Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::Filter::Operator::TaggedSymbol
+                    )
+                  EXCLUDES =
+                    T.let(
+                      :excludes,
+                      Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::Filter::Operator::TaggedSymbol
+                    )
+
+                  sig do
+                    override.returns(
+                      T::Array[
+                        Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::Filter::Operator::TaggedSymbol
+                      ]
+                    )
+                  end
+                  def self.values
+                  end
+                end
               end
-              def self.values
+
+              class InvoiceSettings < Orb::Internal::Type::BaseModel
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::InvoiceSettings,
+                      Orb::Internal::AnyHash
+                    )
+                  end
+
+                # Whether the credits purchase invoice should auto collect with the customer's
+                # saved payment method.
+                sig { returns(T::Boolean) }
+                attr_accessor :auto_collection
+
+                # An optional custom due date for the invoice. If not set, the due date will be
+                # calculated based on the `net_terms` value.
+                sig do
+                  returns(
+                    T.nilable(
+                      Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::InvoiceSettings::CustomDueDate::Variants
+                    )
+                  )
+                end
+                attr_accessor :custom_due_date
+
+                # An ISO 8601 format date that denotes when this invoice should be dated in the
+                # customer's timezone. If not provided, the invoice date will default to the
+                # credit block's effective date.
+                sig do
+                  returns(
+                    T.nilable(
+                      Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::InvoiceSettings::InvoiceDate::Variants
+                    )
+                  )
+                end
+                attr_accessor :invoice_date
+
+                # The ID of the Item to be used for the invoice line item. If not provided, a
+                # default 'Credits' item will be used.
+                sig { returns(T.nilable(String)) }
+                attr_accessor :item_id
+
+                # If true, the new credits purchase invoice will be marked as paid.
+                sig { returns(T.nilable(T::Boolean)) }
+                attr_reader :mark_as_paid
+
+                sig { params(mark_as_paid: T::Boolean).void }
+                attr_writer :mark_as_paid
+
+                # An optional memo to display on the invoice.
+                sig { returns(T.nilable(String)) }
+                attr_accessor :memo
+
+                # The net terms determines the due date of the invoice. Due date is calculated
+                # based on the invoice or issuance date, depending on the account's configured due
+                # date calculation method. A value of '0' here represents that the invoice is due
+                # on issue, whereas a value of '30' represents that the customer has 30 days to
+                # pay the invoice. You must set either `net_terms` or `custom_due_date`, but not
+                # both.
+                sig { returns(T.nilable(Integer)) }
+                attr_accessor :net_terms
+
+                # If true, the new credit block will require that the corresponding invoice is
+                # paid before it can be drawn down from.
+                sig { returns(T.nilable(T::Boolean)) }
+                attr_reader :require_successful_payment
+
+                sig { params(require_successful_payment: T::Boolean).void }
+                attr_writer :require_successful_payment
+
+                # Passing `invoice_settings` automatically generates an invoice for the newly
+                # added credits. If `invoice_settings` is passed, you must specify
+                # per_unit_cost_basis, as the calculation of the invoice total is done on that
+                # basis.
+                sig do
+                  params(
+                    auto_collection: T::Boolean,
+                    custom_due_date:
+                      T.nilable(
+                        Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::InvoiceSettings::CustomDueDate::Variants
+                      ),
+                    invoice_date:
+                      T.nilable(
+                        Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::InvoiceSettings::InvoiceDate::Variants
+                      ),
+                    item_id: T.nilable(String),
+                    mark_as_paid: T::Boolean,
+                    memo: T.nilable(String),
+                    net_terms: T.nilable(Integer),
+                    require_successful_payment: T::Boolean
+                  ).returns(T.attached_class)
+                end
+                def self.new(
+                  # Whether the credits purchase invoice should auto collect with the customer's
+                  # saved payment method.
+                  auto_collection:,
+                  # An optional custom due date for the invoice. If not set, the due date will be
+                  # calculated based on the `net_terms` value.
+                  custom_due_date: nil,
+                  # An ISO 8601 format date that denotes when this invoice should be dated in the
+                  # customer's timezone. If not provided, the invoice date will default to the
+                  # credit block's effective date.
+                  invoice_date: nil,
+                  # The ID of the Item to be used for the invoice line item. If not provided, a
+                  # default 'Credits' item will be used.
+                  item_id: nil,
+                  # If true, the new credits purchase invoice will be marked as paid.
+                  mark_as_paid: nil,
+                  # An optional memo to display on the invoice.
+                  memo: nil,
+                  # The net terms determines the due date of the invoice. Due date is calculated
+                  # based on the invoice or issuance date, depending on the account's configured due
+                  # date calculation method. A value of '0' here represents that the invoice is due
+                  # on issue, whereas a value of '30' represents that the customer has 30 days to
+                  # pay the invoice. You must set either `net_terms` or `custom_due_date`, but not
+                  # both.
+                  net_terms: nil,
+                  # If true, the new credit block will require that the corresponding invoice is
+                  # paid before it can be drawn down from.
+                  require_successful_payment: nil
+                )
+                end
+
+                sig do
+                  override.returns(
+                    {
+                      auto_collection: T::Boolean,
+                      custom_due_date:
+                        T.nilable(
+                          Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::InvoiceSettings::CustomDueDate::Variants
+                        ),
+                      invoice_date:
+                        T.nilable(
+                          Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::InvoiceSettings::InvoiceDate::Variants
+                        ),
+                      item_id: T.nilable(String),
+                      mark_as_paid: T::Boolean,
+                      memo: T.nilable(String),
+                      net_terms: T.nilable(Integer),
+                      require_successful_payment: T::Boolean
+                    }
+                  )
+                end
+                def to_hash
+                end
+
+                # An optional custom due date for the invoice. If not set, the due date will be
+                # calculated based on the `net_terms` value.
+                module CustomDueDate
+                  extend Orb::Internal::Type::Union
+
+                  Variants = T.type_alias { T.any(Date, Time) }
+
+                  sig do
+                    override.returns(
+                      T::Array[
+                        Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::InvoiceSettings::CustomDueDate::Variants
+                      ]
+                    )
+                  end
+                  def self.variants
+                  end
+                end
+
+                # An ISO 8601 format date that denotes when this invoice should be dated in the
+                # customer's timezone. If not provided, the invoice date will default to the
+                # credit block's effective date.
+                module InvoiceDate
+                  extend Orb::Internal::Type::Union
+
+                  Variants = T.type_alias { T.any(Date, Time) }
+
+                  sig do
+                    override.returns(
+                      T::Array[
+                        Orb::Customers::Credits::LedgerCreateEntryParams::Body::Increment::InvoiceSettings::InvoiceDate::Variants
+                      ]
+                    )
+                  end
+                  def self.variants
+                  end
+                end
               end
             end
 
-            # Should prices that match the filter be included or excluded.
-            module Operator
-              extend Orb::Internal::Type::Enum
-
-              TaggedSymbol =
+            class Decrement < Orb::Internal::Type::BaseModel
+              OrHash =
                 T.type_alias do
-                  T.all(
-                    Symbol,
-                    Orb::Customers::Credits::LedgerCreateEntryParams::Filter::Operator
+                  T.any(
+                    Orb::Customers::Credits::LedgerCreateEntryParams::Body::Decrement,
+                    Orb::Internal::AnyHash
                   )
                 end
-              OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-              INCLUDES =
-                T.let(
-                  :includes,
-                  Orb::Customers::Credits::LedgerCreateEntryParams::Filter::Operator::TaggedSymbol
-                )
-              EXCLUDES =
-                T.let(
-                  :excludes,
-                  Orb::Customers::Credits::LedgerCreateEntryParams::Filter::Operator::TaggedSymbol
-                )
+              # The number of credits to effect. Note that this is required for increment,
+              # decrement, void, or undo operations.
+              sig { returns(Float) }
+              attr_accessor :amount
+
+              sig { returns(Symbol) }
+              attr_accessor :entry_type
+
+              # The currency or custom pricing unit to use for this ledger entry. If this is a
+              # real-world currency, it must match the customer's invoicing currency.
+              sig { returns(T.nilable(String)) }
+              attr_accessor :currency
+
+              # Optional metadata that can be specified when adding ledger results via the API.
+              # For example, this can be used to note an increment refers to trial credits, or
+              # for noting corrections as a result of an incident, etc.
+              sig { returns(T.nilable(String)) }
+              attr_accessor :description
+
+              # User-specified key/value pairs for the resource. Individual keys can be removed
+              # by setting the value to `null`, and the entire metadata mapping can be cleared
+              # by setting `metadata` to `null`.
+              sig { returns(T.nilable(T::Hash[Symbol, T.nilable(String)])) }
+              attr_accessor :metadata
+
+              sig do
+                params(
+                  amount: Float,
+                  currency: T.nilable(String),
+                  description: T.nilable(String),
+                  metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
+                  entry_type: Symbol
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                # The number of credits to effect. Note that this is required for increment,
+                # decrement, void, or undo operations.
+                amount:,
+                # The currency or custom pricing unit to use for this ledger entry. If this is a
+                # real-world currency, it must match the customer's invoicing currency.
+                currency: nil,
+                # Optional metadata that can be specified when adding ledger results via the API.
+                # For example, this can be used to note an increment refers to trial credits, or
+                # for noting corrections as a result of an incident, etc.
+                description: nil,
+                # User-specified key/value pairs for the resource. Individual keys can be removed
+                # by setting the value to `null`, and the entire metadata mapping can be cleared
+                # by setting `metadata` to `null`.
+                metadata: nil,
+                entry_type: :decrement
+              )
+              end
 
               sig do
                 override.returns(
-                  T::Array[
-                    Orb::Customers::Credits::LedgerCreateEntryParams::Filter::Operator::TaggedSymbol
-                  ]
+                  {
+                    amount: Float,
+                    entry_type: Symbol,
+                    currency: T.nilable(String),
+                    description: T.nilable(String),
+                    metadata: T.nilable(T::Hash[Symbol, T.nilable(String)])
+                  }
                 )
               end
-              def self.values
+              def to_hash
               end
             end
-          end
 
-          class InvoiceSettings < Orb::Internal::Type::BaseModel
-            OrHash =
-              T.type_alias do
-                T.any(
-                  Orb::Customers::Credits::LedgerCreateEntryParams::InvoiceSettings,
-                  Orb::Internal::AnyHash
-                )
-              end
+            class ExpirationChange < Orb::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Orb::Customers::Credits::LedgerCreateEntryParams::Body::ExpirationChange,
+                    Orb::Internal::AnyHash
+                  )
+                end
 
-            # Whether the credits purchase invoice should auto collect with the customer's
-            # saved payment method.
-            sig { returns(T::Boolean) }
-            attr_accessor :auto_collection
+              sig { returns(Symbol) }
+              attr_accessor :entry_type
+
+              # A future date (specified in YYYY-MM-DD format) used for expiration change,
+              # denoting when credits transferred (as part of a partial block expiration) should
+              # expire.
+              sig { returns(Date) }
+              attr_accessor :target_expiry_date
+
+              # The number of credits to effect. Note that this is required for increment,
+              # decrement, void, or undo operations.
+              sig { returns(T.nilable(Float)) }
+              attr_accessor :amount
+
+              # The ID of the block affected by an expiration_change, used to differentiate
+              # between multiple blocks with the same `expiry_date`.
+              sig { returns(T.nilable(String)) }
+              attr_accessor :block_id
+
+              # The currency or custom pricing unit to use for this ledger entry. If this is a
+              # real-world currency, it must match the customer's invoicing currency.
+              sig { returns(T.nilable(String)) }
+              attr_accessor :currency
+
+              # Optional metadata that can be specified when adding ledger results via the API.
+              # For example, this can be used to note an increment refers to trial credits, or
+              # for noting corrections as a result of an incident, etc.
+              sig { returns(T.nilable(String)) }
+              attr_accessor :description
+
+              # An ISO 8601 format date that identifies the origination credit block to expire
+              sig { returns(T.nilable(Time)) }
+              attr_accessor :expiry_date
+
+              # User-specified key/value pairs for the resource. Individual keys can be removed
+              # by setting the value to `null`, and the entire metadata mapping can be cleared
+              # by setting `metadata` to `null`.
+              sig { returns(T.nilable(T::Hash[Symbol, T.nilable(String)])) }
+              attr_accessor :metadata
 
-            # An optional custom due date for the invoice. If not set, the due date will be
-            # calculated based on the `net_terms` value.
-            sig do
-              returns(
-                T.nilable(
-                  Orb::Customers::Credits::LedgerCreateEntryParams::InvoiceSettings::CustomDueDate::Variants
-                )
+              sig do
+                params(
+                  target_expiry_date: Date,
+                  amount: T.nilable(Float),
+                  block_id: T.nilable(String),
+                  currency: T.nilable(String),
+                  description: T.nilable(String),
+                  expiry_date: T.nilable(Time),
+                  metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
+                  entry_type: Symbol
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                # A future date (specified in YYYY-MM-DD format) used for expiration change,
+                # denoting when credits transferred (as part of a partial block expiration) should
+                # expire.
+                target_expiry_date:,
+                # The number of credits to effect. Note that this is required for increment,
+                # decrement, void, or undo operations.
+                amount: nil,
+                # The ID of the block affected by an expiration_change, used to differentiate
+                # between multiple blocks with the same `expiry_date`.
+                block_id: nil,
+                # The currency or custom pricing unit to use for this ledger entry. If this is a
+                # real-world currency, it must match the customer's invoicing currency.
+                currency: nil,
+                # Optional metadata that can be specified when adding ledger results via the API.
+                # For example, this can be used to note an increment refers to trial credits, or
+                # for noting corrections as a result of an incident, etc.
+                description: nil,
+                # An ISO 8601 format date that identifies the origination credit block to expire
+                expiry_date: nil,
+                # User-specified key/value pairs for the resource. Individual keys can be removed
+                # by setting the value to `null`, and the entire metadata mapping can be cleared
+                # by setting `metadata` to `null`.
+                metadata: nil,
+                entry_type: :expiration_change
               )
-            end
-            attr_accessor :custom_due_date
+              end
 
-            # An ISO 8601 format date that denotes when this invoice should be dated in the
-            # customer's timezone. If not provided, the invoice date will default to the
-            # credit block's effective date.
-            sig do
-              returns(
-                T.nilable(
-                  Orb::Customers::Credits::LedgerCreateEntryParams::InvoiceSettings::InvoiceDate::Variants
+              sig do
+                override.returns(
+                  {
+                    entry_type: Symbol,
+                    target_expiry_date: Date,
+                    amount: T.nilable(Float),
+                    block_id: T.nilable(String),
+                    currency: T.nilable(String),
+                    description: T.nilable(String),
+                    expiry_date: T.nilable(Time),
+                    metadata: T.nilable(T::Hash[Symbol, T.nilable(String)])
+                  }
                 )
-              )
+              end
+              def to_hash
+              end
             end
-            attr_accessor :invoice_date
-
-            # The ID of the Item to be used for the invoice line item. If not provided, a
-            # default 'Credits' item will be used.
-            sig { returns(T.nilable(String)) }
-            attr_accessor :item_id
-
-            # If true, the new credits purchase invoice will be marked as paid.
-            sig { returns(T.nilable(T::Boolean)) }
-            attr_reader :mark_as_paid
-
-            sig { params(mark_as_paid: T::Boolean).void }
-            attr_writer :mark_as_paid
-
-            # An optional memo to display on the invoice.
-            sig { returns(T.nilable(String)) }
-            attr_accessor :memo
-
-            # The net terms determines the due date of the invoice. Due date is calculated
-            # based on the invoice or issuance date, depending on the account's configured due
-            # date calculation method. A value of '0' here represents that the invoice is due
-            # on issue, whereas a value of '30' represents that the customer has 30 days to
-            # pay the invoice. You must set either `net_terms` or `custom_due_date`, but not
-            # both.
-            sig { returns(T.nilable(Integer)) }
-            attr_accessor :net_terms
-
-            # If true, the new credit block will require that the corresponding invoice is
-            # paid before it can be drawn down from.
-            sig { returns(T.nilable(T::Boolean)) }
-            attr_reader :require_successful_payment
-
-            sig { params(require_successful_payment: T::Boolean).void }
-            attr_writer :require_successful_payment
-
-            # Passing `invoice_settings` automatically generates an invoice for the newly
-            # added credits. If `invoice_settings` is passed, you must specify
-            # per_unit_cost_basis, as the calculation of the invoice total is done on that
-            # basis.
-            sig do
-              params(
-                auto_collection: T::Boolean,
-                custom_due_date:
-                  T.nilable(
-                    Orb::Customers::Credits::LedgerCreateEntryParams::InvoiceSettings::CustomDueDate::Variants
-                  ),
-                invoice_date:
+
+            class Void < Orb::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Orb::Customers::Credits::LedgerCreateEntryParams::Body::Void,
+                    Orb::Internal::AnyHash
+                  )
+                end
+
+              # The number of credits to effect. Note that this is required for increment,
+              # decrement, void, or undo operations.
+              sig { returns(Float) }
+              attr_accessor :amount
+
+              # The ID of the block to void.
+              sig { returns(String) }
+              attr_accessor :block_id
+
+              sig { returns(Symbol) }
+              attr_accessor :entry_type
+
+              # The currency or custom pricing unit to use for this ledger entry. If this is a
+              # real-world currency, it must match the customer's invoicing currency.
+              sig { returns(T.nilable(String)) }
+              attr_accessor :currency
+
+              # Optional metadata that can be specified when adding ledger results via the API.
+              # For example, this can be used to note an increment refers to trial credits, or
+              # for noting corrections as a result of an incident, etc.
+              sig { returns(T.nilable(String)) }
+              attr_accessor :description
+
+              # User-specified key/value pairs for the resource. Individual keys can be removed
+              # by setting the value to `null`, and the entire metadata mapping can be cleared
+              # by setting `metadata` to `null`.
+              sig { returns(T.nilable(T::Hash[Symbol, T.nilable(String)])) }
+              attr_accessor :metadata
+
+              # Can only be specified when `entry_type=void`. The reason for the void.
+              sig do
+                returns(
                   T.nilable(
-                    Orb::Customers::Credits::LedgerCreateEntryParams::InvoiceSettings::InvoiceDate::Variants
-                  ),
-                item_id: T.nilable(String),
-                mark_as_paid: T::Boolean,
-                memo: T.nilable(String),
-                net_terms: T.nilable(Integer),
-                require_successful_payment: T::Boolean
-              ).returns(T.attached_class)
-            end
-            def self.new(
-              # Whether the credits purchase invoice should auto collect with the customer's
-              # saved payment method.
-              auto_collection:,
-              # An optional custom due date for the invoice. If not set, the due date will be
-              # calculated based on the `net_terms` value.
-              custom_due_date: nil,
-              # An ISO 8601 format date that denotes when this invoice should be dated in the
-              # customer's timezone. If not provided, the invoice date will default to the
-              # credit block's effective date.
-              invoice_date: nil,
-              # The ID of the Item to be used for the invoice line item. If not provided, a
-              # default 'Credits' item will be used.
-              item_id: nil,
-              # If true, the new credits purchase invoice will be marked as paid.
-              mark_as_paid: nil,
-              # An optional memo to display on the invoice.
-              memo: nil,
-              # The net terms determines the due date of the invoice. Due date is calculated
-              # based on the invoice or issuance date, depending on the account's configured due
-              # date calculation method. A value of '0' here represents that the invoice is due
-              # on issue, whereas a value of '30' represents that the customer has 30 days to
-              # pay the invoice. You must set either `net_terms` or `custom_due_date`, but not
-              # both.
-              net_terms: nil,
-              # If true, the new credit block will require that the corresponding invoice is
-              # paid before it can be drawn down from.
-              require_successful_payment: nil
-            )
-            end
+                    Orb::Customers::Credits::LedgerCreateEntryParams::Body::Void::VoidReason::OrSymbol
+                  )
+                )
+              end
+              attr_accessor :void_reason
 
-            sig do
-              override.returns(
-                {
-                  auto_collection: T::Boolean,
-                  custom_due_date:
-                    T.nilable(
-                      Orb::Customers::Credits::LedgerCreateEntryParams::InvoiceSettings::CustomDueDate::Variants
-                    ),
-                  invoice_date:
+              sig do
+                params(
+                  amount: Float,
+                  block_id: String,
+                  currency: T.nilable(String),
+                  description: T.nilable(String),
+                  metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
+                  void_reason:
                     T.nilable(
-                      Orb::Customers::Credits::LedgerCreateEntryParams::InvoiceSettings::InvoiceDate::Variants
+                      Orb::Customers::Credits::LedgerCreateEntryParams::Body::Void::VoidReason::OrSymbol
                     ),
-                  item_id: T.nilable(String),
-                  mark_as_paid: T::Boolean,
-                  memo: T.nilable(String),
-                  net_terms: T.nilable(Integer),
-                  require_successful_payment: T::Boolean
-                }
+                  entry_type: Symbol
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                # The number of credits to effect. Note that this is required for increment,
+                # decrement, void, or undo operations.
+                amount:,
+                # The ID of the block to void.
+                block_id:,
+                # The currency or custom pricing unit to use for this ledger entry. If this is a
+                # real-world currency, it must match the customer's invoicing currency.
+                currency: nil,
+                # Optional metadata that can be specified when adding ledger results via the API.
+                # For example, this can be used to note an increment refers to trial credits, or
+                # for noting corrections as a result of an incident, etc.
+                description: nil,
+                # User-specified key/value pairs for the resource. Individual keys can be removed
+                # by setting the value to `null`, and the entire metadata mapping can be cleared
+                # by setting `metadata` to `null`.
+                metadata: nil,
+                # Can only be specified when `entry_type=void`. The reason for the void.
+                void_reason: nil,
+                entry_type: :void
               )
-            end
-            def to_hash
-            end
-
-            # An optional custom due date for the invoice. If not set, the due date will be
-            # calculated based on the `net_terms` value.
-            module CustomDueDate
-              extend Orb::Internal::Type::Union
-
-              Variants = T.type_alias { T.any(Date, Time) }
+              end
 
               sig do
                 override.returns(
-                  T::Array[
-                    Orb::Customers::Credits::LedgerCreateEntryParams::InvoiceSettings::CustomDueDate::Variants
-                  ]
+                  {
+                    amount: Float,
+                    block_id: String,
+                    entry_type: Symbol,
+                    currency: T.nilable(String),
+                    description: T.nilable(String),
+                    metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
+                    void_reason:
+                      T.nilable(
+                        Orb::Customers::Credits::LedgerCreateEntryParams::Body::Void::VoidReason::OrSymbol
+                      )
+                  }
                 )
               end
-              def self.variants
+              def to_hash
+              end
+
+              # Can only be specified when `entry_type=void`. The reason for the void.
+              module VoidReason
+                extend Orb::Internal::Type::Enum
+
+                TaggedSymbol =
+                  T.type_alias do
+                    T.all(
+                      Symbol,
+                      Orb::Customers::Credits::LedgerCreateEntryParams::Body::Void::VoidReason
+                    )
+                  end
+                OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+                REFUND =
+                  T.let(
+                    :refund,
+                    Orb::Customers::Credits::LedgerCreateEntryParams::Body::Void::VoidReason::TaggedSymbol
+                  )
+
+                sig do
+                  override.returns(
+                    T::Array[
+                      Orb::Customers::Credits::LedgerCreateEntryParams::Body::Void::VoidReason::TaggedSymbol
+                    ]
+                  )
+                end
+                def self.values
+                end
               end
             end
 
-            # An ISO 8601 format date that denotes when this invoice should be dated in the
-            # customer's timezone. If not provided, the invoice date will default to the
-            # credit block's effective date.
-            module InvoiceDate
-              extend Orb::Internal::Type::Union
+            class Amendment < Orb::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Orb::Customers::Credits::LedgerCreateEntryParams::Body::Amendment,
+                    Orb::Internal::AnyHash
+                  )
+                end
+
+              # The number of credits to effect. Note that this is required for increment,
+              # decrement or void operations.
+              sig { returns(Float) }
+              attr_accessor :amount
+
+              # The ID of the block to reverse a decrement from.
+              sig { returns(String) }
+              attr_accessor :block_id
+
+              sig { returns(Symbol) }
+              attr_accessor :entry_type
+
+              # The currency or custom pricing unit to use for this ledger entry. If this is a
+              # real-world currency, it must match the customer's invoicing currency.
+              sig { returns(T.nilable(String)) }
+              attr_accessor :currency
+
+              # Optional metadata that can be specified when adding ledger results via the API.
+              # For example, this can be used to note an increment refers to trial credits, or
+              # for noting corrections as a result of an incident, etc.
+              sig { returns(T.nilable(String)) }
+              attr_accessor :description
 
-              Variants = T.type_alias { T.any(Date, Time) }
+              # User-specified key/value pairs for the resource. Individual keys can be removed
+              # by setting the value to `null`, and the entire metadata mapping can be cleared
+              # by setting `metadata` to `null`.
+              sig { returns(T.nilable(T::Hash[Symbol, T.nilable(String)])) }
+              attr_accessor :metadata
 
               sig do
-                override.returns(
-                  T::Array[
-                    Orb::Customers::Credits::LedgerCreateEntryParams::InvoiceSettings::InvoiceDate::Variants
-                  ]
-                )
+                params(
+                  amount: Float,
+                  block_id: String,
+                  currency: T.nilable(String),
+                  description: T.nilable(String),
+                  metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
+                  entry_type: Symbol
+                ).returns(T.attached_class)
               end
-              def self.variants
+              def self.new(
+                # The number of credits to effect. Note that this is required for increment,
+                # decrement or void operations.
+                amount:,
+                # The ID of the block to reverse a decrement from.
+                block_id:,
+                # The currency or custom pricing unit to use for this ledger entry. If this is a
+                # real-world currency, it must match the customer's invoicing currency.
+                currency: nil,
+                # Optional metadata that can be specified when adding ledger results via the API.
+                # For example, this can be used to note an increment refers to trial credits, or
+                # for noting corrections as a result of an incident, etc.
+                description: nil,
+                # User-specified key/value pairs for the resource. Individual keys can be removed
+                # by setting the value to `null`, and the entire metadata mapping can be cleared
+                # by setting `metadata` to `null`.
+                metadata: nil,
+                entry_type: :amendment
+              )
               end
-            end
-          end
-
-          # Can only be specified when `entry_type=void`. The reason for the void.
-          module VoidReason
-            extend Orb::Internal::Type::Enum
 
-            TaggedSymbol =
-              T.type_alias do
-                T.all(
-                  Symbol,
-                  Orb::Customers::Credits::LedgerCreateEntryParams::VoidReason
+              sig do
+                override.returns(
+                  {
+                    amount: Float,
+                    block_id: String,
+                    entry_type: Symbol,
+                    currency: T.nilable(String),
+                    description: T.nilable(String),
+                    metadata: T.nilable(T::Hash[Symbol, T.nilable(String)])
+                  }
                 )
               end
-            OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-            REFUND =
-              T.let(
-                :refund,
-                Orb::Customers::Credits::LedgerCreateEntryParams::VoidReason::TaggedSymbol
-              )
+              def to_hash
+              end
+            end
 
             sig do
               override.returns(
                 T::Array[
-                  Orb::Customers::Credits::LedgerCreateEntryParams::VoidReason::TaggedSymbol
+                  Orb::Customers::Credits::LedgerCreateEntryParams::Body::Variants
                 ]
               )
             end
-            def self.values
+            def self.variants
             end
           end
         end