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

data/rbi/lib/modern_treasury/models/ledger_account_list_params.rbi

@@ -6,151 +6,164 @@ 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` (<=), `eq` (=), or `not_eq` (!=) to
+      #   filter by balance amount.
       sig { returns(T.nilable(ModernTreasury::Models::LedgerAccountListParams::AvailableBalanceAmount)) }
-      def available_balance_amount
-      end
+      attr_reader :available_balance_amount
 
       sig do
-        params(_: ModernTreasury::Models::LedgerAccountListParams::AvailableBalanceAmount)
-          .returns(ModernTreasury::Models::LedgerAccountListParams::AvailableBalanceAmount)
-      end
-      def available_balance_amount=(_)
+        params(
+          available_balance_amount: T.any(
+            ModernTreasury::Models::LedgerAccountListParams::AvailableBalanceAmount,
+            ModernTreasury::Util::AnyHash
+          )
+        )
+          .void
       end
+      attr_writer :available_balance_amount
 
+      # 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.
       sig { returns(T.nilable(ModernTreasury::Models::LedgerAccountListParams::Balances)) }
-      def balances
-      end
+      attr_reader :balances
 
       sig do
-        params(_: ModernTreasury::Models::LedgerAccountListParams::Balances)
-          .returns(ModernTreasury::Models::LedgerAccountListParams::Balances)
-      end
-      def balances=(_)
+        params(
+          balances: T.any(ModernTreasury::Models::LedgerAccountListParams::Balances, ModernTreasury::Util::AnyHash)
+        )
+          .void
       end
+      attr_writer :balances
 
+      # 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 currency
-      end
+      attr_reader :currency
 
-      sig { params(_: String).returns(String) }
-      def currency=(_)
-      end
+      sig { params(currency: String).void }
+      attr_writer :currency
 
       sig { returns(T.nilable(String)) }
-      def ledger_account_category_id
-      end
+      attr_reader :ledger_account_category_id
 
-      sig { params(_: String).returns(String) }
-      def ledger_account_category_id=(_)
-      end
+      sig { params(ledger_account_category_id: String).void }
+      attr_writer :ledger_account_category_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
 
+      # 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`.
       sig { returns(T.nilable(T::Array[String])) }
-      def name
-      end
+      attr_reader :name
 
-      sig { params(_: T::Array[String]).returns(T::Array[String]) }
-      def name=(_)
-      end
+      sig { params(name: T::Array[String]).void }
+      attr_writer :name
 
+      # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), `eq` (=), or `not_eq` (!=) to
+      #   filter by balance amount.
       sig { returns(T.nilable(ModernTreasury::Models::LedgerAccountListParams::PendingBalanceAmount)) }
-      def pending_balance_amount
-      end
+      attr_reader :pending_balance_amount
 
       sig do
-        params(_: ModernTreasury::Models::LedgerAccountListParams::PendingBalanceAmount)
-          .returns(ModernTreasury::Models::LedgerAccountListParams::PendingBalanceAmount)
-      end
-      def pending_balance_amount=(_)
+        params(
+          pending_balance_amount: T.any(
+            ModernTreasury::Models::LedgerAccountListParams::PendingBalanceAmount,
+            ModernTreasury::Util::AnyHash
+          )
+        )
+          .void
       end
+      attr_writer :pending_balance_amount
 
       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
 
+      # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), `eq` (=), or `not_eq` (!=) to
+      #   filter by balance amount.
       sig { returns(T.nilable(ModernTreasury::Models::LedgerAccountListParams::PostedBalanceAmount)) }
-      def posted_balance_amount
-      end
+      attr_reader :posted_balance_amount
 
       sig do
-        params(_: ModernTreasury::Models::LedgerAccountListParams::PostedBalanceAmount)
-          .returns(ModernTreasury::Models::LedgerAccountListParams::PostedBalanceAmount)
-      end
-      def posted_balance_amount=(_)
+        params(
+          posted_balance_amount: T.any(ModernTreasury::Models::LedgerAccountListParams::PostedBalanceAmount, ModernTreasury::Util::AnyHash)
+        )
+          .void
       end
+      attr_writer :posted_balance_amount
 
+      # 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(
           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.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,
         available_balance_amount: nil,
@@ -196,57 +209,48 @@ module ModernTreasury
 
       class AvailableBalanceAmount < ModernTreasury::BaseModel
         sig { returns(T.nilable(Integer)) }
-        def eq
-        end
+        attr_reader :eq
 
-        sig { params(_: Integer).returns(Integer) }
-        def eq=(_)
-        end
+        sig { params(eq: Integer).void }
+        attr_writer :eq
 
         sig { returns(T.nilable(Integer)) }
-        def gt
-        end
+        attr_reader :gt
 
-        sig { params(_: Integer).returns(Integer) }
-        def gt=(_)
-        end
+        sig { params(gt: Integer).void }
+        attr_writer :gt
 
         sig { returns(T.nilable(Integer)) }
