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

data/rbi/lib/modern_treasury/models/ledger_event_handler_list_params.rbi

@@ -7,44 +7,37 @@ module ModernTreasury
       include ModernTreasury::RequestParameters
 
       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` (<=), 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.
       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
 
+      # 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
 
       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(
@@ -53,18 +46,11 @@ module ModernTreasury
           metadata: T::Hash[Symbol, String],
           name: 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(
-        after_cursor: nil,
-        created_at: nil,
-        metadata: nil,
-        name: nil,
-        per_page: nil,
-        request_options: {}
-      )
+      def self.new(after_cursor: nil, created_at: nil, metadata: nil, name: nil, per_page: nil, request_options: {})
       end
 
       sig do

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

data/rbi/lib/modern_treasury/models/ledger_event_handler_variable.rbi

@@ -4,26 +4,29 @@ module ModernTreasury
   module Models
     class LedgerEventHandlerVariable < ModernTreasury::BaseModel
       sig { returns(ModernTreasury::Models::LedgerEventHandlerVariable::Query) }
-      def query
-      end
+      attr_reader :query
 
       sig do
-        params(_: ModernTreasury::Models::LedgerEventHandlerVariable::Query)
-          .returns(ModernTreasury::Models::LedgerEventHandlerVariable::Query)
-      end
-      def query=(_)
+        params(
+          query: T.any(ModernTreasury::Models::LedgerEventHandlerVariable::Query, ModernTreasury::Util::AnyHash)
+        )
+          .void
       end
+      attr_writer :query
 
+      # The type of object this variable is. Currently, only "ledger_account" is
+      #   supported.
       sig { returns(String) }
-      def type
-      end
+      attr_accessor :type
 
-      sig { params(_: String).returns(String) }
-      def type=(_)
+      sig do
+        params(
+          query: T.any(ModernTreasury::Models::LedgerEventHandlerVariable::Query, ModernTreasury::Util::AnyHash),
+          type: String
+        )
+          .returns(T.attached_class)
       end
-
-      sig { params(query: ModernTreasury::Models::LedgerEventHandlerVariable::Query, type: String).void }
-      def initialize(query:, type:)
+      def self.new(query:, type:)
       end
 
       sig { override.returns({query: ModernTreasury::Models::LedgerEventHandlerVariable::Query, type: String}) }
@@ -31,32 +34,20 @@ module ModernTreasury
       end
 
       class Query < ModernTreasury::BaseModel
+        # The LHS of the conditional.
         sig { returns(String) }
-        def field
-        end
-
-        sig { params(_: String).returns(String) }
-        def field=(_)
-        end
+        attr_accessor :field
 
+        # What the operator between the `field` and `value` is.
         sig { returns(String) }
-        def operator
-        end
-
-        sig { params(_: String).returns(String) }
-        def operator=(_)
-        end
+        attr_accessor :operator
 
+        # The RHS of the conditional.
         sig { returns(String) }
-        def value
-        end
-
-        sig { params(_: String).returns(String) }
-        def value=(_)
-        end
+        attr_accessor :value
 
-        sig { params(field: String, operator: String, value: String).void }
-        def initialize(field:, operator:, value:)
+        sig { params(field: String, operator: String, value: String).returns(T.attached_class) }
+        def self.new(field:, operator:, value:)
         end
 
         sig { override.returns({field: String, operator: String, value: String}) }

data/rbi/lib/modern_treasury/models/ledger_list_params.rbi

@@ -6,45 +6,40 @@ 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 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(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` (<=), 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.
       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(
@@ -53,18 +48,11 @@ module ModernTreasury
           metadata: T::Hash[Symbol, String],
           per_page: Integer,
           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(
-        id: nil,
-        after_cursor: nil,
-        metadata: nil,
-        per_page: nil,
-        updated_at: nil,
-        request_options: {}
-      )
+      def self.new(id: nil, after_cursor: nil, metadata: nil, per_page: nil, updated_at: nil, request_options: {})
       end
 
       sig do

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

data/rbi/lib/modern_treasury/models/ledger_transaction.rbi

@@ -4,159 +4,86 @@ module ModernTreasury
   module Models
     class LedgerTransaction < ModernTreasury::BaseModel
       sig { returns(String) }
-      def id
-      end
-
-      sig { params(_: String).returns(String) }
-      def id=(_)
-      end
+      attr_accessor :id
 
       sig { returns(Time) }
-      def created_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def created_at=(_)
-      end
+      attr_accessor :created_at
 
+      # An optional description for internal use.
       sig { returns(T.nilable(String)) }
-      def description
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def description=(_)
-      end
+      attr_accessor :description
 
+      # The timestamp (ISO8601 format) at which the ledger transaction happened for
+      #   reporting purposes.
       sig { returns(Time) }
-      def effective_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def effective_at=(_)
-      end
+      attr_accessor :effective_at
 
+      # The date (YYYY-MM-DD) on which the ledger transaction happened for reporting
+      #   purposes.
       sig { returns(Date) }
-      def effective_date
-      end
-
-      sig { params(_: Date).returns(Date) }
-      def effective_date=(_)
-      end
+      attr_accessor :effective_date
 
+      # A unique string to represent the ledger transaction. Only one pending or posted
+      #   ledger transaction may have this ID in the ledger.
       sig { returns(T.nilable(String)) }
-      def external_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def external_id=(_)
-      end
+      attr_accessor :external_id
 
+      # An array of ledger entry objects.
       sig { returns(T::Array[ModernTreasury::Models::LedgerEntry]) }
-      def ledger_entries
-      end
-
-      sig do
-        params(_: T::Array[ModernTreasury::Models::LedgerEntry])
-          .returns(T::Array[ModernTreasury::Models::LedgerEntry])
-      end
-      def ledger_entries=(_)
-      end
+      attr_accessor :ledger_entries
 
+      # The ID of the ledger this ledger transaction belongs to.
       sig { returns(String) }
-      def ledger_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def ledger_id=(_)
-      end
+      attr_accessor :ledger_id
 
+      # If the ledger transaction can be reconciled to another object in Modern
+      #   Treasury, the id will be populated here, otherwise null.
       sig { returns(T.nilable(String)) }
-      def ledgerable_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def ledgerable_id=(_)
-      end
-
-      sig { returns(T.nilable(Symbol)) }
-      def ledgerable_type
-      end
+      attr_accessor :ledgerable_id
 
-      sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-      def ledgerable_type=(_)
-      end
+      # If the ledger transaction can be reconciled to another object in Modern
+      #   Treasury, the type will be populated here, otherwise null. This can be one of
+      #   payment_order, incoming_payment_detail, expected_payment, return, paper_item, or
+      #   reversal.
+      sig { returns(T.nilable(ModernTreasury::Models::LedgerTransaction::LedgerableType::TaggedSymbol)) }
+      attr_accessor :ledgerable_type
 
+      # This field will be true if this object exists in the live environment or false
+      #   if it exists in the test environment.
       sig { returns(T::Boolean) }
-      def live_mode
-      end
-
-      sig { params(_: T::Boolean).returns(T::Boolean) }
-      def live_mode=(_)
-      end
+      attr_accessor :live_mode
 
+      # Additional data represented as key-value pairs. Both the key and value must be
+      #   strings.
       sig { returns(T::Hash[Symbol, String]) }
-      def metadata
-      end
-
-      sig { params(_: T::Hash[Symbol, String]).returns(T::Hash[Symbol, String]) }
-      def metadata=(_)
-      end
+      attr_accessor :metadata
 
       sig { returns(String) }
-      def object
-      end
-
-      sig { params(_: String).returns(String) }
-      def object=(_)
-      end
+      attr_accessor :object
 
+      # The ID of the ledger transaction that this ledger transaction partially posts.
       sig { returns(T.nilable(String)) }
-      def partially_posts_ledger_transaction_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def partially_posts_ledger_transaction_id=(_)
-      end
+      attr_accessor :partially_posts_ledger_transaction_id
 
+      # The time on which the ledger transaction posted. This is null if the ledger
+      #   transaction is pending.
       sig { returns(T.nilable(Time)) }
-      def posted_at
-      end
-
-      sig { params(_: T.nilable(Time)).returns(T.nilable(Time)) }
-      def posted_at=(_)
-      end
+      attr_accessor :posted_at
 
+      # The ID of the ledger transaction that reversed this ledger transaction.
       sig { returns(T.nilable(String)) }
-      def reversed_by_ledger_transaction_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def reversed_by_ledger_transaction_id=(_)
-      end
+      attr_accessor :reversed_by_ledger_transaction_id
 
+      # The ID of the original ledger transaction that this ledger transaction reverses.
       sig { returns(T.nilable(String)) }
-      def reverses_ledger_transaction_id
-      end
+      attr_accessor :reverses_ledger_transaction_id
 
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def reverses_ledger_transaction_id=(_)
-      end
-
-      sig { returns(Symbol) }
-      def status
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def status=(_)
-      end
+      # To post a ledger transaction at creation, use `posted`.
+      sig { returns(ModernTreasury::Models::LedgerTransaction::Status::TaggedSymbol) }
+      attr_accessor :status
 
       sig { returns(Time) }
-      def updated_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def updated_at=(_)
-      end
+      attr_accessor :updated_at
 
       sig do
         params(
@@ -166,10 +93,10 @@ module ModernTreasury
           effective_at: Time,
           effective_date: Date,
           external_id: T.nilable(String),
-          ledger_entries: T::Array[ModernTreasury::Models::LedgerEntry],
+          ledger_entries: T::Array[T.any(ModernTreasury::Models::LedgerEntry, ModernTreasury::Util::AnyHash)],
           ledger_id: String,
           ledgerable_id: T.nilable(String),
-          ledgerable_type: T.nilable(Symbol),
+          ledgerable_type: T.nilable(ModernTreasury::Models::LedgerTransaction::LedgerableType::OrSymbol),
           live_mode: T::Boolean,
           metadata: T::Hash[Symbol, String],
           object: String,
@@ -177,12 +104,12 @@ module ModernTreasury
           posted_at: T.nilable(Time),
           reversed_by_ledger_transaction_id: T.nilable(String),
           reverses_ledger_transaction_id: T.nilable(String),
-          status: Symbol,
+          status: ModernTreasury::Models::LedgerTransaction::Status::OrSymbol,
           updated_at: Time
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         id:,
         created_at:,
         description:,
@@ -218,7 +145,7 @@ module ModernTreasury
               ledger_entries: T::Array[ModernTreasury::Models::LedgerEntry],
               ledger_id: String,
               ledgerable_id: T.nilable(String),
-              ledgerable_type: T.nilable(Symbol),
+              ledgerable_type: T.nilable(ModernTreasury::Models::LedgerTransaction::LedgerableType::TaggedSymbol),
               live_mode: T::Boolean,
               metadata: T::Hash[Symbol, String],
               object: String,
@@ -226,7 +153,7 @@ module ModernTreasury
               posted_at: T.nilable(Time),
               reversed_by_ledger_transaction_id: T.nilable(String),
               reverses_ledger_transaction_id: T.nilable(String),
-              status: Symbol,
+              status: ModernTreasury::Models::LedgerTransaction::Status::TaggedSymbol,
               updated_at: Time
             }
           )
