modern_treasury 0.1.0.pre.alpha.15 → 0.1.0.pre.alpha.17

data/rbi/lib/modern_treasury/models/ledger_account_statement_create_response.rbi

@@ -2,132 +2,97 @@
 
 module ModernTreasury
   module Models
-    class LedgerAccountStatementCreateResponse < ModernTreasury::BaseModel
+    class LedgerAccountStatementCreateResponse < ModernTreasury::Internal::Type::BaseModel
       sig { returns(String) }
-      def id
-      end
-
-      sig { params(_: String).returns(String) }
-      def id=(_)
-      end
+      attr_accessor :id
 
       sig { returns(Time) }
-      def created_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def created_at=(_)
-      end
+      attr_accessor :created_at
 
+      # The description of the ledger account statement.
       sig { returns(T.nilable(String)) }
-      def description
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def description=(_)
-      end
+      attr_accessor :description
 
+      # The inclusive lower bound of the effective_at timestamp of the ledger entries to
+      # be included in the ledger account statement.
       sig { returns(Time) }
-      def effective_at_lower_bound
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def effective_at_lower_bound=(_)
-      end
+      attr_accessor :effective_at_lower_bound
 
+      # The exclusive upper bound of the effective_at timestamp of the ledger entries to
+      # be included in the ledger account statement.
       sig { returns(Time) }
-      def effective_at_upper_bound
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def effective_at_upper_bound=(_)
-      end
+      attr_accessor :effective_at_upper_bound
 
+      # The pending, posted, and available balances for this ledger account at the
+      # `effective_at_upper_bound`. The posted balance is the sum of all posted entries
+      # on the account. The pending balance is the sum of all pending and posted entries
+      # on the account. The available balance is the posted incoming entries minus the
+      # sum of the pending and posted outgoing amounts.
       sig { returns(ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance) }
-      def ending_balance
-      end
+      attr_reader :ending_balance
 
       sig do
-        params(_: ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance)
-          .returns(ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance)
-      end
-      def ending_balance=(_)
+        params(
+          ending_balance: T.any(
+            ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance,
+            ModernTreasury::Internal::AnyHash
+          )
+        )
+          .void
       end
+      attr_writer :ending_balance
 
+      # The id of the ledger account whose ledger entries are queried against, and its
+      # balances are computed as a result.
       sig { returns(String) }
-      def ledger_account_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def ledger_account_id=(_)
-      end
+      attr_accessor :ledger_account_id
 
+      # Lock version of the ledger account at the time of statement generation.
       sig { returns(Integer) }
-      def ledger_account_lock_version
-      end
+      attr_accessor :ledger_account_lock_version
 
-      sig { params(_: Integer).returns(Integer) }
-      def ledger_account_lock_version=(_)
-      end
-
-      sig { returns(Symbol) }
-      def ledger_account_normal_balance
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def ledger_account_normal_balance=(_)
-      end
+      # The normal balance of the ledger account.
+      sig { returns(ModernTreasury::Models::TransactionDirection::TaggedSymbol) }
+      attr_accessor :ledger_account_normal_balance
 
+      # The id of the ledger that this ledger account statement belongs to.
       sig { returns(String) }
-      def ledger_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def ledger_id=(_)
-      end
+      attr_accessor :ledger_id
 
+      # This field will be true if this object exists in the live environment or false
+      # if it exists in the test environment.
       sig { returns(T::Boolean) }
-      def live_mode
-      end
-
-      sig { params(_: T::Boolean).returns(T::Boolean) }
-      def live_mode=(_)
-      end
+      attr_accessor :live_mode
 
+      # Additional data represented as key-value pairs. Both the key and value must be
+      # strings.
       sig { returns(T::Hash[Symbol, String]) }
-      def metadata
-      end
-
-      sig { params(_: T::Hash[Symbol, String]).returns(T::Hash[Symbol, String]) }
-      def metadata=(_)
-      end
+      attr_accessor :metadata
 
       sig { returns(String) }
-      def object
-      end
-
-      sig { params(_: String).returns(String) }
-      def object=(_)
-      end
+      attr_accessor :object
 
+      # The pending, posted, and available balances for this ledger account at the
+      # `effective_at_lower_bound`. The posted balance is the sum of all posted entries
+      # on the account. The pending balance is the sum of all pending and posted entries
+      # on the account. The available balance is the posted incoming entries minus the
+      # sum of the pending and posted outgoing amounts.
       sig { returns(ModernTreasury::Models::LedgerAccountStatementCreateResponse::StartingBalance) }
