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

data/rbi/lib/modern_treasury/resources/ledger_accounts.rbi

@@ -3,112 +3,188 @@
 module ModernTreasury
   module Resources
     class LedgerAccounts
+      # Create a ledger account.
       sig do
         params(
           currency: String,
           ledger_id: String,
           name: String,
-          normal_balance: Symbol,
+          normal_balance: ModernTreasury::Models::TransactionDirection::OrSymbol,
           currency_exponent: T.nilable(Integer),
           description: T.nilable(String),
           ledger_account_category_ids: T::Array[String],
           ledgerable_id: String,
-          ledgerable_type: Symbol,
+          ledgerable_type: ModernTreasury::Models::LedgerAccountCreateParams::LedgerableType::OrSymbol,
           metadata: T::Hash[Symbol, String],
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Models::LedgerAccount)
       end
       def create(
+        # The currency of the ledger account.
         currency:,
+        # The id of the ledger that this account belongs to.
         ledger_id:,
+        # The name of the ledger account.
         name:,
+        # The normal balance of the ledger account.
         normal_balance:,
+        # The currency exponent of the ledger account.
         currency_exponent: nil,
+        # The description of the ledger account.
         description: nil,
+        # The array of ledger account category ids that this ledger account should be a
+        #   child of.
         ledger_account_category_ids: nil,
+        # If the ledger account links to another object in Modern Treasury, the id will be
+        #   populated here, otherwise null.
         ledgerable_id: nil,
+        # If the ledger account links to another object in Modern Treasury, the type will
+        #   be populated here, otherwise null. The value is one of internal_account or
+        #   external_account.
         ledgerable_type: nil,
+        # Additional data represented as key-value pairs. Both the key and value must be
+        #   strings.
         metadata: nil,
         request_options: {}
       )
       end
 
+      # Get details on a single ledger account.
       sig do
         params(
           id: String,
-          balances: ModernTreasury::Models::LedgerAccountRetrieveParams::Balances,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          balances: T.any(ModernTreasury::Models::LedgerAccountRetrieveParams::Balances, ModernTreasury::Util::AnyHash),
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Models::LedgerAccount)
       end
-      def retrieve(id, balances: nil, request_options: {})
+      def retrieve(
+        # id
+        id,
+        # Use `balances[effective_at_lower_bound]` and
+        #   `balances[effective_at_upper_bound]` to get the balances change between the two
+        #   timestamps. The lower bound is inclusive while the upper bound is exclusive of
+        #   the provided timestamps. If no value is supplied the balances will be retrieved
+        #   not including that bound. Use `balances[as_of_lock_version]` to retrieve a
+        #   balance as of a specific Ledger Account `lock_version`.
+        balances: nil,
+        request_options: {}
+      )
       end
 
+      # Update the details of a ledger account.
       sig do
         params(
           id: String,
           description: T.nilable(String),
           metadata: T::Hash[Symbol, String],
           name: String,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Models::LedgerAccount)
       end
-      def update(id, description: nil, metadata: nil, name: nil, request_options: {})
+      def update(
+        # id
+        id,
+        # The description of the ledger account.
+        description: nil,
+        # Additional data represented as key-value pairs. Both the key and value must be
+        #   strings.
+        metadata: nil,
+        # The name of the ledger account.
+        name: nil,
+        request_options: {}
+      )
       end
 
+      # Get a list of ledger accounts.
       sig do
         params(
           id: T::Array[String],
           after_cursor: T.nilable(String),
-          available_balance_amount: ModernTreasury::Models::LedgerAccountListParams::AvailableBalanceAmount,
-          balances: ModernTreasury::Models::LedgerAccountListParams::Balances,
+          available_balance_amount: T.any(
+            ModernTreasury::Models::LedgerAccountListParams::AvailableBalanceAmount,
+            ModernTreasury::Util::AnyHash
+          ),
+          balances: T.any(ModernTreasury::Models::LedgerAccountListParams::Balances, ModernTreasury::Util::AnyHash),
           created_at: T::Hash[Symbol, Time],
           currency: String,
           ledger_account_category_id: String,
           ledger_id: String,
           metadata: T::Hash[Symbol, String],
           name: T::Array[String],
-          pending_balance_amount: ModernTreasury::Models::LedgerAccountListParams::PendingBalanceAmount,
+          pending_balance_amount: T.any(
+            ModernTreasury::Models::LedgerAccountListParams::PendingBalanceAmount,
+            ModernTreasury::Util::AnyHash
+          ),
           per_page: Integer,
-          posted_balance_amount: ModernTreasury::Models::LedgerAccountListParams::PostedBalanceAmount,
+          posted_balance_amount: T.any(ModernTreasury::Models::LedgerAccountListParams::PostedBalanceAmount, ModernTreasury::Util::AnyHash),
           updated_at: T::Hash[Symbol, Time],
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Page[ModernTreasury::Models::LedgerAccount])
       end
       def list(
+        # 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`.
         id: nil,
         after_cursor: nil,
+        # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), `eq` (=), or `not_eq` (!=) to
+        #   filter by balance amount.
         available_balance_amount: nil,
+        # Use `balances[effective_at_lower_bound]` and
+        #   `balances[effective_at_upper_bound]` to get the balances change between the two
+        #   timestamps. The lower bound is inclusive while the upper bound is exclusive of
+        #   the provided timestamps. If no value is supplied the balances will be retrieved
+        #   not including that bound.
         balances: nil,
+        # 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.
         created_at: nil,
         currency: nil,
         ledger_account_category_id: nil,
         ledger_id: nil,
+        # 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.
         metadata: nil,
+        # If you have specific names to retrieve in bulk, you can pass them as query
+        #   parameters delimited with `name[]=`, for example `?name[]=123&name[]=abc`.
         name: nil,
+        # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), `eq` (=), or `not_eq` (!=) to
+        #   filter by balance amount.
         pending_balance_amount: nil,
         per_page: nil,
+        # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), `eq` (=), or `not_eq` (!=) to
+        #   filter by balance amount.
         posted_balance_amount: nil,
+        # 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.
         updated_at: nil,
         request_options: {}
       )
       end
 
