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

data/rbi/lib/modern_treasury/models/ledger_account_balance_monitor.rbi

@@ -2,107 +2,83 @@
 
 module ModernTreasury
   module Models
-    class LedgerAccountBalanceMonitor < ModernTreasury::BaseModel
+    class LedgerAccountBalanceMonitor < ModernTreasury::Internal::Type::BaseModel
       sig { returns(String) }
-      def id
-      end
-
-      sig { params(_: String).returns(String) }
-      def id=(_)
-      end
+      attr_accessor :id
 
+      # Describes the condition that must be satisfied for the monitor to be triggered.
       sig { returns(ModernTreasury::Models::LedgerAccountBalanceMonitor::AlertCondition) }
-      def alert_condition
-      end
+      attr_reader :alert_condition
 
       sig do
-        params(_: ModernTreasury::Models::LedgerAccountBalanceMonitor::AlertCondition)
-          .returns(ModernTreasury::Models::LedgerAccountBalanceMonitor::AlertCondition)
-      end
-      def alert_condition=(_)
+        params(
+          alert_condition: T.any(
+            ModernTreasury::Models::LedgerAccountBalanceMonitor::AlertCondition,
+            ModernTreasury::Internal::AnyHash
+          )
+        )
+          .void
       end
+      attr_writer :alert_condition
 
       sig { returns(Time) }
-      def created_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def created_at=(_)
-      end
+      attr_accessor :created_at
 
+      # The ledger account's balances and the monitor state as of the current ledger
+      # account lock version.
       sig { returns(ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState) }
-      def current_ledger_account_balance_state
-      end
+      attr_reader :current_ledger_account_balance_state
 
       sig do
-        params(_: ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState)
-          .returns(ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState)
-      end
-      def current_ledger_account_balance_state=(_)
+        params(
+          current_ledger_account_balance_state: T.any(
+            ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState,
+            ModernTreasury::Internal::AnyHash
+          )
+        )
+          .void
       end
+      attr_writer :current_ledger_account_balance_state
 
+      # An optional, free-form description for internal use.
       sig { returns(T.nilable(String)) }
-      def description
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def description=(_)
-      end
+      attr_accessor :description
 
       sig { returns(T.nilable(Time)) }
-      def discarded_at
-      end
-
-      sig { params(_: T.nilable(Time)).returns(T.nilable(Time)) }
-      def discarded_at=(_)
-      end
+      attr_accessor :discarded_at
 
+      # The ledger account associated with this balance monitor.
       sig { returns(String) }
-      def ledger_account_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def ledger_account_id=(_)
-      end
+      attr_accessor :ledger_account_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
 
       sig { returns(Time) }
-      def updated_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def updated_at=(_)
-      end
+      attr_accessor :updated_at
 
       sig do
         params(
           id: String,
-          alert_condition: ModernTreasury::Models::LedgerAccountBalanceMonitor::AlertCondition,
+          alert_condition: T.any(
+            ModernTreasury::Models::LedgerAccountBalanceMonitor::AlertCondition,
+            ModernTreasury::Internal::AnyHash
+          ),
           created_at: Time,
-          current_ledger_account_balance_state: ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState,
+          current_ledger_account_balance_state: T.any(
+            ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState,
+            ModernTreasury::Internal::AnyHash
+          ),
           description: T.nilable(String),
           discarded_at: T.nilable(Time),
           ledger_account_id: String,
@@ -111,9 +87,9 @@ module ModernTreasury
           object: String,
           updated_at: Time
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         id:,
         alert_condition:,
         created_at:,
@@ -125,9 +101,7 @@ module ModernTreasury
         metadata:,
         object:,
         updated_at:
-      )
-      end
-
+      ); end
       sig do
         override
           .returns(
@@ -146,81 +120,72 @@ module ModernTreasury
             }
           )
       end
-      def to_hash
-      end
+      def to_hash; end
 
-      class AlertCondition < ModernTreasury::BaseModel
+      class AlertCondition < ModernTreasury::Internal::Type::BaseModel
+        # One of `available_balance_amount`, `pending_balance_amount`,
+        # `posted_balance_amount`, `ledger_account_lock_version`.
         sig { returns(String) }
-        def field
-        end
-
-        sig { params(_: String).returns(String) }
-        def field=(_)
-        end
+        attr_accessor :field
 
+        # A logical operator to compare the `field` against the `value`. One of
+        # `less_than`, `less_than_or_equals`, `equals`, `greater_than_or_equals`,
+        # `greater_than`.
         sig { returns(String) }
-        def operator
-        end
-
-        sig { params(_: String).returns(String) }
-        def operator=(_)
-        end
+        attr_accessor :operator
 
+        # The monitor's `current_ledger_account_balance_state.triggered` will be `true`
+        # when comparing the `field` to this integer value using the `operator` is
+        # logically true.
         sig { returns(Integer) }
-        def value
-        end
+        attr_accessor :value
 