-      def starting_balance
-      end
+      attr_reader :starting_balance
 
       sig do
-        params(_: ModernTreasury::Models::LedgerAccountStatementCreateResponse::StartingBalance)
-          .returns(ModernTreasury::Models::LedgerAccountStatementCreateResponse::StartingBalance)
-      end
-      def starting_balance=(_)
+        params(
+          starting_balance: T.any(
+            ModernTreasury::Models::LedgerAccountStatementCreateResponse::StartingBalance,
+            ModernTreasury::Internal::AnyHash
+          )
+        )
+          .void
       end
+      attr_writer :starting_balance
 
       sig { returns(Time) }
-      def updated_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def updated_at=(_)
-      end
+      attr_accessor :updated_at
 
       sig do
         params(
@@ -136,20 +101,26 @@ module ModernTreasury
           description: T.nilable(String),
           effective_at_lower_bound: Time,
           effective_at_upper_bound: Time,
-          ending_balance: ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance,
+          ending_balance: T.any(
+            ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance,
+            ModernTreasury::Internal::AnyHash
+          ),
           ledger_account_id: String,
           ledger_account_lock_version: Integer,
-          ledger_account_normal_balance: Symbol,
+          ledger_account_normal_balance: ModernTreasury::Models::TransactionDirection::OrSymbol,
           ledger_id: String,
           live_mode: T::Boolean,
           metadata: T::Hash[Symbol, String],
           object: String,
-          starting_balance: ModernTreasury::Models::LedgerAccountStatementCreateResponse::StartingBalance,
+          starting_balance: T.any(
+            ModernTreasury::Models::LedgerAccountStatementCreateResponse::StartingBalance,
+            ModernTreasury::Internal::AnyHash
+          ),
           updated_at: Time
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         id:,
         created_at:,
         description:,
@@ -165,9 +136,7 @@ module ModernTreasury
         object:,
         starting_balance:,
         updated_at:
-      )
-      end
-
+      ); end
       sig do
         override
           .returns(
@@ -180,7 +149,7 @@ module ModernTreasury
               ending_balance: ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance,
               ledger_account_id: String,
               ledger_account_lock_version: Integer,
-              ledger_account_normal_balance: Symbol,
+              ledger_account_normal_balance: ModernTreasury::Models::TransactionDirection::TaggedSymbol,
               ledger_id: String,
               live_mode: T::Boolean,
               metadata: T::Hash[Symbol, String],
@@ -190,53 +159,80 @@ module ModernTreasury
             }
           )
       end
-      def to_hash
-      end
+      def to_hash; end
 
-      class EndingBalance < ModernTreasury::BaseModel
+      class EndingBalance < ModernTreasury::Internal::Type::BaseModel
+        # The available_balance is the sum of all posted inbound entries and pending
+        # outbound entries. For credit normal, available_amount = posted_credits -
+        # pending_debits; for debit normal, available_amount = posted_debits -
+        # pending_credits.
         sig { returns(ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance::AvailableBalance) }
-        def available_balance
-        end
+        attr_reader :available_balance
 
         sig do
-          params(_: ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance::AvailableBalance)
-            .returns(ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance::AvailableBalance)
-        end
-        def available_balance=(_)
+          params(
+            available_balance: T.any(
+              ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance::AvailableBalance,
+              ModernTreasury::Internal::AnyHash
+            )
+          )
+            .void
         end
+        attr_writer :available_balance
 
+        # The pending_balance is the sum of all pending and posted entries.
         sig { returns(ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance::PendingBalance) }
-        def pending_balance
-        end
+        attr_reader :pending_balance
 
         sig do
-          params(_: ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance::PendingBalance)
-            .returns(ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance::PendingBalance)
-        end
-        def pending_balance=(_)
+          params(
+            pending_balance: T.any(
+              ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance::PendingBalance,
+              ModernTreasury::Internal::AnyHash
+            )
+          )
+            .void
         end
+        attr_writer :pending_balance
 
+        # The posted_balance is the sum of all posted entries.
         sig { returns(ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance::PostedBalance) }
-        def posted_balance
-        end
+        attr_reader :posted_balance
 
         sig do