+      # Delete a ledger account.
       sig do
         params(
           id: String,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Models::LedgerAccount)
       end
-      def delete(id, request_options: {})
+      def delete(
+        # id
+        id,
+        request_options: {}
+      )
       end
 
-      sig { params(client: ModernTreasury::Client).void }
-      def initialize(client:)
+      sig { params(client: ModernTreasury::Client).returns(T.attached_class) }
+      def self.new(client:)
       end
     end
   end

data/rbi/lib/modern_treasury/resources/ledger_entries.rbi

@@ -3,34 +3,51 @@
 module ModernTreasury
   module Resources
     class LedgerEntries
+      # Get details on a single ledger entry.
       sig do
         params(
           id: String,
           show_balances: T::Boolean,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Models::LedgerEntry)
       end
-      def retrieve(id, show_balances: nil, request_options: {})
+      def retrieve(
+        # id
+        id,
+        # If true, response will include the balances attached to the ledger entry. If
+        #   there is no balance available, null will be returned instead.
+        show_balances: nil,
+        request_options: {}
+      )
       end
 
+      # Update the details of a ledger entry.
       sig do
         params(
           id: String,
           metadata: T::Hash[Symbol, String],
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Models::LedgerEntry)
       end
-      def update(id, metadata: nil, request_options: {})
+      def update(
+        # id
+        id,
+        # Additional data represented as key-value pairs. Both the key and value must be
+        #   strings.
+        metadata: nil,
+        request_options: {}
+      )
       end
 
+      # Get a list of all ledger entries.
       sig do
         params(
           id: T::Array[String],
           after_cursor: T.nilable(String),
           as_of_lock_version: Integer,
-          direction: Symbol,
+          direction: ModernTreasury::Models::TransactionDirection::OrSymbol,
           effective_at: T::Hash[Symbol, Time],
           effective_date: T::Hash[Symbol, Date],
           ledger_account_category_id: String,
@@ -41,43 +58,77 @@ module ModernTreasury
           ledger_account_statement_id: String,
           ledger_transaction_id: String,
           metadata: T::Hash[Symbol, String],
-          order_by: ModernTreasury::Models::LedgerEntryListParams::OrderBy,
+          order_by: T.any(ModernTreasury::Models::LedgerEntryListParams::OrderBy, ModernTreasury::Util::AnyHash),
           per_page: Integer,
           show_balances: T::Boolean,
           show_deleted: T::Boolean,
-          status: Symbol,
+          status: ModernTreasury::Models::LedgerEntryListParams::Status::OrSymbol,
           updated_at: T::Hash[Symbol, Time],
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Page[ModernTreasury::Models::LedgerEntry])
       end
       def list(
+        # 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`.
         id: nil,
         after_cursor: nil,
+        # Shows all ledger entries that were present on a ledger account at a particular
+        #   `lock_version`. You must also specify `ledger_account_id`.
         as_of_lock_version: nil,
+        # If true, response will include ledger entries that were deleted. When you update
+        #   a ledger transaction to specify a new set of entries, the previous entries are
+        #   deleted.
         direction: nil,
+        # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), or `eq` (=) to filter by the
+        #   transaction's effective time. Format ISO8601
         effective_at: nil,
+        # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), or `eq` (=) to filter by the
+        #   transaction's effective date. Format YYYY-MM-DD
         effective_date: nil,
+        # Get all ledger entries that match the direction specified. One of `credit`,
+        #   `debit`.
         ledger_account_category_id: nil,
         ledger_account_id: nil,
+        # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), or `eq` (=) to filter by the
+        #   lock_version of a ledger account. For example, for all entries created at or
+        #   before before lock_version 1000 of a ledger account, use
+        #   `ledger_account_lock_version%5Blte%5D=1000`.
         ledger_account_lock_version: nil,
         ledger_account_payout_id: nil,
         ledger_account_settlement_id: nil,
+        # Get all ledger entries that are included in the ledger account statement.
         ledger_account_statement_id: nil,
         ledger_transaction_id: nil,
+        # 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.
         metadata: nil,
+        # Order by `created_at` or `effective_at` in `asc` or `desc` order. For example,
+        #   to order by `effective_at asc`, use `order_by%5Beffective_at%5D=asc`. Ordering
+        #   by only one field at a time is supported.
         order_by: nil,
         per_page: nil,
+        # If true, response will include the balances attached to the ledger entry. If
+        #   there is no balance available, null will be returned instead.
         show_balances: nil,
+        # If true, response will include ledger entries that were deleted. When you update
+        #   a ledger transaction to specify a new set of entries, the previous entries are
+        #   deleted.
         show_deleted: nil,
+        # Get all ledger entries that match the status specified. One of `pending`,
+        #   `posted`, or `archived`.
         status: nil,
+        # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), or `eq` (=) to filter by the
+        #   posted at timestamp. For example, for all times after Jan 1 2000 12:00 UTC, use
+        #   updated_at%5Bgt%5D=2000-01-01T12:00:00Z.
         updated_at: nil,
         request_options: {}
       )
       end
 
