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

data/rbi/lib/modern_treasury/models/event.rbi

@@ -4,84 +4,41 @@ module ModernTreasury
   module Models
     class Event < 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
 
+      # The body of the event.
       sig { returns(T::Hash[Symbol, T.anything]) }
-      def data
-      end
-
-      sig { params(_: T::Hash[Symbol, T.anything]).returns(T::Hash[Symbol, T.anything]) }
-      def data=(_)
-      end
+      attr_accessor :data
 
+      # The ID of the entity for the event.
       sig { returns(String) }
-      def entity_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def entity_id=(_)
-      end
+      attr_accessor :entity_id
 
+      # The name of the event.
       sig { returns(String) }
-      def event_name
-      end
-
-      sig { params(_: String).returns(String) }
-      def event_name=(_)
-      end
+      attr_accessor :event_name
 
+      # The time of the event.
       sig { returns(Time) }
-      def event_time
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def event_time=(_)
-      end
+      attr_accessor :event_time
 
+      # 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
 
       sig { returns(String) }
-      def object
-      end
-
-      sig { params(_: String).returns(String) }
-      def object=(_)
-      end
+      attr_accessor :object
 
+      # The type of resource for the event.
       sig { returns(String) }
-      def resource
-      end
-
-      sig { params(_: String).returns(String) }
-      def resource=(_)
-      end
+      attr_accessor :resource
 
       sig { returns(Time) }
-      def updated_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def updated_at=(_)
-      end
+      attr_accessor :updated_at
 
       sig do
         params(
@@ -96,20 +53,9 @@ module ModernTreasury
           resource: String,
           updated_at: Time
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
-        id:,
-        created_at:,
-        data:,
-        entity_id:,
-        event_name:,
-        event_time:,
-        live_mode:,
-        object:,
-        resource:,
-        updated_at:
-      )
+      def self.new(id:, created_at:, data:, entity_id:, event_name:, event_time:, live_mode:, object:, resource:, updated_at:)
       end
 
       sig do

data/rbi/lib/modern_treasury/models/event_list_params.rbi

@@ -7,60 +7,45 @@ 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
 
       sig { returns(T.nilable(String)) }
-      def entity_id
-      end
+      attr_reader :entity_id
 
-      sig { params(_: String).returns(String) }
-      def entity_id=(_)
-      end
+      sig { params(entity_id: String).void }
+      attr_writer :entity_id
 
       sig { returns(T.nilable(String)) }
-      def event_name
-      end
+      attr_reader :event_name
 
-      sig { params(_: String).returns(String) }
-      def event_name=(_)
-      end
+      sig { params(event_name: String).void }
+      attr_writer :event_name
 
+      # An inclusive upper bound for when the event occurred
       sig { returns(T.nilable(Time)) }
-      def event_time_end
-      end
+      attr_reader :event_time_end
 
-      sig { params(_: Time).returns(Time) }
-      def event_time_end=(_)
-      end
+      sig { params(event_time_end: Time).void }
+      attr_writer :event_time_end
 
+      # An inclusive lower bound for when the event occurred
       sig { returns(T.nilable(Time)) }
-      def event_time_start
-      end
+      attr_reader :event_time_start
 
-      sig { params(_: Time).returns(Time) }
-      def event_time_start=(_)
-      end
+      sig { params(event_time_start: Time).void }
+      attr_writer :event_time_start
 
       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 { returns(T.nilable(String)) }
-      def resource
-      end
+      attr_reader :resource
 