-          params(_: ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance::PostedBalance)
-            .returns(ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance::PostedBalance)
-        end
-        def posted_balance=(_)
+          params(
+            posted_balance: T.any(
+              ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance::PostedBalance,
+              ModernTreasury::Internal::AnyHash
+            )
+          )
+            .void
         end
+        attr_writer :posted_balance
 
+        # The pending, posted, and available balances for this ledger account at the
+        # `effective_at_upper_bound`. The posted balance is the sum of all posted entries
+        # on the account. The pending balance is the sum of all pending and posted entries
+        # on the account. The available balance is the posted incoming entries minus the
+        # sum of the pending and posted outgoing amounts.
         sig do
           params(
-            available_balance: ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance::AvailableBalance,
-            pending_balance: ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance::PendingBalance,
-            posted_balance: ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance::PostedBalance
+            available_balance: T.any(
+              ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance::AvailableBalance,
+              ModernTreasury::Internal::AnyHash
+            ),
+            pending_balance: T.any(
+              ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance::PendingBalance,
+              ModernTreasury::Internal::AnyHash
+            ),
+            posted_balance: T.any(
+              ModernTreasury::Models::LedgerAccountStatementCreateResponse::EndingBalance::PostedBalance,
+              ModernTreasury::Internal::AnyHash
+            )
           )
-            .void
-        end
-        def initialize(available_balance:, pending_balance:, posted_balance:)
+            .returns(T.attached_class)
         end
+        def self.new(available_balance:, pending_balance:, posted_balance:); end
 
         sig do
           override
@@ -248,50 +244,30 @@ module ModernTreasury
               }
             )
         end
-        def to_hash
-        end
+        def to_hash; end
 
-        class AvailableBalance < ModernTreasury::BaseModel
+        class AvailableBalance < ModernTreasury::Internal::Type::BaseModel
           sig { returns(Integer) }
-          def amount
-          end
-
-          sig { params(_: Integer).returns(Integer) }
-          def amount=(_)
-          end
+          attr_accessor :amount
 
           sig { returns(Integer) }
-          def credits
-          end
-
-          sig { params(_: Integer).returns(Integer) }
-          def credits=(_)
-          end
+          attr_accessor :credits
 
+          # The currency of the ledger account.
           sig { returns(String) }
-          def currency
-          end
-
-          sig { params(_: String).returns(String) }
-          def currency=(_)
-          end
+          attr_accessor :currency
 
+          # The currency exponent of the ledger account.
           sig { returns(Integer) }
-          def currency_exponent
-          end
-
-          sig { params(_: Integer).returns(Integer) }
-          def currency_exponent=(_)
-          end
+          attr_accessor :currency_exponent
 
           sig { returns(Integer) }
-          def debits
-          end
-
-          sig { params(_: Integer).returns(Integer) }
-          def debits=(_)
-          end
+          attr_accessor :debits
 
+          # The available_balance is the sum of all posted inbound entries and pending
+          # outbound entries. For credit normal, available_amount = posted_credits -
+          # pending_debits; for debit normal, available_amount = posted_debits -
+          # pending_credits.
           sig do
             params(
               amount: Integer,
@@ -300,10 +276,9 @@ module ModernTreasury
               currency_exponent: Integer,
               debits: Integer
             )
-              .void
-          end
-          def initialize(amount:, credits:, currency:, currency_exponent:, debits:)
+              .returns(T.attached_class)
           end
+          def self.new(amount:, credits:, currency:, currency_exponent:, debits:); end
 
           sig do
             override
@@ -317,51 +292,28 @@ module ModernTreasury
                 }
               )
           end
-          def to_hash
-          end
+          def to_hash; end
         end
 
-        class PendingBalance < ModernTreasury::BaseModel
+        class PendingBalance < ModernTreasury::Internal::Type::BaseModel
           sig { returns(Integer) }
-          def amount
-          end
-
-          sig { params(_: Integer).returns(Integer) }
-          def amount=(_)
-          end
+          attr_accessor :amount
 
           sig { returns(Integer) }
-          def credits
-          end
-
-          sig { params(_: Integer).returns(Integer) }
-          def credits=(_)
-          end
+          attr_accessor :credits
 
+          # The currency of the ledger account.
           sig { returns(String) }
-          def currency
-          end
-
-          sig { params(_: String).returns(String) }
-          def currency=(_)
-          end
+          attr_accessor :currency
 