-      sig { params(client: ModernTreasury::Client).void }
-      def initialize(client:)
+      sig { params(client: ModernTreasury::Client).returns(T.attached_class) }
+      def self.new(client:)
       end
     end
   end

data/rbi/lib/modern_treasury/resources/ledger_event_handlers.rbi

@@ -3,41 +3,60 @@
 module ModernTreasury
   module Resources
     class LedgerEventHandlers
+      # create ledger_event_handler
       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.nilable(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.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Models::LedgerEventHandler)
       end
       def create(
         ledger_transaction_template:,
+        # Name of the ledger event handler.
         name:,
         conditions: nil,
+        # An optional description.
         description: nil,
+        # The id of the ledger that this account belongs to.
         ledger_id: nil,
+        # Additional data represented as key-value pairs. Both the key and value must be
+        #   strings.
         metadata: nil,
         variables: nil,
         request_options: {}
       )
       end
 
+      # Get details on a single ledger event handler.
       sig do
         params(
           id: String,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Models::LedgerEventHandler)
       end
-      def retrieve(id, request_options: {})
+      def retrieve(
+        # id
+        id,
+        request_options: {}
+      )
       end
 
+      # Get a list of ledger event handlers.
       sig do
         params(
           after_cursor: T.nilable(String),
@@ -45,13 +64,19 @@ module ModernTreasury
           metadata: T::Hash[Symbol, String],
           name: String,
           per_page: Integer,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Page[ModernTreasury::Models::LedgerEventHandler])
       end
       def list(
         after_cursor: nil,
+        # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), or `eq` (=) to filter by the
+        #   posted at timestamp. For example, for all times after Jan 1 2000 12:00 UTC, use
+        #   created_at%5Bgt%5D=2000-01-01T12:00:00Z.
         created_at: nil,
+        # 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.
         metadata: nil,
         name: nil,
         per_page: nil,
@@ -59,18 +84,23 @@ module ModernTreasury
       )
       end
 
+      # Archive a ledger event handler.
       sig do
         params(
           id: String,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Models::LedgerEventHandler)
       end
-      def delete(id, request_options: {})
+      def delete(
+        # id
+        id,
+        request_options: {}
+      )
       end
 
-      sig { params(client: ModernTreasury::Client).void }
-      def initialize(client:)
+      sig { params(client: ModernTreasury::Client).returns(T.attached_class) }
+      def self.new(client:)
       end
     end
   end

data/rbi/lib/modern_treasury/resources/ledger_transactions/versions.rbi

@@ -4,6 +4,7 @@ module ModernTreasury
   module Resources
     class LedgerTransactions
       class Versions
+        # Get a list of ledger transaction versions.
         sig do
           params(
             after_cursor: T.nilable(String),
@@ -12,23 +13,32 @@ module ModernTreasury
             ledger_transaction_id: String,
             per_page: Integer,
             version: T::Hash[Symbol, Integer],
-            request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+            request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
           )
             .returns(ModernTreasury::Page[ModernTreasury::Models::LedgerTransactions::LedgerTransactionVersion])
         end
         def list(
           after_cursor: nil,
+          # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), or `eq` (=) to filter by the
+          #   created_at timestamp. For example, for all dates after Jan 1 2000 12:00 UTC, use
+          #   created_at%5Bgt%5D=2000-01-01T12:00:00Z.
           created_at: nil,
+          # Get all ledger transaction versions that are included in the ledger account
+          #   statement.
           ledger_account_statement_id: nil,
+          # Get all the ledger transaction versions corresponding to the ID of a ledger
+          #   transaction.
           ledger_transaction_id: nil,
           per_page: nil,
+          # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), or `eq` (=) to filter by the
+          #   version. For example, for all versions after 2, use version%5Bgt%5D=2.
           version: nil,
           request_options: {}
         )
         end
 
-        sig { params(client: ModernTreasury::Client).void }
-        def initialize(client:)
+        sig { params(client: ModernTreasury::Client).returns(T.attached_class) }
+        def self.new(client:)
         end
       end
     end