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

data/rbi/lib/modern_treasury/models/ledger_event_handler.rbi

@@ -4,137 +4,94 @@ module ModernTreasury
   module Models
     class LedgerEventHandler < ModernTreasury::BaseModel
       sig { returns(String) }
-      def id
-      end
-
-      sig { params(_: String).returns(String) }
-      def id=(_)
-      end
+      attr_accessor :id
 
       sig { returns(T.nilable(ModernTreasury::Models::LedgerEventHandler::Conditions)) }
-      def conditions
-      end
+      attr_reader :conditions
 
       sig do
-        params(_: T.nilable(ModernTreasury::Models::LedgerEventHandler::Conditions))
-          .returns(T.nilable(ModernTreasury::Models::LedgerEventHandler::Conditions))
-      end
-      def conditions=(_)
+        params(
+          conditions: T.nilable(T.any(ModernTreasury::Models::LedgerEventHandler::Conditions, ModernTreasury::Util::AnyHash))
+        )
+          .void
       end
+      attr_writer :conditions
 
       sig { returns(Time) }
-      def created_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def created_at=(_)
-      end
+      attr_accessor :created_at
 
+      # An optional description.
       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 id of the ledger that this event handler belongs to.
       sig { returns(T.nilable(String)) }
-      def ledger_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def ledger_id=(_)
-      end
+      attr_accessor :ledger_id
 
       sig { returns(ModernTreasury::Models::LedgerEventHandler::LedgerTransactionTemplate) }
-      def ledger_transaction_template
-      end
+      attr_reader :ledger_transaction_template
 
       sig do
-        params(_: ModernTreasury::Models::LedgerEventHandler::LedgerTransactionTemplate)
-          .returns(ModernTreasury::Models::LedgerEventHandler::LedgerTransactionTemplate)
-      end
-      def ledger_transaction_template=(_)
+        params(
+          ledger_transaction_template: T.any(
+            ModernTreasury::Models::LedgerEventHandler::LedgerTransactionTemplate,
+            ModernTreasury::Util::AnyHash
+          )
+        )
+          .void
       end
+      attr_writer :ledger_transaction_template
 
+      # 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.nilable(T::Hash[Symbol, String])) }
-      def metadata
-      end
-
-      sig { params(_: T.nilable(T::Hash[Symbol, String])).returns(T.nilable(T::Hash[Symbol, String])) }
-      def metadata=(_)
-      end
+      attr_accessor :metadata
 
+      # Name of the ledger event handler.
       sig { returns(String) }
-      def name
-      end
-
-      sig { params(_: String).returns(String) }
-      def name=(_)
-      end
+      attr_accessor :name
 
       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 { returns(T.nilable(T::Hash[Symbol, ModernTreasury::Models::LedgerEventHandlerVariable])) }