+          # The currency exponent of the ledger account.
           sig { returns(Integer) }
-          def currency_exponent
-          end
-
-          sig { params(_: Integer).returns(Integer) }
-          def currency_exponent=(_)
-          end
+          attr_accessor :currency_exponent
 
           sig { returns(Integer) }
-          def debits
-          end
-
-          sig { params(_: Integer).returns(Integer) }
-          def debits=(_)
-          end
+          attr_accessor :debits
 
+          # The pending_balance is the sum of all pending and posted entries.
           sig do
             params(
               amount: Integer,
@@ -370,10 +322,9 @@ module ModernTreasury
               currency_exponent: Integer,
               debits: Integer
             )
-              .void
-          end
-          def initialize(amount:, credits:, currency:, currency_exponent:, debits:)
+              .returns(T.attached_class)
           end
+          def self.new(amount:, credits:, currency:, currency_exponent:, debits:); end
 
           sig do
             override
@@ -387,51 +338,28 @@ module ModernTreasury
                 }
               )
           end
-          def to_hash
-          end
+          def to_hash; end
         end
 
-        class PostedBalance < ModernTreasury::BaseModel
+        class PostedBalance < ModernTreasury::Internal::Type::BaseModel
           sig { returns(Integer) }
-          def amount
-          end
-
-          sig { params(_: Integer).returns(Integer) }
-          def amount=(_)
-          end
+          attr_accessor :amount
 
           sig { returns(Integer) }
-          def credits
-          end
-
-          sig { params(_: Integer).returns(Integer) }
-          def credits=(_)
-          end
+          attr_accessor :credits
 
+          # The currency of the ledger account.
           sig { returns(String) }
-          def currency
-          end
-
-          sig { params(_: String).returns(String) }
-          def currency=(_)
-          end
+          attr_accessor :currency
 
+          # The currency exponent of the ledger account.
           sig { returns(Integer) }
-          def currency_exponent
-          end
-
-          sig { params(_: Integer).returns(Integer) }
-          def currency_exponent=(_)
-          end
+          attr_accessor :currency_exponent
 
           sig { returns(Integer) }
-          def debits
-          end
-
-          sig { params(_: Integer).returns(Integer) }
-          def debits=(_)
-          end
+          attr_accessor :debits
 
+          # The posted_balance is the sum of all posted entries.
           sig do
             params(
               amount: Integer,
@@ -440,10 +368,9 @@ module ModernTreasury
               currency_exponent: Integer,
               debits: Integer
             )
-              .void
-          end
-          def initialize(amount:, credits:, currency:, currency_exponent:, debits:)
+              .returns(T.attached_class)
           end
+          def self.new(amount:, credits:, currency:, currency_exponent:, debits:); end
 
           sig do
             override
@@ -457,55 +384,82 @@ module ModernTreasury
                 }
               )
           end
-          def to_hash
-          end
+          def to_hash; end
         end
       end
 
-      class StartingBalance < ModernTreasury::BaseModel
+      class StartingBalance < ModernTreasury::Internal::Type::BaseModel
+        # The available_balance is the sum of all posted inbound entries and pending
+        # outbound entries. For credit normal, available_amount = posted_credits -
+        # pending_debits; for debit normal, available_amount = posted_debits -
+        # pending_credits.
         sig { returns(ModernTreasury::Models::LedgerAccountStatementCreateResponse::StartingBalance::AvailableBalance) }
-        def available_balance
-        end
+        attr_reader :available_balance
 
         sig do
-          params(_: ModernTreasury::Models::LedgerAccountStatementCreateResponse::StartingBalance::AvailableBalance)
-            .returns(ModernTreasury::Models::LedgerAccountStatementCreateResponse::StartingBalance::AvailableBalance)
-        end
-        def available_balance=(_)
+          params(
+            available_balance: T.any(
+              ModernTreasury::Models::LedgerAccountStatementCreateResponse::StartingBalance::AvailableBalance,
+              ModernTreasury::Internal::AnyHash
+            )
+          )
+            .void
         end
+        attr_writer :available_balance
 
+        # The pending_balance is the sum of all pending and posted entries.
         sig { returns(ModernTreasury::Models::LedgerAccountStatementCreateResponse::StartingBalance::PendingBalance) }
-        def pending_balance
-        end
+        attr_reader :pending_balance
 
         sig do
