modern_treasury 0.1.0.pre.alpha.18 → 0.1.0.pre.alpha.19

data/rbi/modern_treasury/models/ledger_account_create_params.rbi

@@ -0,0 +1,200 @@
+# typed: strong
+
+module ModernTreasury
+  module Models
+    class LedgerAccountCreateParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            ModernTreasury::LedgerAccountCreateParams,
+            ModernTreasury::Internal::AnyHash
+          )
+        end
+
+      # The currency of the ledger account.
+      sig { returns(String) }
+      attr_accessor :currency
+
+      # The id of the ledger that this account belongs to.
+      sig { returns(String) }
+      attr_accessor :ledger_id
+
+      # The name of the ledger account.
+      sig { returns(String) }
+      attr_accessor :name
+
+      # The normal balance of the ledger account.
+      sig { returns(ModernTreasury::TransactionDirection::OrSymbol) }
+      attr_accessor :normal_balance
+
+      # The currency exponent of the ledger account.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :currency_exponent
+
+      # The description of the ledger account.
+      sig { returns(T.nilable(String)) }
+      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])) }
+      attr_reader :ledger_account_category_ids
+
+      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)) }
+      attr_reader :ledgerable_id
+
+      sig { params(ledgerable_id: String).void }
+      attr_writer :ledgerable_id
+
+      # 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 do
+        returns(
+          T.nilable(
+            ModernTreasury::LedgerAccountCreateParams::LedgerableType::OrSymbol
+          )
+        )
+      end
+      attr_reader :ledgerable_type
+
+      sig do
+        params(
+          ledgerable_type:
+            ModernTreasury::LedgerAccountCreateParams::LedgerableType::OrSymbol
+        ).void
+      end
+      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])) }
+      attr_reader :metadata
+
+      sig { params(metadata: T::Hash[Symbol, String]).void }
+      attr_writer :metadata
+
+      sig do
+        params(
+          currency: String,
+          ledger_id: String,
+          name: String,
+          normal_balance: ModernTreasury::TransactionDirection::OrSymbol,
+          currency_exponent: T.nilable(Integer),
+          description: T.nilable(String),
+          ledger_account_category_ids: T::Array[String],
+          ledgerable_id: String,
+          ledgerable_type:
+            ModernTreasury::LedgerAccountCreateParams::LedgerableType::OrSymbol,
+          metadata: T::Hash[Symbol, String],
+          request_options: ModernTreasury::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # 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
+
+      sig do
+        override.returns(
+          {
+            currency: String,
+            ledger_id: String,
+            name: String,
+            normal_balance: ModernTreasury::TransactionDirection::OrSymbol,
+            currency_exponent: T.nilable(Integer),
+            description: T.nilable(String),
+            ledger_account_category_ids: T::Array[String],
+            ledgerable_id: String,
+            ledgerable_type:
+              ModernTreasury::LedgerAccountCreateParams::LedgerableType::OrSymbol,
+            metadata: T::Hash[Symbol, String],
+            request_options: ModernTreasury::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      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.
+      module LedgerableType
+        extend ModernTreasury::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(
+              Symbol,
+              ModernTreasury::LedgerAccountCreateParams::LedgerableType
+            )
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        COUNTERPARTY =
+          T.let(
+            :counterparty,
+            ModernTreasury::LedgerAccountCreateParams::LedgerableType::TaggedSymbol
+          )
+        EXTERNAL_ACCOUNT =
+          T.let(
+            :external_account,
+            ModernTreasury::LedgerAccountCreateParams::LedgerableType::TaggedSymbol
+          )
+        INTERNAL_ACCOUNT =
+          T.let(
+            :internal_account,
+            ModernTreasury::LedgerAccountCreateParams::LedgerableType::TaggedSymbol
+          )
+        VIRTUAL_ACCOUNT =
+          T.let(
+            :virtual_account,
+            ModernTreasury::LedgerAccountCreateParams::LedgerableType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              ModernTreasury::LedgerAccountCreateParams::LedgerableType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/modern_treasury/models/ledger_account_delete_params.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module ModernTreasury
+  module Models
+    class LedgerAccountDeleteParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            ModernTreasury::LedgerAccountDeleteParams,
+            ModernTreasury::Internal::AnyHash
+          )
+        end
+
+      sig do
+        params(request_options: ModernTreasury::RequestOptions::OrHash).returns(
+          T.attached_class
+        )
+      end
+      def self.new(request_options: {})
+      end
+
+      sig do
+        override.returns({ request_options: ModernTreasury::RequestOptions })
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/{lib/modern_treasury → modern_treasury}/models/ledger_account_list_params.rbi

@@ -6,6 +6,14 @@ module ModernTreasury
       extend ModernTreasury::Internal::Type::RequestParameters::Converter
       include ModernTreasury::Internal::Type::RequestParameters
 
+      OrHash =
+        T.type_alias do
+          T.any(
+            ModernTreasury::LedgerAccountListParams,
+            ModernTreasury::Internal::AnyHash
+          )
+        end
+
       # 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])) }
@@ -19,17 +27,20 @@ module ModernTreasury
 
       # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), `eq` (=), or `not_eq` (!=) to
       # filter by balance amount.
-      sig { returns(T.nilable(ModernTreasury::Models::LedgerAccountListParams::AvailableBalanceAmount)) }
+      sig do
+        returns(
+          T.nilable(
+            ModernTreasury::LedgerAccountListParams::AvailableBalanceAmount
+          )
+        )
+      end
       attr_reader :available_balance_amount
 
       sig do
         params(
-          available_balance_amount: T.any(
-            ModernTreasury::Models::LedgerAccountListParams::AvailableBalanceAmount,
-            ModernTreasury::Internal::AnyHash
-          )
-        )
-          .void
+          available_balance_amount:
+            ModernTreasury::LedgerAccountListParams::AvailableBalanceAmount::OrHash
+        ).void
       end
       attr_writer :available_balance_amount
 
@@ -38,14 +49,15 @@ module ModernTreasury
       # 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.
-      sig { returns(T.nilable(ModernTreasury::Models::LedgerAccountListParams::Balances)) }
+      sig do
+        returns(T.nilable(ModernTreasury::LedgerAccountListParams::Balances))
+      end
       attr_reader :balances
 
       sig do
         params(
-          balances: T.any(ModernTreasury::Models::LedgerAccountListParams::Balances, ModernTreasury::Internal::AnyHash)
-        )
-          .void
+          balances: ModernTreasury::LedgerAccountListParams::Balances::OrHash
+        ).void
       end
       attr_writer :balances
 
@@ -95,17 +107,20 @@ module ModernTreasury
 
       # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), `eq` (=), or `not_eq` (!=) to
       # filter by balance amount.
-      sig { returns(T.nilable(ModernTreasury::Models::LedgerAccountListParams::PendingBalanceAmount)) }
+      sig do
+        returns(
+          T.nilable(
+            ModernTreasury::LedgerAccountListParams::PendingBalanceAmount
+          )
+        )
+      end
       attr_reader :pending_balance_amount
 
       sig do
         params(
-          pending_balance_amount: T.any(
-            ModernTreasury::Models::LedgerAccountListParams::PendingBalanceAmount,
-            ModernTreasury::Internal::AnyHash
-          )
-        )
-          .void
+          pending_balance_amount:
+            ModernTreasury::LedgerAccountListParams::PendingBalanceAmount::OrHash
+        ).void
       end
       attr_writer :pending_balance_amount
 