-      def variables
-      end
-
-      sig do
-        params(_: T.nilable(T::Hash[Symbol, ModernTreasury::Models::LedgerEventHandlerVariable]))
-          .returns(T.nilable(T::Hash[Symbol, ModernTreasury::Models::LedgerEventHandlerVariable]))
-      end
-      def variables=(_)
-      end
+      attr_accessor :variables
 
       sig do
         params(
           id: String,
-          conditions: T.nilable(ModernTreasury::Models::LedgerEventHandler::Conditions),
+          conditions: T.nilable(T.any(ModernTreasury::Models::LedgerEventHandler::Conditions, ModernTreasury::Util::AnyHash)),
           created_at: Time,
           description: T.nilable(String),
           discarded_at: T.nilable(Time),
           ledger_id: T.nilable(String),
-          ledger_transaction_template: ModernTreasury::Models::LedgerEventHandler::LedgerTransactionTemplate,
+          ledger_transaction_template: T.any(
+            ModernTreasury::Models::LedgerEventHandler::LedgerTransactionTemplate,
+            ModernTreasury::Util::AnyHash
+          ),
           live_mode: T::Boolean,
           metadata: T.nilable(T::Hash[Symbol, String]),
           name: String,
           object: String,
           updated_at: Time,
-          variables: T.nilable(T::Hash[Symbol, ModernTreasury::Models::LedgerEventHandlerVariable])
+          variables: T.nilable(
+            T::Hash[Symbol, T.any(ModernTreasury::Models::LedgerEventHandlerVariable, ModernTreasury::Util::AnyHash)]
+          )
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         id:,
         conditions:,
         created_at:,
@@ -175,32 +132,20 @@ module ModernTreasury
       end
 
       class Conditions < ModernTreasury::BaseModel
+        # The LHS of the conditional.
         sig { returns(String) }
-        def field
-        end
-
-        sig { params(_: String).returns(String) }
-        def field=(_)
-        end
+        attr_accessor :field
 
+        # What the operator between the `field` and `value` is.
         sig { returns(String) }
-        def operator
-        end
-
-        sig { params(_: String).returns(String) }
-        def operator=(_)
-        end
+        attr_accessor :operator
 
+        # The RHS of the conditional.
         sig { returns(String) }
-        def value
-        end
+        attr_accessor :value
 
-        sig { params(_: String).returns(String) }
-        def value=(_)
-        end
-
-        sig { params(field: String, operator: String, value: String).void }
-        def initialize(field:, operator:, value:)
+        sig { params(field: String, operator: String, value: String).returns(T.attached_class) }
+        def self.new(field:, operator:, value:)
         end
 
         sig { override.returns({field: String, operator: String, value: String}) }
@@ -209,51 +154,38 @@ module ModernTreasury
       end
 
       class LedgerTransactionTemplate < ModernTreasury::BaseModel
+        # An optional 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
 
+        # The timestamp (ISO8601 format) at which the ledger transaction happened for
+        #   reporting purposes.
         sig { returns(T.nilable(String)) }
-        def effective_at
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def effective_at=(_)
-        end
+        attr_accessor :effective_at
 
+        # An array of ledger entry objects.
         sig { returns(T::Array[ModernTreasury::Models::LedgerEventHandler::LedgerTransactionTemplate::LedgerEntry]) }
-        def ledger_entries
-        end
-
-        sig do
-          params(_: T::Array[ModernTreasury::Models::LedgerEventHandler::LedgerTransactionTemplate::LedgerEntry])
-            .returns(T::Array[ModernTreasury::Models::LedgerEventHandler::LedgerTransactionTemplate::LedgerEntry])
-        end
-        def ledger_entries=(_)
-        end
+        attr_accessor :ledger_entries
 
+        # To post a ledger transaction at creation, use `posted`.
         sig { returns(T.nilable(String)) }
-        def status
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def status=(_)
-        end
+        attr_accessor :status
 
         sig do
           params(
             description: T.nilable(String),
             effective_at: T.nilable(String),
-            ledger_entries: T::Array[ModernTreasury::Models::LedgerEventHandler::LedgerTransactionTemplate::LedgerEntry],
+            ledger_entries: T::Array[
+            T.any(
+              ModernTreasury::Models::LedgerEventHandler::LedgerTransactionTemplate::LedgerEntry,
+              ModernTreasury::Util::AnyHash
+            )
+            ],
             status: T.nilable(String)
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(description:, effective_at:, ledger_entries:, status:)
+        def self.new(description:, effective_at:, ledger_entries:, status:)
         end
 
         sig do
@@ -271,32 +203,22 @@ module ModernTreasury
         end
 
         class LedgerEntry < ModernTreasury::BaseModel
+          # The LHS of the conditional.
           sig { returns(String) }
-          def amount
-          end
-
-          sig { params(_: String).returns(String) }
-          def amount=(_)
-          end
+          attr_accessor :amount
 
+          # What the operator between the `field` and `value` is.
           sig { returns(String) }
-          def direction
-          end
-
-          sig { params(_: String).returns(String) }
-          def direction=(_)
-          end
+          attr_accessor :direction
 
+          # The RHS of the conditional.
           sig { returns(String) }
-          def ledger_account_id
-          end
+          attr_accessor :ledger_account_id
 
-          sig { params(_: String).returns(String) }
-          def ledger_account_id=(_)
+          sig do
+            params(amount: String, direction: String, ledger_account_id: String).returns(T.attached_class)
           end
-
-          sig { params(amount: String, direction: String, ledger_account_id: String).void }
-          def initialize(amount:, direction:, ledger_account_id:)
+          def self.new(amount:, direction:, ledger_account_id:)
           end
 
           sig { override.returns({amount: String, direction: String, ledger_account_id: String}) }

data/rbi/lib/modern_treasury/models/ledger_event_handler_create_params.rbi

@@ -7,84 +7,76 @@ module ModernTreasury
       include ModernTreasury::RequestParameters
 
       sig { returns(ModernTreasury::Models::LedgerEventHandlerCreateParams::LedgerTransactionTemplate) }
-      def ledger_transaction_template
-      end
+      attr_reader :ledger_transaction_template
 
       sig do
-        params(_: ModernTreasury::Models::LedgerEventHandlerCreateParams::LedgerTransactionTemplate)
-          .returns(ModernTreasury::Models::LedgerEventHandlerCreateParams::LedgerTransactionTemplate)
-      end
-      def ledger_transaction_template=(_)
+        params(
+          ledger_transaction_template: T.any(
+            ModernTreasury::Models::LedgerEventHandlerCreateParams::LedgerTransactionTemplate,
+            ModernTreasury::Util::AnyHash
+          )
+        )
+          .void
       end
+      attr_writer :ledger_transaction_template
 
+      # Name of the ledger event handler.
       sig { returns(String) }
-      def name
-      end
-
-      sig { params(_: String).returns(String) }
-      def name=(_)
-      end
+      attr_accessor :name
 
       sig { returns(T.nilable(ModernTreasury::Models::LedgerEventHandlerCreateParams::Conditions)) }
-      def conditions
-      end
+      attr_reader :conditions
 
       sig do
-        params(_: T.nilable(ModernTreasury::Models::LedgerEventHandlerCreateParams::Conditions))
-          .returns(T.nilable(ModernTreasury::Models::LedgerEventHandlerCreateParams::Conditions))
-      end
-      def conditions=(_)
+        params(
+          conditions: T.nilable(
+            T.any(ModernTreasury::Models::LedgerEventHandlerCreateParams::Conditions, ModernTreasury::Util::AnyHash)
+          )
+        )
+          .void
       end
+      attr_writer :conditions
 
+      # An optional description.
       sig { returns(T.nilable(String)) }
-      def description
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def description=(_)
-      end
+      attr_accessor :description
 
+      # The id of the ledger that this account belongs to.
       sig { returns(T.nilable(String)) }
-      def ledger_id
-      end
+      attr_reader :ledger_id
 
-      sig { params(_: String).returns(String) }
-      def ledger_id=(_)
-      end
+      sig { params(ledger_id: String).void }
+      attr_writer :ledger_id
 
+      # Additional data represented as key-value pairs. Both the key and value must be
+      #   strings.
       sig { returns(T.nilable(T::Hash[Symbol, String])) }
-      def metadata
-      end
-
-      sig { params(_: T.nilable(T::Hash[Symbol, String])).returns(T.nilable(T::Hash[Symbol, String])) }
-      def metadata=(_)
-      end
+      attr_accessor :metadata
 
       sig { returns(T.nilable(T::Hash[Symbol, ModernTreasury::Models::LedgerEventHandlerVariable])) }
-      def variables
-      end
-
-      sig do
-        params(_: T.nilable(T::Hash[Symbol, ModernTreasury::Models::LedgerEventHandlerVariable]))
-          .returns(T.nilable(T::Hash[Symbol, ModernTreasury::Models::LedgerEventHandlerVariable]))
-      end
-      def variables=(_)
-      end
+      attr_accessor :variables
 
       sig do
         params(
-          ledger_transaction_template: ModernTreasury::Models::LedgerEventHandlerCreateParams::LedgerTransactionTemplate,
+          ledger_transaction_template: T.any(
+            ModernTreasury::Models::LedgerEventHandlerCreateParams::LedgerTransactionTemplate,
+            ModernTreasury::Util::AnyHash
+          ),
           name: String,
-          conditions: T.nilable(ModernTreasury::Models::LedgerEventHandlerCreateParams::Conditions),
+          conditions: T.nilable(
+            T.any(ModernTreasury::Models::LedgerEventHandlerCreateParams::Conditions, ModernTreasury::Util::AnyHash)
+          ),
           description: T.nilable(String),
           ledger_id: String,
           metadata: T.nilable(T::Hash[Symbol, String]),
-          variables: T.nilable(T::Hash[Symbol, ModernTreasury::Models::LedgerEventHandlerVariable]),
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          variables: T.nilable(
+            T::Hash[Symbol, T.any(ModernTreasury::Models::LedgerEventHandlerVariable, ModernTreasury::Util::AnyHash)]
+          ),
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         ledger_transaction_template:,
         name:,
         conditions: nil,
@@ -115,59 +107,42 @@ module ModernTreasury
       end
 
       class LedgerTransactionTemplate < ModernTreasury::BaseModel
+        # An optional 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
 
+        # The timestamp (ISO8601 format) at which the ledger transaction happened for
+        #   reporting purposes.
         sig { returns(T.nilable(String)) }
-        def effective_at
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def effective_at=(_)
-        end
+        attr_accessor :effective_at
 
+        # An array of ledger entry objects.
         sig do
           returns(
             T::Array[ModernTreasury::Models::LedgerEventHandlerCreateParams::LedgerTransactionTemplate::LedgerEntry]
           )
         end
-        def ledger_entries
-        end
-
-        sig do
-          params(
-            _: T::Array[ModernTreasury::Models::LedgerEventHandlerCreateParams::LedgerTransactionTemplate::LedgerEntry]
-          )
-            .returns(
-              T::Array[ModernTreasury::Models::LedgerEventHandlerCreateParams::LedgerTransactionTemplate::LedgerEntry]
-            )
-        end
-        def ledger_entries=(_)
-        end
+        attr_accessor :ledger_entries
 
+        # To post a ledger transaction at creation, use `posted`.
         sig { returns(T.nilable(String)) }
-        def status
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def status=(_)
-        end
+        attr_accessor :status
 
         sig do
           params(
             description: T.nilable(String),
             effective_at: T.nilable(String),
-            ledger_entries: T::Array[ModernTreasury::Models::LedgerEventHandlerCreateParams::LedgerTransactionTemplate::LedgerEntry],
+            ledger_entries: T::Array[
+            T.any(
+              ModernTreasury::Models::LedgerEventHandlerCreateParams::LedgerTransactionTemplate::LedgerEntry,
+              ModernTreasury::Util::AnyHash
+            )
+            ],
             status: T.nilable(String)
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(description:, effective_at:, ledger_entries:, status:)
+        def self.new(description:, effective_at:, ledger_entries:, status:)
         end
 
         sig do
@@ -185,32 +160,22 @@ module ModernTreasury
         end
 
         class LedgerEntry < ModernTreasury::BaseModel
+          # The LHS of the conditional.
           sig { returns(String) }
-          def amount
-          end
-
-          sig { params(_: String).returns(String) }
-          def amount=(_)
-          end
+          attr_accessor :amount
 
+          # What the operator between the `field` and `value` is.
           sig { returns(String) }
-          def direction
-          end
-
-          sig { params(_: String).returns(String) }
-          def direction=(_)
-          end
+          attr_accessor :direction
 
+          # The RHS of the conditional.
           sig { returns(String) }
-          def ledger_account_id
-          end
+          attr_accessor :ledger_account_id
 
-          sig { params(_: String).returns(String) }
-          def ledger_account_id=(_)
+          sig do
+            params(amount: String, direction: String, ledger_account_id: String).returns(T.attached_class)
           end
-
-          sig { params(amount: String, direction: String, ledger_account_id: String).void }
-          def initialize(amount:, direction:, ledger_account_id:)
+          def self.new(amount:, direction:, ledger_account_id:)
           end
 
           sig { override.returns({amount: String, direction: String, ledger_account_id: String}) }
@@ -220,32 +185,20 @@ module ModernTreasury
       end
 
       class Conditions < ModernTreasury::BaseModel
+        # The LHS of the conditional.
         sig { returns(String) }
-        def field
-        end
-
-        sig { params(_: String).returns(String) }
-        def field=(_)
-        end
+        attr_accessor :field
 
+        # What the operator between the `field` and `value` is.
         sig { returns(String) }
-        def operator
-        end
-
-        sig { params(_: String).returns(String) }
-        def operator=(_)
-        end
+        attr_accessor :operator
 
+        # The RHS of the conditional.
         sig { returns(String) }
-        def value
-        end
-
-        sig { params(_: String).returns(String) }
-        def value=(_)
-        end
+        attr_accessor :value
 
-        sig { params(field: String, operator: String, value: String).void }
-        def initialize(field:, operator:, value:)
+        sig { params(field: String, operator: String, value: String).returns(T.attached_class) }
+        def self.new(field:, operator:, value:)
         end
 
         sig { override.returns({field: String, operator: String, value: String}) }

data/rbi/lib/modern_treasury/models/ledger_event_handler_delete_params.rbi

@@ -6,8 +6,11 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
-      sig { params(request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])).void }
-      def initialize(request_options: {})
+      sig do
+        params(request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
+          .returns(T.attached_class)
+      end
+      def self.new(request_options: {})
       end
 
       sig { override.returns({request_options: ModernTreasury::RequestOptions}) }