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

data/rbi/lib/modern_treasury/models/ledger_account_category_list_params.rbi

@@ -6,94 +6,84 @@ 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
 
+      # For example, if you want the balances as of a particular time (ISO8601), the
+      #   encoded query string would be `balances%5Beffective_at%5D=2000-12-31T12:00:00Z`.
+      #   The balances as of a time are inclusive of entries with that exact time.
       sig { returns(T.nilable(ModernTreasury::Models::LedgerAccountCategoryListParams::Balances)) }
-      def balances
-      end
+      attr_reader :balances
 
       sig do
-        params(_: ModernTreasury::Models::LedgerAccountCategoryListParams::Balances)
-          .returns(ModernTreasury::Models::LedgerAccountCategoryListParams::Balances)
-      end
-      def balances=(_)
+        params(
+          balances: T.any(ModernTreasury::Models::LedgerAccountCategoryListParams::Balances, ModernTreasury::Util::AnyHash)
+        )
+          .void
       end
+      attr_writer :balances
 
       sig { returns(T.nilable(String)) }
-      def currency
-      end
+      attr_reader :currency
 
-      sig { params(_: String).returns(String) }
-      def currency=(_)
-      end
+      sig { params(currency: String).void }
+      attr_writer :currency
 
+      # Query categories which contain a ledger account directly or through child
+      #   categories.
       sig { returns(T.nilable(String)) }
-      def ledger_account_id
-      end
+      attr_reader :ledger_account_id
 
-      sig { params(_: String).returns(String) }
-      def ledger_account_id=(_)
-      end
+      sig { params(ledger_account_id: String).void }
+      attr_writer :ledger_account_id
 
       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
 
+      # 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(String)) }
-      def name
-      end
+      attr_reader :name
 
-      sig { params(_: String).returns(String) }
-      def name=(_)
-      end
+      sig { params(name: String).void }
+      attr_writer :name
 
+      # Query categories that are nested underneath a parent category
       sig { returns(T.nilable(String)) }
-      def parent_ledger_account_category_id
-      end
+      attr_reader :parent_ledger_account_category_id
 
