modern_treasury 0.1.0.pre.alpha.15 → 0.1.0.pre.alpha.16

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

@@ -4,105 +4,75 @@ module ModernTreasury
   module Models
     class LedgerAccountBalanceMonitor < ModernTreasury::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::Util::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::Util::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::Util::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::Util::AnyHash
+          ),
           description: T.nilable(String),
           discarded_at: T.nilable(Time),
           ledger_account_id: String,
@@ -111,9 +81,9 @@ module ModernTreasury
           object: String,
           updated_at: Time
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         id:,
         alert_condition:,
         created_at:,
@@ -150,32 +120,26 @@ module ModernTreasury
       end
 
       class AlertCondition < ModernTreasury::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
-
-        sig { params(_: Integer).returns(Integer) }
-        def value=(_)
-        end
+        attr_accessor :value
 
-        sig { params(field: String, operator: String, value: Integer).void }
-        def initialize(field:, operator:, value:)
+        # 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}) }
@@ -185,41 +149,42 @@ module ModernTreasury
 
       class CurrentLedgerAccountBalanceState < ModernTreasury::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::Util::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::Util::AnyHash
+            ),
             ledger_account_lock_version: Integer,
             triggered: T::Boolean
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(balances:, ledger_account_lock_version:, triggered:)
+        def self.new(balances:, ledger_account_lock_version:, triggered:)
         end
 
         sig do
@@ -236,72 +201,84 @@ module ModernTreasury
         end
 
         class Balances < ModernTreasury::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::Util::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::Util::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::Util::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::Util::AnyHash
+              ),
+              pending_balance: T.any(
+                ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances::PendingBalance,
+                ModernTreasury::Util::AnyHash
+              ),
+              posted_balance: T.any(
+                ModernTreasury::Models::LedgerAccountBalanceMonitor::CurrentLedgerAccountBalanceState::Balances::PostedBalance,
+                ModernTreasury::Util::AnyHash
+              )
             )
-              .void
+              .returns(T.attached_class)
           end
-          def initialize(available_balance:, pending_balance:, posted_balance:)
+          def self.new(available_balance:, pending_balance:, posted_balance:)
           end
 
           sig do
@@ -319,45 +296,26 @@ module ModernTreasury
 
           class AvailableBalance < ModernTreasury::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,9 +324,9 @@ module ModernTreasury
                 currency_exponent: Integer,
                 debits: Integer
               )
-                .void
+                .returns(T.attached_class)
             end
-            def initialize(amount:, credits:, currency:, currency_exponent:, debits:)
+            def self.new(amount:, credits:, currency:, currency_exponent:, debits:)
             end
 
             sig do
@@ -389,45 +347,23 @@ module ModernTreasury
 
           class PendingBalance < ModernTreasury::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,9 +372,9 @@ module ModernTreasury
                 currency_exponent: Integer,
                 debits: Integer
               )
-                .void
+                .returns(T.attached_class)
             end
-            def initialize(amount:, credits:, currency:, currency_exponent:, debits:)
+            def self.new(amount:, credits:, currency:, currency_exponent:, debits:)
             end
 
             sig do
@@ -459,45 +395,23 @@ module ModernTreasury
 
           class PostedBalance < ModernTreasury::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,9 +420,9 @@ module ModernTreasury
                 currency_exponent: Integer,
                 debits: Integer
               )
-                .void
+                .returns(T.attached_class)
             end
-            def initialize(amount:, credits:, currency:, currency_exponent:, debits:)
+            def self.new(amount:, credits:, currency:, currency_exponent:, debits:)
             end
 
             sig do