-          params(_: ModernTreasury::Models::LedgerAccountStatementCreateResponse::StartingBalance::PendingBalance)
-            .returns(ModernTreasury::Models::LedgerAccountStatementCreateResponse::StartingBalance::PendingBalance)
-        end
-        def pending_balance=(_)
+          params(
+            pending_balance: T.any(
+              ModernTreasury::Models::LedgerAccountStatementCreateResponse::StartingBalance::PendingBalance,
+              ModernTreasury::Internal::AnyHash
+            )
+          )
+            .void
         end
+        attr_writer :pending_balance
 
+        # The posted_balance is the sum of all posted entries.
         sig { returns(ModernTreasury::Models::LedgerAccountStatementCreateResponse::StartingBalance::PostedBalance) }
-        def posted_balance
-        end
+        attr_reader :posted_balance
 
         sig do
-          params(_: ModernTreasury::Models::LedgerAccountStatementCreateResponse::StartingBalance::PostedBalance)
-            .returns(ModernTreasury::Models::LedgerAccountStatementCreateResponse::StartingBalance::PostedBalance)
-        end
-        def posted_balance=(_)
+          params(
+            posted_balance: T.any(
+              ModernTreasury::Models::LedgerAccountStatementCreateResponse::StartingBalance::PostedBalance,
+              ModernTreasury::Internal::AnyHash
+            )
+          )
+            .void
         end
+        attr_writer :posted_balance
 
+        # The pending, posted, and available balances for this ledger account at the
+        # `effective_at_lower_bound`. The posted balance is the sum of all posted entries
+        # on the account. The pending balance is the sum of all pending and posted entries
+        # on the account. The available balance is the posted incoming entries minus the
+        # sum of the pending and posted outgoing amounts.
         sig do
           params(
-            available_balance: ModernTreasury::Models::LedgerAccountStatementCreateResponse::StartingBalance::AvailableBalance,
-            pending_balance: ModernTreasury::Models::LedgerAccountStatementCreateResponse::StartingBalance::PendingBalance,
-            posted_balance: ModernTreasury::Models::LedgerAccountStatementCreateResponse::StartingBalance::PostedBalance
+            available_balance: T.any(
+              ModernTreasury::Models::LedgerAccountStatementCreateResponse::StartingBalance::AvailableBalance,
+              ModernTreasury::Internal::AnyHash
+            ),
+            pending_balance: T.any(
+              ModernTreasury::Models::LedgerAccountStatementCreateResponse::StartingBalance::PendingBalance,
+              ModernTreasury::Internal::AnyHash
+            ),
+            posted_balance: T.any(
+              ModernTreasury::Models::LedgerAccountStatementCreateResponse::StartingBalance::PostedBalance,
+              ModernTreasury::Internal::AnyHash
+            )
           )
-            .void
-        end
-        def initialize(available_balance:, pending_balance:, posted_balance:)
+            .returns(T.attached_class)
         end
+        def self.new(available_balance:, pending_balance:, posted_balance:); end
 
         sig do
           override
@@ -517,50 +471,30 @@ module ModernTreasury
               }
             )
         end
-        def to_hash
-        end
+        def to_hash; end
 
-        class AvailableBalance < ModernTreasury::BaseModel
+        class AvailableBalance < ModernTreasury::Internal::Type::BaseModel
           sig { returns(Integer) }
-          def amount
-          end
-
-          sig { params(_: Integer).returns(Integer) }
-          def amount=(_)
-          end
+          attr_accessor :amount
 
           sig { returns(Integer) }
-          def credits
-          end
-
-          sig { params(_: Integer).returns(Integer) }
-          def credits=(_)
-          end
+          attr_accessor :credits
 
+          # The currency of the ledger account.
           sig { returns(String) }
-          def currency
-          end
-
-          sig { params(_: String).returns(String) }
-          def currency=(_)
-          end
+          attr_accessor :currency
 
+          # The currency exponent of the ledger account.
           sig { returns(Integer) }
-          def currency_exponent
-          end
-
-          sig { params(_: Integer).returns(Integer) }
-          def currency_exponent=(_)
-          end
+          attr_accessor :currency_exponent
 
           sig { returns(Integer) }
-          def debits
-          end
-
-          sig { params(_: Integer).returns(Integer) }
-          def debits=(_)
-          end
+          attr_accessor :debits
 