-      sig { params(_: String).returns(String) }
-      def parent_ledger_account_category_id=(_)
-      end
+      sig { params(parent_ledger_account_category_id: String).void }
+      attr_writer :parent_ledger_account_category_id
 
       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 do
         params(
           id: T::Array[String],
           after_cursor: T.nilable(String),
-          balances: ModernTreasury::Models::LedgerAccountCategoryListParams::Balances,
+          balances: T.any(ModernTreasury::Models::LedgerAccountCategoryListParams::Balances, ModernTreasury::Util::AnyHash),
           currency: String,
           ledger_account_id: String,
           ledger_id: String,
@@ -101,11 +91,11 @@ module ModernTreasury
           name: String,
           parent_ledger_account_category_id: String,
           per_page: Integer,
-          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,
         balances: nil,
@@ -143,15 +133,16 @@ module ModernTreasury
 
       class Balances < ModernTreasury::BaseModel
         sig { returns(T.nilable(Time)) }
-        def effective_at
-        end
-
-        sig { params(_: Time).returns(Time) }
-        def effective_at=(_)
-        end
+        attr_reader :effective_at
 
         sig { params(effective_at: Time).void }
-        def initialize(effective_at: nil)
+        attr_writer :effective_at
+
+        # For example, if you want the balances as of a particular time (ISO8601), the
+        #   encoded query string would be `balances%5Beffective_at%5D=2000-12-31T12:00:00Z`.
+        #   The balances as of a time are inclusive of entries with that exact time.
+        sig { params(effective_at: Time).returns(T.attached_class) }
+        def self.new(effective_at: nil)
         end
 
         sig { override.returns({effective_at: Time}) }

data/rbi/lib/modern_treasury/models/ledger_account_category_remove_ledger_account_params.rbi

@@ -7,24 +7,19 @@ module ModernTreasury
       include ModernTreasury::RequestParameters
 
       sig { returns(String) }
-      def id
-      end
-
-      sig { params(_: String).returns(String) }
-      def id=(_)
-      end
+      attr_accessor :id
 
       sig do
         params(
           id: String,
           request_options: T.any(
             ModernTreasury::RequestOptions,
-            T::Hash[Symbol, T.anything]
+            ModernTreasury::Util::AnyHash
           )
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(id:, request_options: {})
+      def self.new(id:, request_options: {})
       end
 
       sig { override.returns({id: String, request_options: ModernTreasury::RequestOptions}) }

data/rbi/lib/modern_treasury/models/ledger_account_category_remove_nested_category_params.rbi

@@ -7,24 +7,19 @@ module ModernTreasury
       include ModernTreasury::RequestParameters
 
       sig { returns(String) }
-      def id
-      end
-
-      sig { params(_: String).returns(String) }
-      def id=(_)
-      end
+      attr_accessor :id
 
       sig do
         params(
           id: String,
           request_options: T.any(
             ModernTreasury::RequestOptions,
-            T::Hash[Symbol, T.anything]
+            ModernTreasury::Util::AnyHash
           )
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(id:, request_options: {})
+      def self.new(id:, request_options: {})
       end
 
       sig { override.returns({id: String, request_options: ModernTreasury::RequestOptions}) }

data/rbi/lib/modern_treasury/models/ledger_account_category_retrieve_params.rbi

@@ -6,25 +6,34 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
+      # For example, if you want the balances as of a particular time (ISO8601), the
+      #   encoded query string would be `balances%5Beffective_at%5D=2000-12-31T12:00:00Z`.
+      #   The balances as of a time are inclusive of entries with that exact time.
       sig { returns(T.nilable(ModernTreasury::Models::LedgerAccountCategoryRetrieveParams::Balances)) }
-      def balances
-      end
+      attr_reader :balances
 
       sig do
-        params(_: ModernTreasury::Models::LedgerAccountCategoryRetrieveParams::Balances)
-          .returns(ModernTreasury::Models::LedgerAccountCategoryRetrieveParams::Balances)
-      end
-      def balances=(_)
+        params(
+          balances: T.any(
+            ModernTreasury::Models::LedgerAccountCategoryRetrieveParams::Balances,
+            ModernTreasury::Util::AnyHash
+          )
+        )
+          .void
       end
+      attr_writer :balances
 
       sig do
         params(
-          balances: ModernTreasury::Models::LedgerAccountCategoryRetrieveParams::Balances,
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          balances: T.any(
+            ModernTreasury::Models::LedgerAccountCategoryRetrieveParams::Balances,
+            ModernTreasury::Util::AnyHash
+          ),
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(balances: nil, request_options: {})
+      def self.new(balances: nil, request_options: {})
       end
 
       sig do
@@ -41,23 +50,22 @@ module ModernTreasury
 
       class Balances < ModernTreasury::BaseModel
         sig { returns(T.nilable(Date)) }
-        def as_of_date
-        end
+        attr_reader :as_of_date
 
-        sig { params(_: Date).returns(Date) }
-        def as_of_date=(_)
-        end
+        sig { params(as_of_date: Date).void }
+        attr_writer :as_of_date
 
         sig { returns(T.nilable(Time)) }
-        def effective_at
-        end
+        attr_reader :effective_at
 
-        sig { params(_: Time).returns(Time) }
-        def effective_at=(_)
-        end
+        sig { params(effective_at: Time).void }
+        attr_writer :effective_at
 
-        sig { params(as_of_date: Date, effective_at: Time).void }
-        def initialize(as_of_date: nil, effective_at: nil)
+        # For example, if you want the balances as of a particular time (ISO8601), the
+        #   encoded query string would be `balances%5Beffective_at%5D=2000-12-31T12:00:00Z`.
+        #   The balances as of a time are inclusive of entries with that exact time.
+        sig { params(as_of_date: Date, effective_at: Time).returns(T.attached_class) }
+        def self.new(as_of_date: nil, effective_at: nil)
         end
 
         sig { override.returns({as_of_date: Date, effective_at: Time}) }

data/rbi/lib/modern_treasury/models/ledger_account_category_update_params.rbi

@@ -6,40 +6,35 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
+      # The description of the ledger account category.
       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
 
+      # The name of the ledger account category.
       sig { returns(T.nilable(String)) }
-      def name
-      end
+      attr_reader :name
 
-      sig { params(_: String).returns(String) }
-      def name=(_)
-      end
+      sig { params(name: String).void }
+      attr_writer :name
 
       sig do
         params(
           description: T.nilable(String),
           metadata: T::Hash[Symbol, String],
           name: String,
-          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(description: nil, metadata: nil, name: nil, request_options: {})
+      def self.new(description: nil, metadata: nil, name: nil, request_options: {})
       end
 
       sig do

data/rbi/lib/modern_treasury/models/ledger_account_create_params.rbi

@@ -6,103 +6,80 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
+      # The currency of the ledger account.
       sig { returns(String) }
-      def currency
-      end
-
-      sig { params(_: String).returns(String) }
-      def currency=(_)
-      end
+      attr_accessor :currency
 
+      # The id of the ledger that this account belongs to.
       sig { returns(String) }
-      def ledger_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def ledger_id=(_)
-      end
+      attr_accessor :ledger_id
 
+      # The name of the ledger account.
       sig { returns(String) }
-      def name
-      end
+      attr_accessor :name
 
-      sig { params(_: String).returns(String) }
-      def name=(_)
-      end
-
-      sig { returns(Symbol) }
-      def normal_balance
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def normal_balance=(_)
-      end
+      # The normal balance of the ledger account.
+      sig { returns(ModernTreasury::Models::TransactionDirection::OrSymbol) }
+      attr_accessor :normal_balance
 
+      # The currency exponent of the ledger account.
       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.
       sig { returns(T.nilable(String)) }
-      def description
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def description=(_)
-      end
+      attr_accessor :description
 
+      # The array of ledger account category ids that this ledger account should be a
+      #   child of.
       sig { returns(T.nilable(T::Array[String])) }
-      def ledger_account_category_ids
-      end
+      attr_reader :ledger_account_category_ids
 
-      sig { params(_: T::Array[String]).returns(T::Array[String]) }
-      def ledger_account_category_ids=(_)
-      end
+      sig { params(ledger_account_category_ids: T::Array[String]).void }
+      attr_writer :ledger_account_category_ids
 
+      # If the ledger account links to another object in Modern Treasury, the id will be
+      #   populated here, otherwise null.
       sig { returns(T.nilable(String)) }
-      def ledgerable_id
-      end
+      attr_reader :ledgerable_id
 
-      sig { params(_: String).returns(String) }
-      def ledgerable_id=(_)
-      end
+      sig { params(ledgerable_id: String).void }
+      attr_writer :ledgerable_id
 
-      sig { returns(T.nilable(Symbol)) }
-      def ledgerable_type
-      end
+      # 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.
+      sig { returns(T.nilable(ModernTreasury::Models::LedgerAccountCreateParams::LedgerableType::OrSymbol)) }
+      attr_reader :ledgerable_type
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def ledgerable_type=(_)
-      end
+      sig { params(ledgerable_type: ModernTreasury::Models::LedgerAccountCreateParams::LedgerableType::OrSymbol).void }
+      attr_writer :ledgerable_type
 
+      # 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 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.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(
         currency:,
         ledger_id:,
         name:,
@@ -124,12 +101,12 @@ module ModernTreasury
               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: ModernTreasury::RequestOptions
             }
@@ -138,15 +115,29 @@ module ModernTreasury
       def to_hash
       end
 
-      class LedgerableType < ModernTreasury::Enum
-        abstract!
-
-        COUNTERPARTY = :counterparty
-        EXTERNAL_ACCOUNT = :external_account
-        INTERNAL_ACCOUNT = :internal_account
-        VIRTUAL_ACCOUNT = :virtual_account
-
-        sig { override.returns(T::Array[Symbol]) }
+      # 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.
+      module LedgerableType
+        extend ModernTreasury::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::LedgerAccountCreateParams::LedgerableType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::LedgerAccountCreateParams::LedgerableType::TaggedSymbol) }
+
+        COUNTERPARTY =
+          T.let(:counterparty, ModernTreasury::Models::LedgerAccountCreateParams::LedgerableType::TaggedSymbol)
+        EXTERNAL_ACCOUNT =
+          T.let(:external_account, ModernTreasury::Models::LedgerAccountCreateParams::LedgerableType::TaggedSymbol)
+        INTERNAL_ACCOUNT =
+          T.let(:internal_account, ModernTreasury::Models::LedgerAccountCreateParams::LedgerableType::TaggedSymbol)
+        VIRTUAL_ACCOUNT =
+          T.let(:virtual_account, ModernTreasury::Models::LedgerAccountCreateParams::LedgerableType::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[ModernTreasury::Models::LedgerAccountCreateParams::LedgerableType::TaggedSymbol])
+        end
         def self.values
         end
       end

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