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

data/rbi/lib/modern_treasury/models/ledger_account_settlement.rbi

@@ -4,140 +4,75 @@ module ModernTreasury
   module Models
     class LedgerAccountSettlement < ModernTreasury::BaseModel
       sig { returns(String) }
-      def id
-      end
-
-      sig { params(_: String).returns(String) }
-      def id=(_)
-      end
+      attr_accessor :id
 
+      # The amount of the ledger account settlement.
       sig { returns(T.nilable(Integer)) }
-      def amount
-      end
-
-      sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-      def amount=(_)
-      end
+      attr_accessor :amount
 
+      # The id of the contra ledger account that sends to or receives funds from the
+      #   settled ledger account.
       sig { returns(String) }
-      def contra_ledger_account_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def contra_ledger_account_id=(_)
-      end
+      attr_accessor :contra_ledger_account_id
 
       sig { returns(Time) }
-      def created_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def created_at=(_)
-      end
+      attr_accessor :created_at
 
+      # The currency of the ledger account settlement.
       sig { returns(String) }
-      def currency
-      end
-
-      sig { params(_: String).returns(String) }
-      def currency=(_)
-      end
+      attr_accessor :currency
 
+      # The currency exponent of the ledger account settlement.
       sig { returns(T.nilable(Integer)) }
-      def currency_exponent
-      end
-
-      sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-      def currency_exponent=(_)
-      end
+      attr_accessor :currency_exponent
 
+      # The description of the ledger account settlement.
       sig { returns(T.nilable(String)) }
-      def description
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def description=(_)
-      end
+      attr_accessor :description
 
+      # The exclusive upper bound of the effective_at timestamp of the ledger entries to
+      #   be included in the ledger account settlement. The default value is the
+      #   created_at timestamp of the ledger account settlement.
       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 id of the ledger that this ledger account settlement belongs to.
       sig { returns(String) }
-      def ledger_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def ledger_id=(_)
-      end
+      attr_accessor :ledger_id
 
+      # The id of the ledger transaction that this settlement is associated with.
       sig { returns(T.nilable(String)) }
-      def ledger_transaction_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def ledger_transaction_id=(_)
-      end
+      attr_accessor :ledger_transaction_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 id of the settled ledger account whose ledger entries are queried against,
+      #   and its balance is reduced as a result.
       sig { returns(String) }
-      def settled_ledger_account_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def settled_ledger_account_id=(_)
-      end
+      attr_accessor :settled_ledger_account_id
 
+      # The direction of the ledger entry with the settlement_ledger_account.
       sig { returns(T.nilable(String)) }
-      def settlement_entry_direction
-      end
+      attr_accessor :settlement_entry_direction
 
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def settlement_entry_direction=(_)
-      end
-
-      sig { returns(Symbol) }
-      def status
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def status=(_)
-      end
+      # The status of the ledger account settlement. One of `processing`, `pending`,
+      #   `posted`, `archiving` or `archived`.
+      sig { returns(ModernTreasury::Models::LedgerAccountSettlement::Status::TaggedSymbol) }
+      attr_accessor :status
 
       sig { returns(Time) }
-      def updated_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def updated_at=(_)
-      end
+      attr_accessor :updated_at
 
       sig do
         params(
@@ -156,12 +91,12 @@ module ModernTreasury
           object: String,
           settled_ledger_account_id: String,
           settlement_entry_direction: T.nilable(String),
-          status: Symbol,
+          status: ModernTreasury::Models::LedgerAccountSettlement::Status::OrSymbol,
           updated_at: Time
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         id:,
         amount:,
         contra_ledger_account_id:,
@@ -201,7 +136,7 @@ module ModernTreasury
               object: String,
               settled_ledger_account_id: String,
               settlement_entry_direction: T.nilable(String),
-              status: Symbol,
+              status: ModernTreasury::Models::LedgerAccountSettlement::Status::TaggedSymbol,
               updated_at: Time
             }
           )
@@ -209,17 +144,23 @@ module ModernTreasury
       def to_hash
       end
 
-      class Status < ModernTreasury::Enum
-        abstract!
+      # The status of the ledger account settlement. One of `processing`, `pending`,
+      #   `posted`, `archiving` or `archived`.
+      module Status
+        extend ModernTreasury::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::LedgerAccountSettlement::Status) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::LedgerAccountSettlement::Status::TaggedSymbol) }
 