-      sig { params(_: String).returns(String) }
-      def resource=(_)
-      end
+      sig { params(resource: String).void }
+      attr_writer :resource
 
       sig do
         params(
@@ -71,11 +56,11 @@ module ModernTreasury
           event_time_start: Time,
           per_page: Integer,
           resource: 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(
         after_cursor: nil,
         entity_id: nil,
         event_name: nil,

data/rbi/lib/modern_treasury/models/event_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/expected_payment.rbi

@@ -4,215 +4,117 @@ module ModernTreasury
   module Models
     class ExpectedPayment < ModernTreasury::BaseModel
       sig { returns(String) }
-      def id
-      end
-
-      sig { params(_: String).returns(String) }
-      def id=(_)
-      end
+      attr_accessor :id
 
+      # The lowest amount this expected payment may be equal to. Value in specified
+      #   currency's smallest unit. e.g. $10 would be represented as 1000.
       sig { returns(T.nilable(Integer)) }
-      def amount_lower_bound
-      end
-
-      sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-      def amount_lower_bound=(_)
-      end
+      attr_accessor :amount_lower_bound
 
+      # The highest amount this expected payment may be equal to. Value in specified
+      #   currency's smallest unit. e.g. $10 would be represented as 1000.
       sig { returns(T.nilable(Integer)) }
-      def amount_upper_bound
-      end
-
-      sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-      def amount_upper_bound=(_)
-      end
+      attr_accessor :amount_upper_bound
 
+      # The ID of the counterparty you expect for this payment.
       sig { returns(T.nilable(String)) }
-      def counterparty_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def counterparty_id=(_)
-      end
+      attr_accessor :counterparty_id
 
       sig { returns(Time) }
-      def created_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def created_at=(_)
-      end
-
-      sig { returns(T.nilable(Symbol)) }
-      def currency
-      end
+      attr_accessor :created_at
 
-      sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-      def currency=(_)
-      end
+      # Must conform to ISO 4217. Defaults to the currency of the internal account.
+      sig { returns(T.nilable(ModernTreasury::Models::Currency::TaggedSymbol)) }
+      attr_accessor :currency
 
+      # The earliest date the payment may come in. Format: yyyy-mm-dd
       sig { returns(T.nilable(Date)) }
-      def date_lower_bound
-      end
-
-      sig { params(_: T.nilable(Date)).returns(T.nilable(Date)) }
-      def date_lower_bound=(_)
-      end
+      attr_accessor :date_lower_bound
 
+      # The latest date the payment may come in. Format: yyyy-mm-dd
       sig { returns(T.nilable(Date)) }
-      def date_upper_bound
-      end
-
-      sig { params(_: T.nilable(Date)).returns(T.nilable(Date)) }
-      def date_upper_bound=(_)
-      end
+      attr_accessor :date_upper_bound
 
+      # An optional description for internal use.
       sig { returns(T.nilable(String)) }
-      def description
-      end
+      attr_accessor :description
 
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def description=(_)
-      end
-
-      sig { returns(T.nilable(Symbol)) }
-      def direction
-      end
-
-      sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-      def direction=(_)
-      end
+      # One of credit or debit. When you are receiving money, use credit. When you are
+      #   being charged, use debit.
+      sig { returns(T.nilable(ModernTreasury::Models::ExpectedPayment::Direction::TaggedSymbol)) }
+      attr_accessor :direction
 
+      # The ID of the Internal Account for the expected payment.
       sig { returns(T.nilable(String)) }
-      def internal_account_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def internal_account_id=(_)
-      end
+      attr_accessor :internal_account_id
 
+      # The ID of the ledger transaction linked to the expected payment.
       sig { returns(T.nilable(String)) }
-      def ledger_transaction_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def ledger_transaction_id=(_)
-      end
+      attr_accessor :ledger_transaction_id
 
+      # 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 reconciliation filters you have for this payment.
       sig { returns(T.nilable(T.anything)) }
-      def reconciliation_filters
-      end
-
-      sig { params(_: T.nilable(T.anything)).returns(T.nilable(T.anything)) }
-      def reconciliation_filters=(_)
-      end
+      attr_accessor :reconciliation_filters
 
+      # The reconciliation groups you have for this payment.
       sig { returns(T.nilable(T.anything)) }
-      def reconciliation_groups
-      end
+      attr_accessor :reconciliation_groups
 
-      sig { params(_: T.nilable(T.anything)).returns(T.nilable(T.anything)) }
-      def reconciliation_groups=(_)
-      end
-
-      sig { returns(T.nilable(Symbol)) }
-      def reconciliation_method
-      end
-
-      sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-      def reconciliation_method=(_)
-      end
+      # One of manual if this expected payment was manually reconciled in the dashboard,
+      #   automatic if it was automatically reconciled by Modern Treasury, or null if it
+      #   is unreconciled.
+      sig { returns(T.nilable(ModernTreasury::Models::ExpectedPayment::ReconciliationMethod::TaggedSymbol)) }
+      attr_accessor :reconciliation_method
 
+      # An array of reconciliation rule variables for this payment.
       sig { returns(T.nilable(T::Array[ModernTreasury::Models::ReconciliationRule])) }
-      def reconciliation_rule_variables
-      end
-
-      sig do
-        params(_: T.nilable(T::Array[ModernTreasury::Models::ReconciliationRule]))
-          .returns(T.nilable(T::Array[ModernTreasury::Models::ReconciliationRule]))
-      end
-      def reconciliation_rule_variables=(_)
-      end
+      attr_accessor :reconciliation_rule_variables
 
+      # For `ach`, this field will be passed through on an addenda record. For `wire`
+      #   payments the field will be passed through as the "Originator to Beneficiary
+      #   Information", also known as OBI or Fedwire tag 6000.
       sig { returns(T.nilable(String)) }
-      def remittance_information
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def remittance_information=(_)
-      end
+      attr_accessor :remittance_information
 
+      # The statement description you expect to see on the transaction. For ACH
+      #   payments, this will be the full line item passed from the bank. For wire
+      #   payments, this will be the OBI field on the wire. For check payments, this will
+      #   be the memo field.
       sig { returns(T.nilable(String)) }
-      def statement_descriptor
-      end
+      attr_accessor :statement_descriptor
 
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def statement_descriptor=(_)
-      end
-
-      sig { returns(Symbol) }
-      def status
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def status=(_)
-      end
+      # One of unreconciled, partially_reconciled, reconciled, or archived.
+      sig { returns(ModernTreasury::Models::ExpectedPayment::Status::TaggedSymbol) }
+      attr_accessor :status
 
+      # The ID of the Transaction this expected payment object has been matched to.
       sig { returns(T.nilable(String)) }
-      def transaction_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def transaction_id=(_)
-      end
+      attr_accessor :transaction_id
 
+      # The ID of the Transaction Line Item this expected payment has been matched to.
       sig { returns(T.nilable(String)) }
-      def transaction_line_item_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def transaction_line_item_id=(_)
-      end
+      attr_accessor :transaction_line_item_id
 
-      sig { returns(T.nilable(Symbol)) }
-      def type
-      end
-
-      sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-      def type=(_)
-      end
+      # One of: ach, au_becs, bacs, book, check, eft, interac, provxchange, rtp, sen,
+      #   sepa, signet, wire.
+      sig { returns(T.nilable(ModernTreasury::Models::ExpectedPaymentType::TaggedSymbol)) }
+      attr_accessor :type
 
       sig { returns(Time) }
-      def updated_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def updated_at=(_)
-      end
+      attr_accessor :updated_at
 
       sig do
         params(
@@ -221,11 +123,11 @@ module ModernTreasury
           amount_upper_bound: T.nilable(Integer),
           counterparty_id: T.nilable(String),
           created_at: Time,
-          currency: T.nilable(Symbol),
+          currency: T.nilable(ModernTreasury::Models::Currency::OrSymbol),
           date_lower_bound: T.nilable(Date),
           date_upper_bound: T.nilable(Date),
           description: T.nilable(String),
-          direction: T.nilable(Symbol),
+          direction: T.nilable(ModernTreasury::Models::ExpectedPayment::Direction::OrSymbol),
           internal_account_id: T.nilable(String),
           ledger_transaction_id: T.nilable(String),
           live_mode: T::Boolean,
@@ -233,19 +135,19 @@ module ModernTreasury
           object: String,
           reconciliation_filters: T.nilable(T.anything),
           reconciliation_groups: T.nilable(T.anything),
-          reconciliation_method: T.nilable(Symbol),
-          reconciliation_rule_variables: T.nilable(T::Array[ModernTreasury::Models::ReconciliationRule]),
+          reconciliation_method: T.nilable(ModernTreasury::Models::ExpectedPayment::ReconciliationMethod::OrSymbol),
+          reconciliation_rule_variables: T.nilable(T::Array[T.any(ModernTreasury::Models::ReconciliationRule, ModernTreasury::Util::AnyHash)]),
           remittance_information: T.nilable(String),
           statement_descriptor: T.nilable(String),
-          status: Symbol,
+          status: ModernTreasury::Models::ExpectedPayment::Status::OrSymbol,
           transaction_id: T.nilable(String),
           transaction_line_item_id: T.nilable(String),
-          type: T.nilable(Symbol),
+          type: T.nilable(ModernTreasury::Models::ExpectedPaymentType::OrSymbol),
           updated_at: Time
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         id:,
         amount_lower_bound:,
         amount_upper_bound:,
@@ -284,11 +186,11 @@ module ModernTreasury
               amount_upper_bound: T.nilable(Integer),
               counterparty_id: T.nilable(String),
               created_at: Time,
-              currency: T.nilable(Symbol),
+              currency: T.nilable(ModernTreasury::Models::Currency::TaggedSymbol),
               date_lower_bound: T.nilable(Date),
               date_upper_bound: T.nilable(Date),
               description: T.nilable(String),
-              direction: T.nilable(Symbol),
+              direction: T.nilable(ModernTreasury::Models::ExpectedPayment::Direction::TaggedSymbol),
               internal_account_id: T.nilable(String),
               ledger_transaction_id: T.nilable(String),
               live_mode: T::Boolean,
@@ -296,14 +198,14 @@ module ModernTreasury
               object: String,
               reconciliation_filters: T.nilable(T.anything),
               reconciliation_groups: T.nilable(T.anything),
-              reconciliation_method: T.nilable(Symbol),
+              reconciliation_method: T.nilable(ModernTreasury::Models::ExpectedPayment::ReconciliationMethod::TaggedSymbol),
               reconciliation_rule_variables: T.nilable(T::Array[ModernTreasury::Models::ReconciliationRule]),
               remittance_information: T.nilable(String),
               statement_descriptor: T.nilable(String),
-              status: Symbol,
+              status: ModernTreasury::Models::ExpectedPayment::Status::TaggedSymbol,
               transaction_id: T.nilable(String),
               transaction_line_item_id: T.nilable(String),
-              type: T.nilable(Symbol),
+              type: T.nilable(ModernTreasury::Models::ExpectedPaymentType::TaggedSymbol),
               updated_at: Time
             }
           )
@@ -311,37 +213,57 @@ module ModernTreasury
       def to_hash
       end
 
-      class Direction < ModernTreasury::Enum
-        abstract!
+      # One of credit or debit. When you are receiving money, use credit. When you are
+      #   being charged, use debit.
+      module Direction
+        extend ModernTreasury::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::ExpectedPayment::Direction) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::ExpectedPayment::Direction::TaggedSymbol) }
 