@@ -117,17 +132,20 @@ module ModernTreasury
 
       # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), `eq` (=), or `not_eq` (!=) to
       # filter by balance amount.
-      sig { returns(T.nilable(ModernTreasury::Models::LedgerAccountListParams::PostedBalanceAmount)) }
+      sig do
+        returns(
+          T.nilable(
+            ModernTreasury::LedgerAccountListParams::PostedBalanceAmount
+          )
+        )
+      end
       attr_reader :posted_balance_amount
 
       sig do
         params(
-          posted_balance_amount: T.any(
-            ModernTreasury::Models::LedgerAccountListParams::PostedBalanceAmount,
-            ModernTreasury::Internal::AnyHash
-          )
-        )
-          .void
+          posted_balance_amount:
+            ModernTreasury::LedgerAccountListParams::PostedBalanceAmount::OrHash
+        ).void
       end
       attr_writer :posted_balance_amount
 
@@ -144,73 +162,103 @@ module ModernTreasury
         params(
           id: T::Array[String],
           after_cursor: T.nilable(String),
-          available_balance_amount: T.any(
-            ModernTreasury::Models::LedgerAccountListParams::AvailableBalanceAmount,
-            ModernTreasury::Internal::AnyHash
-          ),
-          balances: T.any(ModernTreasury::Models::LedgerAccountListParams::Balances, ModernTreasury::Internal::AnyHash),
+          available_balance_amount:
+            ModernTreasury::LedgerAccountListParams::AvailableBalanceAmount::OrHash,
+          balances: ModernTreasury::LedgerAccountListParams::Balances::OrHash,
           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: T.any(
-            ModernTreasury::Models::LedgerAccountListParams::PendingBalanceAmount,
-            ModernTreasury::Internal::AnyHash
-          ),
+          pending_balance_amount:
+            ModernTreasury::LedgerAccountListParams::PendingBalanceAmount::OrHash,
           per_page: Integer,
-          posted_balance_amount: T.any(
-            ModernTreasury::Models::LedgerAccountListParams::PostedBalanceAmount,
-            ModernTreasury::Internal::AnyHash
-          ),
+          posted_balance_amount:
+            ModernTreasury::LedgerAccountListParams::PostedBalanceAmount::OrHash,
           updated_at: T::Hash[Symbol, Time],
-          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          request_options: ModernTreasury::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
+        # 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
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              id: T::Array[String],
-              after_cursor: T.nilable(String),
-              available_balance_amount: ModernTreasury::Models::LedgerAccountListParams::AvailableBalanceAmount,
-              balances: ModernTreasury::Models::LedgerAccountListParams::Balances,
-              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,
-              per_page: Integer,
-              posted_balance_amount: ModernTreasury::Models::LedgerAccountListParams::PostedBalanceAmount,
-              updated_at: T::Hash[Symbol, Time],
-              request_options: ModernTreasury::RequestOptions
-            }
-          )
+        override.returns(
+          {
+            id: T::Array[String],
+            after_cursor: T.nilable(String),
+            available_balance_amount:
+              ModernTreasury::LedgerAccountListParams::AvailableBalanceAmount,
+            balances: ModernTreasury::LedgerAccountListParams::Balances,
+            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::LedgerAccountListParams::PendingBalanceAmount,
+            per_page: Integer,
+            posted_balance_amount:
+              ModernTreasury::LedgerAccountListParams::PostedBalanceAmount,
+            updated_at: T::Hash[Symbol, Time],
+            request_options: ModernTreasury::RequestOptions
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       class AvailableBalanceAmount < ModernTreasury::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              ModernTreasury::LedgerAccountListParams::AvailableBalanceAmount,
+              ModernTreasury::Internal::AnyHash
+            )
+          end
+
         sig { returns(T.nilable(Integer)) }
         attr_reader :eq
 
@@ -250,10 +298,17 @@ module ModernTreasury
         # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), `eq` (=), or `not_eq` (!=) to
         # filter by balance amount.
         sig do
-          params(eq: Integer, gt: Integer, gte: Integer, lt: Integer, lte: Integer, not_eq: Integer)
-            .returns(T.attached_class)
+          params(
+            eq: Integer,
+            gt: Integer,
+            gte: Integer,
+            lt: Integer,
+            lte: Integer,
+            not_eq: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(eq: nil, gt: nil, gte: nil, lt: nil, lte: nil, not_eq: nil)
         end
-        def self.new(eq: nil, gt: nil, gte: nil, lt: nil, lte: nil, not_eq: nil); end
 
         sig do
           override.returns(
@@ -267,10 +322,19 @@ module ModernTreasury
             }
           )
         end
-        def to_hash; end
+        def to_hash
+        end
       end
 
       class Balances < ModernTreasury::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              ModernTreasury::LedgerAccountListParams::Balances,
+              ModernTreasury::Internal::AnyHash
+            )
+          end
+
         sig { returns(T.nilable(Date)) }
         attr_reader :as_of_date
 