-        ARCHIVED = :archived
-        ARCHIVING = :archiving
-        DRAFTING = :drafting
-        PENDING = :pending
-        POSTED = :posted
-        PROCESSING = :processing
+        ARCHIVED = T.let(:archived, ModernTreasury::Models::LedgerAccountSettlement::Status::TaggedSymbol)
+        ARCHIVING = T.let(:archiving, ModernTreasury::Models::LedgerAccountSettlement::Status::TaggedSymbol)
+        DRAFTING = T.let(:drafting, ModernTreasury::Models::LedgerAccountSettlement::Status::TaggedSymbol)
+        PENDING = T.let(:pending, ModernTreasury::Models::LedgerAccountSettlement::Status::TaggedSymbol)
+        POSTED = T.let(:posted, ModernTreasury::Models::LedgerAccountSettlement::Status::TaggedSymbol)
+        PROCESSING = T.let(:processing, ModernTreasury::Models::LedgerAccountSettlement::Status::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[ModernTreasury::Models::LedgerAccountSettlement::Status::TaggedSymbol]) }
         def self.values
         end
       end

data/rbi/lib/modern_treasury/models/ledger_account_settlement_create_params.rbi

@@ -6,69 +6,49 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
+      # The id of the contra ledger account that sends to or receives funds from the
+      #   settled ledger account.
       sig { returns(String) }
-      def contra_ledger_account_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def contra_ledger_account_id=(_)
-      end
+      attr_accessor :contra_ledger_account_id
 
+      # The id of the settled ledger account whose ledger entries are queried against,
+      #   and its balance is reduced as a result.
       sig { returns(String) }
-      def settled_ledger_account_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def settled_ledger_account_id=(_)
-      end
+      attr_accessor :settled_ledger_account_id
 
+      # If true, the settlement amount and settlement_entry_direction will bring the
+      #   settlement ledger account's balance closer to zero, even if the balance is
+      #   negative.
       sig { returns(T.nilable(T::Boolean)) }
-      def allow_either_direction
-      end
-
-      sig { params(_: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
-      def allow_either_direction=(_)
-      end
+      attr_accessor :allow_either_direction
 
+      # The description of the ledger account settlement.
       sig { returns(T.nilable(String)) }
-      def description
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def description=(_)
-      end
+      attr_accessor :description
 
+      # The exclusive upper bound of the effective_at timestamp of the ledger entries to
+      #   be included in the ledger account settlement. The default value is the
+      #   created_at timestamp of the ledger account settlement.
       sig { returns(T.nilable(Time)) }
-      def effective_at_upper_bound
-      end
-
-      sig { params(_: T.nilable(Time)).returns(T.nilable(Time)) }
-      def effective_at_upper_bound=(_)
-      end
+      attr_accessor :effective_at_upper_bound
 
+      # 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
+      attr_reader :metadata
 
-      sig { params(_: T::Hash[Symbol, String]).returns(T::Hash[Symbol, String]) }
-      def metadata=(_)
-      end
+      sig { params(metadata: T::Hash[Symbol, String]).void }
+      attr_writer :metadata
 
+      # It is set to `false` by default. It should be set to `true` when migrating
+      #   existing settlements.
       sig { returns(T.nilable(T::Boolean)) }
-      def skip_settlement_ledger_transaction
-      end
-
-      sig { params(_: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
-      def skip_settlement_ledger_transaction=(_)
-      end
-
-      sig { returns(T.nilable(Symbol)) }
-      def status
-      end
+      attr_accessor :skip_settlement_ledger_transaction
 
-      sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-      def status=(_)
-      end
+      # The status of the ledger account settlement. It is set to `pending` by default.
+      #   To post a ledger account settlement at creation, use `posted`.
+      sig { returns(T.nilable(ModernTreasury::Models::LedgerAccountSettlementCreateParams::Status::OrSymbol)) }
+      attr_accessor :status
 
       sig do
         params(
@@ -79,12 +59,12 @@ module ModernTreasury
           effective_at_upper_bound: T.nilable(Time),
           metadata: T::Hash[Symbol, String],
           skip_settlement_ledger_transaction: T.nilable(T::Boolean),
-          status: T.nilable(Symbol),
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          status: T.nilable(ModernTreasury::Models::LedgerAccountSettlementCreateParams::Status::OrSymbol),
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         contra_ledger_account_id:,
         settled_ledger_account_id:,
         allow_either_direction: nil,
@@ -108,7 +88,7 @@ module ModernTreasury
               effective_at_upper_bound: T.nilable(Time),
               metadata: T::Hash[Symbol, String],
               skip_settlement_ledger_transaction: T.nilable(T::Boolean),
-              status: T.nilable(Symbol),
+              status: T.nilable(ModernTreasury::Models::LedgerAccountSettlementCreateParams::Status::OrSymbol),
               request_options: ModernTreasury::RequestOptions
             }
           )
@@ -116,13 +96,25 @@ module ModernTreasury
       def to_hash
       end
 
-      class Status < ModernTreasury::Enum
-        abstract!
+      # The status of the ledger account settlement. It is set to `pending` by default.
+      #   To post a ledger account settlement at creation, use `posted`.
+      module Status
+        extend ModernTreasury::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::LedgerAccountSettlementCreateParams::Status) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::LedgerAccountSettlementCreateParams::Status::TaggedSymbol) }
 
