modern_treasury 0.1.0.pre.alpha.15 → 0.1.0.pre.alpha.17

data/rbi/lib/modern_treasury/models/ledger_account_category_create_params.rbi

@@ -2,89 +2,65 @@
 
 module ModernTreasury
   module Models
-    class LedgerAccountCategoryCreateParams < ModernTreasury::BaseModel
-      extend ModernTreasury::RequestParameters::Converter
-      include ModernTreasury::RequestParameters
+    class LedgerAccountCategoryCreateParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::RequestParameters
 
+      # The currency of the ledger account category.
       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 category 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 category.
       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 category.
+      sig { returns(ModernTreasury::Models::TransactionDirection::OrSymbol) }
+      attr_accessor :normal_balance
 
+      # The currency exponent of the ledger account category.
       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 category.
       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 category
+      # 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
 
+      # 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],
           metadata: T::Hash[Symbol, String],
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         currency:,
         ledger_id:,
         name:,
@@ -94,9 +70,7 @@ module ModernTreasury
         ledger_account_category_ids: nil,
         metadata: nil,
         request_options: {}
-      )
-      end
-
+      ); end
       sig do
         override
           .returns(
@@ -104,7 +78,7 @@ 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],
@@ -113,8 +87,7 @@ module ModernTreasury
             }
           )
       end
-      def to_hash
-      end
+      def to_hash; end
     end
   end
 end

data/rbi/lib/modern_treasury/models/ledger_account_category_delete_params.rbi

@@ -2,17 +2,18 @@
 
 module ModernTreasury
   module Models
-    class LedgerAccountCategoryDeleteParams < ModernTreasury::BaseModel
-      extend ModernTreasury::RequestParameters::Converter
-      include ModernTreasury::RequestParameters
+    class LedgerAccountCategoryDeleteParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::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::Internal::AnyHash))
+          .returns(T.attached_class)
       end
+      def self.new(request_options: {}); end
 
       sig { override.returns({request_options: ModernTreasury::RequestOptions}) }
-      def to_hash
-      end
+      def to_hash; end
     end
   end
 end

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

@@ -2,98 +2,94 @@
 
 module ModernTreasury
   module Models
-    class LedgerAccountCategoryListParams < ModernTreasury::BaseModel
-      extend ModernTreasury::RequestParameters::Converter
-      include ModernTreasury::RequestParameters
+    class LedgerAccountCategoryListParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::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::Internal::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::Internal::AnyHash
+          ),
           currency: String,
           ledger_account_id: String,
           ledger_id: String,
@@ -101,11 +97,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::Internal::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         id: nil,
         after_cursor: nil,
         balances: nil,
@@ -117,9 +113,7 @@ module ModernTreasury
         parent_ledger_account_category_id: nil,
         per_page: nil,
         request_options: {}
-      )
-      end
-
+      ); end
       sig do
         override
           .returns(
@@ -138,25 +132,23 @@ module ModernTreasury
             }
           )
       end
-      def to_hash
-      end
+      def to_hash; end
 
-      class Balances < ModernTreasury::BaseModel
+      class Balances < ModernTreasury::Internal::Type::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)
-        end
+        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}) }
-        def to_hash
-        end
+        def to_hash; end
       end
     end
   end

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

@@ -2,34 +2,24 @@
 
 module ModernTreasury
   module Models
-    class LedgerAccountCategoryRemoveLedgerAccountParams < ModernTreasury::BaseModel
-      extend ModernTreasury::RequestParameters::Converter
-      include ModernTreasury::RequestParameters
+    class LedgerAccountCategoryRemoveLedgerAccountParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::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]
-          )
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash)
         )
-          .void
-      end
-      def initialize(id:, request_options: {})
+          .returns(T.attached_class)
       end
+      def self.new(id:, request_options: {}); end
 
       sig { override.returns({id: String, request_options: ModernTreasury::RequestOptions}) }
-      def to_hash
-      end
+      def to_hash; end
     end
   end
 end

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

@@ -2,34 +2,24 @@
 
 module ModernTreasury
   module Models
-    class LedgerAccountCategoryRemoveNestedCategoryParams < ModernTreasury::BaseModel
-      extend ModernTreasury::RequestParameters::Converter
-      include ModernTreasury::RequestParameters
+    class LedgerAccountCategoryRemoveNestedCategoryParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::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]
-          )
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash)
         )
-          .void
-      end
-      def initialize(id:, request_options: {})
+          .returns(T.attached_class)
       end
+      def self.new(id:, request_options: {}); end
 
       sig { override.returns({id: String, request_options: ModernTreasury::RequestOptions}) }
-      def to_hash
-      end
+      def to_hash; end
     end
   end
 end

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

@@ -2,30 +2,38 @@
 
 module ModernTreasury
   module Models
-    class LedgerAccountCategoryRetrieveParams < ModernTreasury::BaseModel
-      extend ModernTreasury::RequestParameters::Converter
-      include ModernTreasury::RequestParameters
+    class LedgerAccountCategoryRetrieveParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::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::Internal::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::Internal::AnyHash
+          ),
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash)
         )
-          .void
-      end
-      def initialize(balances: nil, request_options: {})
+          .returns(T.attached_class)
       end
+      def self.new(balances: nil, request_options: {}); end
 
       sig do
         override
@@ -36,33 +44,29 @@ module ModernTreasury
             }
           )
       end
-      def to_hash
-      end
+      def to_hash; end
 
-      class Balances < ModernTreasury::BaseModel
+      class Balances < ModernTreasury::Internal::Type::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)
-        end
+        # 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}) }
-        def to_hash
-        end
+        def to_hash; end
       end
     end
   end

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

@@ -2,45 +2,39 @@
 
 module ModernTreasury
   module Models
-    class LedgerAccountCategoryUpdateParams < ModernTreasury::BaseModel
-      extend ModernTreasury::RequestParameters::Converter
-      include ModernTreasury::RequestParameters
+    class LedgerAccountCategoryUpdateParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::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::Internal::AnyHash)
         )
-          .void
-      end
-      def initialize(description: nil, metadata: nil, name: nil, request_options: {})
+          .returns(T.attached_class)
       end
+      def self.new(description: nil, metadata: nil, name: nil, request_options: {}); end
 
       sig do
         override
@@ -53,8 +47,7 @@ module ModernTreasury
             }
           )
       end
-      def to_hash
-      end
+      def to_hash; end
     end
   end
 end