-        def gte
-        end
+        attr_reader :gte
 
-        sig { params(_: Integer).returns(Integer) }
-        def gte=(_)
-        end
+        sig { params(gte: Integer).void }
+        attr_writer :gte
 
         sig { returns(T.nilable(Integer)) }
-        def lt
-        end
+        attr_reader :lt
 
-        sig { params(_: Integer).returns(Integer) }
-        def lt=(_)
-        end
+        sig { params(lt: Integer).void }
+        attr_writer :lt
 
         sig { returns(T.nilable(Integer)) }
-        def lte
-        end
+        attr_reader :lte
 
-        sig { params(_: Integer).returns(Integer) }
-        def lte=(_)
-        end
+        sig { params(lte: Integer).void }
+        attr_writer :lte
 
         sig { returns(T.nilable(Integer)) }
-        def not_eq
-        end
+        attr_reader :not_eq
 
-        sig { params(_: Integer).returns(Integer) }
-        def not_eq=(_)
-        end
+        sig { params(not_eq: Integer).void }
+        attr_writer :not_eq
 
+        # 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).void
+          params(eq: Integer, gt: Integer, gte: Integer, lt: Integer, lte: Integer, not_eq: Integer)
+            .returns(T.attached_class)
         end
-        def initialize(eq: nil, gt: nil, gte: nil, lt: nil, lte: nil, not_eq: nil)
+        def self.new(eq: nil, gt: nil, gte: nil, lt: nil, lte: nil, not_eq: nil)
         end
 
         sig do
@@ -267,37 +271,34 @@ 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 { returns(T.nilable(Time)) }
-        def effective_at_lower_bound
-        end
+        attr_reader :effective_at_lower_bound
 
-        sig { params(_: Time).returns(Time) }
-        def effective_at_lower_bound=(_)
-        end
+        sig { params(effective_at_lower_bound: Time).void }
+        attr_writer :effective_at_lower_bound
 
         sig { returns(T.nilable(Time)) }
-        def effective_at_upper_bound
-        end
+        attr_reader :effective_at_upper_bound
 
-        sig { params(_: Time).returns(Time) }
-        def effective_at_upper_bound=(_)
-        end
+        sig { params(effective_at_upper_bound: Time).void }
+        attr_writer :effective_at_upper_bound
 