-        sig { params(_: Integer).returns(Integer) }
-        def value=(_)
-        end
-
-        sig { params(field: String, operator: String, value: Integer).void }
-        def initialize(field:, operator:, value:)
-        end
+        # Describes the condition that must be satisfied for the monitor to be triggered.
+        sig { params(field: String, operator: String, value: Integer).returns(T.attached_class) }
+        def self.new(field:, operator:, value:); end
 
         sig { override.returns({field: String, operator: String, value: Integer}) }
-        def to_hash
-        end
+        def to_hash; end
       end
 
-      class CurrentLedgerAccountBalanceState < ModernTreasury::BaseModel
+      class CurrentLedgerAccountBalanceState < ModernTreasury::Internal::Type::BaseModel
         sig { returns(ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances) }
-        def balances
-        end
+        attr_reader :balances
 
         sig do
-          params(_: ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances)
-            .returns(ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances)
-        end
-        def balances=(_)
+          params(
+            balances: T.any(
+              ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances,
+              ModernTreasury::Internal::AnyHash
+            )
+          )
+            .void
         end
+        attr_writer :balances
 
+        # The current lock version of the ledger account.
         sig { returns(Integer) }
-        def ledger_account_lock_version
-        end
-
-        sig { params(_: Integer).returns(Integer) }
-        def ledger_account_lock_version=(_)
-        end
+        attr_accessor :ledger_account_lock_version
 
+        # If `true`, the ledger account's balances satisfy the `alert_condition` at this
+        # lock version.
         sig { returns(T::Boolean) }
-        def triggered
-        end
-
-        sig { params(_: T::Boolean).returns(T::Boolean) }
-        def triggered=(_)
-        end
+        attr_accessor :triggered
 
+        # The ledger account's balances and the monitor state as of the current ledger
+        # account lock version.
         sig do
           params(
-            balances: ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances,
+            balances: T.any(
+              ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances,
+              ModernTreasury::Internal::AnyHash
+            ),
             ledger_account_lock_version: Integer,
             triggered: T::Boolean
           )
-            .void
-        end
-        def initialize(balances:, ledger_account_lock_version:, triggered:)
+            .returns(T.attached_class)
         end
+        def self.new(balances:, ledger_account_lock_version:, triggered:); end
 
         sig do
           override
@@ -232,77 +197,87 @@ module ModernTreasury
               }
             )
         end
-        def to_hash
-        end
+        def to_hash; end
 
-        class Balances < ModernTreasury::BaseModel
+        class Balances < 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 do
             returns(
               ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances::AvailableBalance
             )
           end
-          def available_balance
-          end
+          attr_reader :available_balance
 
           sig do
             params(
-              _: ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances::AvailableBalance
-            )
-              .returns(
-                ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances::AvailableBalance
+              available_balance: T.any(
+                ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances::AvailableBalance,
+                ModernTreasury::Internal::AnyHash
               )
+            )
+              .void
           end
-          def available_balance=(_)
-          end
+          attr_writer :available_balance
 
+          # The pending_balance is the sum of all pending and posted entries.
           sig do
             returns(
               ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances::PendingBalance
             )
           end
-          def pending_balance
-          end
+          attr_reader :pending_balance
 
           sig do
             params(
-              _: ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances::PendingBalance
-            )
-              .returns(
-                ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances::PendingBalance
+              pending_balance: T.any(
+                ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances::PendingBalance,
+                ModernTreasury::Internal::AnyHash
               )
+            )
+              .void
           end
-          def pending_balance=(_)
-          end
+          attr_writer :pending_balance
 
+          # The posted_balance is the sum of all posted entries.
           sig do
             returns(
               ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances::PostedBalance
             )
           end
-          def posted_balance
-          end
+          attr_reader :posted_balance
 
           sig do
             params(
-              _: ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances::PostedBalance
-            )
-              .returns(
-                ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances::PostedBalance
+              posted_balance: T.any(
+                ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances::PostedBalance,
+                ModernTreasury::Internal::AnyHash
               )
+            )
+              .void
           end
-          def posted_balance=(_)
-          end
+          attr_writer :posted_balance
 
           sig do
             params(
-              available_balance: ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances::AvailableBalance,
-              pending_balance: ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances::PendingBalance,
-              posted_balance: ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances::PostedBalance
+              available_balance: T.any(
+                ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances::AvailableBalance,
+                ModernTreasury::Internal::AnyHash
+              ),
+              pending_balance: T.any(
+                ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances::PendingBalance,
+                ModernTreasury::Internal::AnyHash
+              ),
+              posted_balance: T.any(
+                ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances::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
@@ -314,50 +289,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,
@@ -366,10 +321,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
@@ -383,51 +337,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,
@@ -436,10 +367,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
@@ -453,51 +383,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,
@@ -506,10 +413,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
@@ -523,8 +429,7 @@ module ModernTreasury
                   }
                 )
             end
-            def to_hash
-            end
+            def to_hash; end
           end
         end
       end