@@ -234,29 +161,45 @@ module ModernTreasury
       def to_hash
       end
 
-      class LedgerableType < ModernTreasury::Enum
-        abstract!
-
-        EXPECTED_PAYMENT = T.let(:expected_payment, T.nilable(Symbol))
-        INCOMING_PAYMENT_DETAIL = T.let(:incoming_payment_detail, T.nilable(Symbol))
-        PAPER_ITEM = T.let(:paper_item, T.nilable(Symbol))
-        PAYMENT_ORDER = T.let(:payment_order, T.nilable(Symbol))
-        RETURN = T.let(:return, T.nilable(Symbol))
-        REVERSAL = T.let(:reversal, T.nilable(Symbol))
-
-        sig { override.returns(T::Array[Symbol]) }
+      # If the ledger transaction can be reconciled to another object in Modern
+      #   Treasury, the type will be populated here, otherwise null. This can be one of
+      #   payment_order, incoming_payment_detail, expected_payment, return, paper_item, or
+      #   reversal.
+      module LedgerableType
+        extend ModernTreasury::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::LedgerTransaction::LedgerableType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::LedgerTransaction::LedgerableType::TaggedSymbol) }
+
+        EXPECTED_PAYMENT =
+          T.let(:expected_payment, ModernTreasury::Models::LedgerTransaction::LedgerableType::TaggedSymbol)
+        INCOMING_PAYMENT_DETAIL =
+          T.let(:incoming_payment_detail, ModernTreasury::Models::LedgerTransaction::LedgerableType::TaggedSymbol)
+        PAPER_ITEM = T.let(:paper_item, ModernTreasury::Models::LedgerTransaction::LedgerableType::TaggedSymbol)
+        PAYMENT_ORDER =
+          T.let(:payment_order, ModernTreasury::Models::LedgerTransaction::LedgerableType::TaggedSymbol)
+        RETURN = T.let(:return, ModernTreasury::Models::LedgerTransaction::LedgerableType::TaggedSymbol)
+        REVERSAL = T.let(:reversal, ModernTreasury::Models::LedgerTransaction::LedgerableType::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::LedgerTransaction::LedgerableType::TaggedSymbol]) }
         def self.values
         end
       end
 
-      class Status < ModernTreasury::Enum
-        abstract!
+      # To post a ledger transaction at creation, use `posted`.
+      module Status
+        extend ModernTreasury::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::LedgerTransaction::Status) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::LedgerTransaction::Status::TaggedSymbol) }
 
-        ARCHIVED = :archived
-        PENDING = :pending
-        POSTED = :posted
+        ARCHIVED = T.let(:archived, ModernTreasury::Models::LedgerTransaction::Status::TaggedSymbol)
+        PENDING = T.let(:pending, ModernTreasury::Models::LedgerTransaction::Status::TaggedSymbol)
+        POSTED = T.let(:posted, ModernTreasury::Models::LedgerTransaction::Status::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[ModernTreasury::Models::LedgerTransaction::Status::TaggedSymbol]) }
         def self.values
         end
       end