+        # 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.
         sig do
           params(
             as_of_date: Date,
@@ -305,14 +306,9 @@ module ModernTreasury
             effective_at_lower_bound: Time,
             effective_at_upper_bound: Time
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(
-          as_of_date: nil,
-          effective_at: nil,
-          effective_at_lower_bound: nil,
-          effective_at_upper_bound: nil
-        )
+        def self.new(as_of_date: nil, effective_at: nil, effective_at_lower_bound: nil, effective_at_upper_bound: nil)
         end
 
         sig do
@@ -332,57 +328,48 @@ module ModernTreasury
 
       class PendingBalanceAmount < ModernTreasury::BaseModel
         sig { returns(T.nilable(Integer)) }
-        def eq
-        end
+        attr_reader :eq
 
-        sig { params(_: Integer).returns(Integer) }
-        def eq=(_)
-        end
+        sig { params(eq: Integer).void }
+        attr_writer :eq
 
         sig { returns(T.nilable(Integer)) }
-        def gt
-        end
+        attr_reader :gt
 
-        sig { params(_: Integer).returns(Integer) }
-        def gt=(_)
-        end
+        sig { params(gt: Integer).void }
+        attr_writer :gt
 
         sig { returns(T.nilable(Integer)) }
-        def gte
-        end
+        attr_reader :gte
 
-        sig { params(_: Integer).returns(Integer) }
-        def gte=(_)
-        end
+        sig { params(gte: Integer).void }
+        attr_writer :gte
 
         sig { returns(T.nilable(Integer)) }
-        def lt
-        end
+        attr_reader :lt
 
-        sig { params(_: Integer).returns(Integer) }
-        def lt=(_)
-        end
+        sig { params(lt: Integer).void }
+        attr_writer :lt
 
         sig { returns(T.nilable(Integer)) }
-        def lte
-        end
+        attr_reader :lte
 
-        sig { params(_: Integer).returns(Integer) }
-        def lte=(_)
-        end
+        sig { params(lte: Integer).void }
+        attr_writer :lte
 
         sig { returns(T.nilable(Integer)) }
-        def not_eq
-        end
+        attr_reader :not_eq
 
-        sig { params(_: Integer).returns(Integer) }
-        def not_eq=(_)
-        end
+        sig { params(not_eq: Integer).void }
+        attr_writer :not_eq
 
+        # 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).void
+          params(eq: Integer, gt: Integer, gte: Integer, lt: Integer, lte: Integer, not_eq: Integer)
+            .returns(T.attached_class)
         end
-        def initialize(eq: nil, gt: nil, gte: nil, lt: nil, lte: nil, not_eq: nil)
+        def self.new(eq: nil, gt: nil, gte: nil, lt: nil, lte: nil, not_eq: nil)
         end
 
         sig do
@@ -403,57 +390,48 @@ module ModernTreasury
 
       class PostedBalanceAmount < ModernTreasury::BaseModel
         sig { returns(T.nilable(Integer)) }
-        def eq
-        end
+        attr_reader :eq
 
-        sig { params(_: Integer).returns(Integer) }
-        def eq=(_)
-        end
+        sig { params(eq: Integer).void }
+        attr_writer :eq
 
         sig { returns(T.nilable(Integer)) }
-        def gt
-        end
+        attr_reader :gt
 
-        sig { params(_: Integer).returns(Integer) }
-        def gt=(_)
-        end
+        sig { params(gt: Integer).void }
+        attr_writer :gt
 
         sig { returns(T.nilable(Integer)) }
-        def gte
-        end
+        attr_reader :gte
 
-        sig { params(_: Integer).returns(Integer) }
-        def gte=(_)
-        end
+        sig { params(gte: Integer).void }
+        attr_writer :gte
 
         sig { returns(T.nilable(Integer)) }
-        def lt
-        end
+        attr_reader :lt
 
-        sig { params(_: Integer).returns(Integer) }
-        def lt=(_)
-        end
+        sig { params(lt: Integer).void }
+        attr_writer :lt
 
         sig { returns(T.nilable(Integer)) }
-        def lte
-        end
+        attr_reader :lte
 
-        sig { params(_: Integer).returns(Integer) }
-        def lte=(_)
-        end
+        sig { params(lte: Integer).void }
+        attr_writer :lte
 
         sig { returns(T.nilable(Integer)) }
-        def not_eq
-        end
+        attr_reader :not_eq
 
-        sig { params(_: Integer).returns(Integer) }
-        def not_eq=(_)
-        end
+        sig { params(not_eq: Integer).void }
+        attr_writer :not_eq
 
+        # 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).void
+          params(eq: Integer, gt: Integer, gte: Integer, lt: Integer, lte: Integer, not_eq: Integer)
+            .returns(T.attached_class)
         end
-        def initialize(eq: nil, gt: nil, gte: nil, lt: nil, lte: nil, not_eq: nil)
+        def self.new(eq: nil, gt: nil, gte: nil, lt: nil, lte: nil, not_eq: nil)
         end
 
         sig do

data/rbi/lib/modern_treasury/models/ledger_account_retrieve_params.rbi

@@ -6,25 +6,31 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
+      # 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`.
       sig { returns(T.nilable(ModernTreasury::Models::LedgerAccountRetrieveParams::Balances)) }
-      def balances
-      end
+      attr_reader :balances
 
       sig do
-        params(_: ModernTreasury::Models::LedgerAccountRetrieveParams::Balances)
-          .returns(ModernTreasury::Models::LedgerAccountRetrieveParams::Balances)
-      end
-      def balances=(_)
+        params(
+          balances: T.any(ModernTreasury::Models::LedgerAccountRetrieveParams::Balances, ModernTreasury::Util::AnyHash)
+        )
+          .void
       end
+      attr_writer :balances
 
       sig do
         params(
-          balances: ModernTreasury::Models::LedgerAccountRetrieveParams::Balances,
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          balances: T.any(ModernTreasury::Models::LedgerAccountRetrieveParams::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,45 +47,41 @@ 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(Integer)) }
-        def as_of_lock_version
-        end
+        attr_reader :as_of_lock_version
 
-        sig { params(_: Integer).returns(Integer) }
-        def as_of_lock_version=(_)
-        end
+        sig { params(as_of_lock_version: Integer).void }
+        attr_writer :as_of_lock_version
 
         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 { returns(T.nilable(Time)) }
-        def effective_at_lower_bound
-        end
+        attr_reader :effective_at_lower_bound
 
-        sig { params(_: Time).returns(Time) }
-        def effective_at_lower_bound=(_)
-        end
+        sig { params(effective_at_lower_bound: Time).void }
+        attr_writer :effective_at_lower_bound
 
         sig { returns(T.nilable(Time)) }
-        def effective_at_upper_bound
-        end
+        attr_reader :effective_at_upper_bound
 
-        sig { params(_: Time).returns(Time) }
-        def effective_at_upper_bound=(_)
-        end
+        sig { params(effective_at_upper_bound: Time).void }
+        attr_writer :effective_at_upper_bound
 
+        # 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`.
         sig do
           params(
             as_of_date: Date,
@@ -88,9 +90,9 @@ module ModernTreasury
             effective_at_lower_bound: Time,
             effective_at_upper_bound: Time
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(
+        def self.new(
           as_of_date: nil,
           as_of_lock_version: nil,
           effective_at: nil,