+          # The available_balance is the sum of all posted inbound entries and pending
+          # outbound entries. For credit normal, available_amount = posted_credits -
+          # pending_debits; for debit normal, available_amount = posted_debits -
+          # pending_credits.
           sig do
             params(
               amount: Integer,
@@ -569,10 +503,9 @@ module ModernTreasury
               currency_exponent: Integer,
               debits: Integer
             )
-              .void
-          end
-          def initialize(amount:, credits:, currency:, currency_exponent:, debits:)
+              .returns(T.attached_class)
           end
+          def self.new(amount:, credits:, currency:, currency_exponent:, debits:); end
 
           sig do
             override
@@ -586,51 +519,28 @@ module ModernTreasury
                 }
               )
           end
-          def to_hash
-          end
+          def to_hash; end
         end
 
-        class PendingBalance < ModernTreasury::BaseModel
+        class PendingBalance < ModernTreasury::Internal::Type::BaseModel
           sig { returns(Integer) }
-          def amount
-          end
-
-          sig { params(_: Integer).returns(Integer) }
-          def amount=(_)
-          end
+          attr_accessor :amount
 
           sig { returns(Integer) }
-          def credits
-          end
-
-          sig { params(_: Integer).returns(Integer) }
-          def credits=(_)
-          end
+          attr_accessor :credits
 
+          # The currency of the ledger account.
           sig { returns(String) }
-          def currency
-          end
-
-          sig { params(_: String).returns(String) }
-          def currency=(_)
-          end
+          attr_accessor :currency
 
+          # The currency exponent of the ledger account.
           sig { returns(Integer) }
-          def currency_exponent
-          end
-
-          sig { params(_: Integer).returns(Integer) }
-          def currency_exponent=(_)
-          end
+          attr_accessor :currency_exponent
 
           sig { returns(Integer) }
-          def debits
-          end
-
-          sig { params(_: Integer).returns(Integer) }
-          def debits=(_)
-          end
+          attr_accessor :debits
 
+          # The pending_balance is the sum of all pending and posted entries.
           sig do
             params(
               amount: Integer,
@@ -639,10 +549,9 @@ module ModernTreasury
               currency_exponent: Integer,
               debits: Integer
             )
-              .void
-          end
-          def initialize(amount:, credits:, currency:, currency_exponent:, debits:)
+              .returns(T.attached_class)
           end
+          def self.new(amount:, credits:, currency:, currency_exponent:, debits:); end
 
           sig do
             override
@@ -656,51 +565,28 @@ module ModernTreasury
                 }
               )
           end
-          def to_hash
-          end
+          def to_hash; end
         end
 
-        class PostedBalance < ModernTreasury::BaseModel
+        class PostedBalance < ModernTreasury::Internal::Type::BaseModel
           sig { returns(Integer) }
-          def amount
-          end
-
-          sig { params(_: Integer).returns(Integer) }
-          def amount=(_)
-          end
+          attr_accessor :amount
 
           sig { returns(Integer) }
-          def credits
-          end
-
-          sig { params(_: Integer).returns(Integer) }
-          def credits=(_)
-          end
+          attr_accessor :credits
 
+          # The currency of the ledger account.
           sig { returns(String) }
-          def currency
-          end
-
-          sig { params(_: String).returns(String) }
-          def currency=(_)
-          end
+          attr_accessor :currency
 
+          # The currency exponent of the ledger account.
           sig { returns(Integer) }
-          def currency_exponent
-          end
-
-          sig { params(_: Integer).returns(Integer) }
-          def currency_exponent=(_)
-          end
+          attr_accessor :currency_exponent
 
           sig { returns(Integer) }
-          def debits
-          end
-
-          sig { params(_: Integer).returns(Integer) }
-          def debits=(_)
-          end
+          attr_accessor :debits
 
+          # The posted_balance is the sum of all posted entries.
           sig do
             params(
               amount: Integer,
@@ -709,10 +595,9 @@ module ModernTreasury
               currency_exponent: Integer,
               debits: Integer
             )
-              .void
-          end
-          def initialize(amount:, credits:, currency:, currency_exponent:, debits:)
+              .returns(T.attached_class)
           end
+          def self.new(amount:, credits:, currency:, currency_exponent:, debits:); end
 
           sig do
             override
@@ -726,8 +611,7 @@ module ModernTreasury
                 }
               )
           end
-          def to_hash
-          end
+          def to_hash; end
         end
       end
     end