-        PENDING = T.let(:pending, T.nilable(Symbol))
-        POSTED = T.let(:posted, T.nilable(Symbol))
+        PENDING =
+          T.let(:pending, ModernTreasury::Models::LedgerAccountSettlementCreateParams::Status::TaggedSymbol)
+        POSTED =
+          T.let(:posted, ModernTreasury::Models::LedgerAccountSettlementCreateParams::Status::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig do
+          override
+            .returns(T::Array[ModernTreasury::Models::LedgerAccountSettlementCreateParams::Status::TaggedSymbol])
+        end
         def self.values
         end
       end

data/rbi/lib/modern_treasury/models/ledger_account_settlement_list_params.rbi

@@ -6,85 +6,73 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
+      # If you have specific IDs to retrieve in bulk, you can pass them as query
+      #   parameters delimited with `id[]=`, for example `?id[]=123&id[]=abc`.
       sig { returns(T.nilable(T::Array[String])) }
-      def id
-      end
+      attr_reader :id
 
-      sig { params(_: T::Array[String]).returns(T::Array[String]) }
-      def id=(_)
-      end
+      sig { params(id: T::Array[String]).void }
+      attr_writer :id
 
       sig { returns(T.nilable(String)) }
-      def after_cursor
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def after_cursor=(_)
-      end
+      attr_accessor :after_cursor
 
+      # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), or `eq` (=) to filter by the
+      #   created at timestamp. For example, for all times after Jan 1 2000 12:00 UTC, use
+      #   created_at%5Bgt%5D=2000-01-01T12:00:00Z.
       sig { returns(T.nilable(T::Hash[Symbol, Time])) }
-      def created_at
-      end
+      attr_reader :created_at
 
-      sig { params(_: T::Hash[Symbol, Time]).returns(T::Hash[Symbol, Time]) }
-      def created_at=(_)
-      end
+      sig { params(created_at: T::Hash[Symbol, Time]).void }
+      attr_writer :created_at
 
       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
 
       sig { returns(T.nilable(String)) }
-      def ledger_transaction_id
-      end
+      attr_reader :ledger_transaction_id
 
-      sig { params(_: String).returns(String) }
-      def ledger_transaction_id=(_)
-      end
+      sig { params(ledger_transaction_id: String).void }
+      attr_writer :ledger_transaction_id
 
+      # For example, if you want to query for records with metadata key `Type` and value
+      #   `Loan`, the query would be `metadata%5BType%5D=Loan`. This encodes the query
+      #   parameters.
       sig { returns(T.nilable(T::Hash[Symbol, String])) }
-      def metadata
-      end
+      attr_reader :metadata
 
-      sig { params(_: T::Hash[Symbol, String]).returns(T::Hash[Symbol, String]) }
-      def metadata=(_)
-      end
+      sig { params(metadata: T::Hash[Symbol, String]).void }
+      attr_writer :metadata
 
       sig { returns(T.nilable(Integer)) }
-      def per_page
-      end
+      attr_reader :per_page
 
-      sig { params(_: Integer).returns(Integer) }
-      def per_page=(_)
-      end
+      sig { params(per_page: Integer).void }
+      attr_writer :per_page
 
       sig { returns(T.nilable(String)) }
-      def settled_ledger_account_id
-      end
+      attr_reader :settled_ledger_account_id
 
-      sig { params(_: String).returns(String) }
-      def settled_ledger_account_id=(_)
-      end
+      sig { params(settled_ledger_account_id: String).void }
+      attr_writer :settled_ledger_account_id
 
       sig { returns(T.nilable(String)) }
-      def settlement_entry_direction
-      end
+      attr_reader :settlement_entry_direction
 
-      sig { params(_: String).returns(String) }
-      def settlement_entry_direction=(_)
-      end
+      sig { params(settlement_entry_direction: String).void }
+      attr_writer :settlement_entry_direction
 
+      # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), or `eq` (=) to filter by the
+      #   updated at timestamp. For example, for all times after Jan 1 2000 12:00 UTC, use
+      #   updated_at%5Bgt%5D=2000-01-01T12:00:00Z.
       sig { returns(T.nilable(T::Hash[Symbol, Time])) }
-      def updated_at
-      end
+      attr_reader :updated_at
 
-      sig { params(_: T::Hash[Symbol, Time]).returns(T::Hash[Symbol, Time]) }
-      def updated_at=(_)
-      end
+      sig { params(updated_at: T::Hash[Symbol, Time]).void }
+      attr_writer :updated_at
 
       sig do
         params(
@@ -98,11 +86,11 @@ module ModernTreasury
           settled_ledger_account_id: String,
           settlement_entry_direction: String,
           updated_at: T::Hash[Symbol, Time],
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         id: nil,
         after_cursor: nil,
         created_at: nil,

data/rbi/lib/modern_treasury/models/ledger_account_settlement_retrieve_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}) }