@@ -306,8 +370,7 @@ module ModernTreasury
             effective_at: Time,
             effective_at_lower_bound: Time,
             effective_at_upper_bound: Time
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
         end
         def self.new(
           as_of_date: nil,
@@ -318,20 +381,28 @@ module ModernTreasury
         end
 
         sig do
-          override
-            .returns(
-              {
-                as_of_date: Date,
-                effective_at: Time,
-                effective_at_lower_bound: Time,
-                effective_at_upper_bound: Time
-              }
-            )
+          override.returns(
+            {
+              as_of_date: Date,
+              effective_at: Time,
+              effective_at_lower_bound: Time,
+              effective_at_upper_bound: Time
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
       end
 
       class PendingBalanceAmount < ModernTreasury::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              ModernTreasury::LedgerAccountListParams::PendingBalanceAmount,
+              ModernTreasury::Internal::AnyHash
+            )
+          end
+
         sig { returns(T.nilable(Integer)) }
         attr_reader :eq
 
@@ -371,10 +442,17 @@ module ModernTreasury
         # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), `eq` (=), or `not_eq` (!=) to
         # filter by balance amount.
         sig do
-          params(eq: Integer, gt: Integer, gte: Integer, lt: Integer, lte: Integer, not_eq: Integer)
-            .returns(T.attached_class)
+          params(
+            eq: Integer,
+            gt: Integer,
+            gte: Integer,
+            lt: Integer,
+            lte: Integer,
+            not_eq: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(eq: nil, gt: nil, gte: nil, lt: nil, lte: nil, not_eq: nil)
         end
-        def self.new(eq: nil, gt: nil, gte: nil, lt: nil, lte: nil, not_eq: nil); end
 
         sig do
           override.returns(
@@ -388,10 +466,19 @@ module ModernTreasury
             }
           )
         end
-        def to_hash; end
+        def to_hash
+        end
       end
 
       class PostedBalanceAmount < ModernTreasury::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              ModernTreasury::LedgerAccountListParams::PostedBalanceAmount,
+              ModernTreasury::Internal::AnyHash
+            )
+          end
+
         sig { returns(T.nilable(Integer)) }
         attr_reader :eq
 
@@ -431,10 +518,17 @@ module ModernTreasury
         # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), `eq` (=), or `not_eq` (!=) to
         # filter by balance amount.
         sig do
-          params(eq: Integer, gt: Integer, gte: Integer, lt: Integer, lte: Integer, not_eq: Integer)
-            .returns(T.attached_class)
+          params(
+            eq: Integer,
+            gt: Integer,
+            gte: Integer,
+            lt: Integer,
+            lte: Integer,
+            not_eq: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(eq: nil, gt: nil, gte: nil, lt: nil, lte: nil, not_eq: nil)
         end
-        def self.new(eq: nil, gt: nil, gte: nil, lt: nil, lte: nil, not_eq: nil); end
 
         sig do
           override.returns(
@@ -448,7 +542,8 @@ module ModernTreasury
             }
           )
         end
-        def to_hash; end
+        def to_hash
+        end
       end
     end
   end