-        CREDIT = T.let(:credit, T.nilable(Symbol))
-        DEBIT = T.let(:debit, T.nilable(Symbol))
+        CREDIT = T.let(:credit, ModernTreasury::Models::ExpectedPayment::Direction::TaggedSymbol)
+        DEBIT = T.let(:debit, ModernTreasury::Models::ExpectedPayment::Direction::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[ModernTreasury::Models::ExpectedPayment::Direction::TaggedSymbol]) }
         def self.values
         end
       end
 
-      class ReconciliationMethod < ModernTreasury::Enum
-        abstract!
+      # One of manual if this expected payment was manually reconciled in the dashboard,
+      #   automatic if it was automatically reconciled by Modern Treasury, or null if it
+      #   is unreconciled.
+      module ReconciliationMethod
+        extend ModernTreasury::Enum
 
-        AUTOMATIC = T.let(:automatic, T.nilable(Symbol))
-        MANUAL = T.let(:manual, T.nilable(Symbol))
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::ExpectedPayment::ReconciliationMethod) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::ExpectedPayment::ReconciliationMethod::TaggedSymbol) }
 
-        sig { override.returns(T::Array[Symbol]) }
+        AUTOMATIC =
+          T.let(:automatic, ModernTreasury::Models::ExpectedPayment::ReconciliationMethod::TaggedSymbol)
+        MANUAL = T.let(:manual, ModernTreasury::Models::ExpectedPayment::ReconciliationMethod::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::ExpectedPayment::ReconciliationMethod::TaggedSymbol]) }
         def self.values
         end
       end
 
-      class Status < ModernTreasury::Enum
-        abstract!
+      # One of unreconciled, partially_reconciled, reconciled, or archived.
+      module Status
+        extend ModernTreasury::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::ExpectedPayment::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, ModernTreasury::Models::ExpectedPayment::Status::TaggedSymbol) }
 
-        ARCHIVED = :archived
-        PARTIALLY_RECONCILED = :partially_reconciled
-        RECONCILED = :reconciled
-        UNRECONCILED = :unreconciled
+        ARCHIVED = T.let(:archived, ModernTreasury::Models::ExpectedPayment::Status::TaggedSymbol)
+        PARTIALLY_RECONCILED =
+          T.let(:partially_reconciled, ModernTreasury::Models::ExpectedPayment::Status::TaggedSymbol)
+        RECONCILED = T.let(:reconciled, ModernTreasury::Models::ExpectedPayment::Status::TaggedSymbol)
+        UNRECONCILED = T.let(:unreconciled, ModernTreasury::Models::ExpectedPayment::Status::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[ModernTreasury::Models::ExpectedPayment::Status::TaggedSymbol]) }
         def self.values
         end
       end