data/rbi/lib/modern_treasury/models/ledger_account_settlement_update_params.rbi

@@ -6,40 +6,36 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
+      # The description of the ledger account settlement.
       sig { returns(T.nilable(String)) }
-      def description
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def description=(_)
-      end
+      attr_accessor :description
 
+      # 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
+      attr_reader :metadata
 
-      sig { params(_: T::Hash[Symbol, String]).returns(T::Hash[Symbol, String]) }
-      def metadata=(_)
-      end
+      sig { params(metadata: T::Hash[Symbol, String]).void }
+      attr_writer :metadata
 
-      sig { returns(T.nilable(Symbol)) }
-      def status
-      end
+      # To post a pending ledger account settlement, use `posted`. To archive a pending
+      #   ledger transaction, use `archived`.
+      sig { returns(T.nilable(ModernTreasury::Models::LedgerAccountSettlementUpdateParams::Status::OrSymbol)) }
+      attr_reader :status
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def status=(_)
-      end
+      sig { params(status: ModernTreasury::Models::LedgerAccountSettlementUpdateParams::Status::OrSymbol).void }
+      attr_writer :status
 
       sig do
         params(
           description: T.nilable(String),
           metadata: T::Hash[Symbol, String],
-          status: Symbol,
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          status: ModernTreasury::Models::LedgerAccountSettlementUpdateParams::Status::OrSymbol,
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(description: nil, metadata: nil, status: nil, request_options: {})
+      def self.new(description: nil, metadata: nil, status: nil, request_options: {})
       end
 
       sig do
@@ -48,7 +44,7 @@ module ModernTreasury
             {
               description: T.nilable(String),
               metadata: T::Hash[Symbol, String],
-              status: Symbol,
+              status: ModernTreasury::Models::LedgerAccountSettlementUpdateParams::Status::OrSymbol,
               request_options: ModernTreasury::RequestOptions
             }
           )
@@ -56,13 +52,25 @@ module ModernTreasury
       def to_hash
       end
 
-      class Status < ModernTreasury::Enum
-        abstract!
+      # To post a pending ledger account settlement, use `posted`. To archive a pending
+      #   ledger transaction, use `archived`.
+      module Status
+        extend ModernTreasury::Enum
 
-        POSTED = :posted
-        ARCHIVED = :archived
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::LedgerAccountSettlementUpdateParams::Status) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::LedgerAccountSettlementUpdateParams::Status::TaggedSymbol) }
 
-        sig { override.returns(T::Array[Symbol]) }
+        POSTED =
+          T.let(:posted, ModernTreasury::Models::LedgerAccountSettlementUpdateParams::Status::TaggedSymbol)
+        ARCHIVED =
+          T.let(:archived, ModernTreasury::Models::LedgerAccountSettlementUpdateParams::Status::TaggedSymbol)
+
+        sig do
+          override
+            .returns(T::Array[ModernTreasury::Models::LedgerAccountSettlementUpdateParams::Status::TaggedSymbol])
+        end
         def self.values
         end
       end

data/rbi/lib/modern_treasury/models/ledger_account_settlements/account_entry_delete_params.rbi

@@ -7,22 +7,19 @@ module ModernTreasury
         extend ModernTreasury::RequestParameters::Converter
         include ModernTreasury::RequestParameters
 
+        # The ids of the ledger entries that are to be added or removed from the ledger
+        #   account settlement.
         sig { returns(T.nilable(T::Array[T.anything])) }
-        def ledger_entry_ids
-        end
-
-        sig { params(_: T.nilable(T::Array[T.anything])).returns(T.nilable(T::Array[T.anything])) }
-        def ledger_entry_ids=(_)
-        end
+        attr_accessor :ledger_entry_ids
 
         sig do
           params(
             ledger_entry_ids: T.nilable(T::Array[T.anything]),
-            request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+            request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash)
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(ledger_entry_ids:, request_options: {})
+        def self.new(ledger_entry_ids:, request_options: {})
         end
 
         sig do