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

data/rbi/lib/modern_treasury/models/ledger_transaction_create_params.rbi

@@ -2,101 +2,99 @@
 
 module ModernTreasury
   module Models
-    class LedgerTransactionCreateParams < ModernTreasury::BaseModel
-      extend ModernTreasury::RequestParameters::Converter
-      include ModernTreasury::RequestParameters
+    class LedgerTransactionCreateParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::RequestParameters
 
+      # An array of ledger entry objects.
       sig { returns(T::Array[ModernTreasury::Models::LedgerTransactionCreateParams::LedgerEntry]) }
-      def ledger_entries
-      end
-
-      sig do
-        params(_: T::Array[ModernTreasury::Models::LedgerTransactionCreateParams::LedgerEntry])
-          .returns(T::Array[ModernTreasury::Models::LedgerTransactionCreateParams::LedgerEntry])
-      end
-      def ledger_entries=(_)
-      end
+      attr_accessor :ledger_entries
 
+      # 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(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
 
+      # The date (YYYY-MM-DD) on which the ledger transaction happened for reporting
+      # purposes.
       sig { returns(T.nilable(Date)) }
-      def effective_date
-      end
+      attr_reader :effective_date
 
-      sig { params(_: Date).returns(Date) }
-      def effective_date=(_)
-      end
+      sig { params(effective_date: Date).void }
+      attr_writer :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
+      attr_reader :external_id
 
-      sig { params(_: String).returns(String) }
-      def external_id=(_)
-      end
+      sig { params(external_id: String).void }
+      attr_writer :external_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
+      attr_reader :ledgerable_id
 
-      sig { params(_: String).returns(String) }
-      def ledgerable_id=(_)
-      end
+      sig { params(ledgerable_id: String).void }
+      attr_writer :ledgerable_id
 
-      sig { 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::LedgerTransactionCreateParams::LedgerableType::OrSymbol)) }
+      attr_reader :ledgerable_type
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def ledgerable_type=(_)
+      sig do
+        params(ledgerable_type: ModernTreasury::Models::LedgerTransactionCreateParams::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])) }
-      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(Symbol)) }
-      def status
-      end
+      # To post a ledger transaction at creation, use `posted`.
+      sig { returns(T.nilable(ModernTreasury::Models::LedgerTransactionCreateParams::Status::OrSymbol)) }
+      attr_reader :status
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def status=(_)
-      end
+      sig { params(status: ModernTreasury::Models::LedgerTransactionCreateParams::Status::OrSymbol).void }
+      attr_writer :status
 
       sig do
         params(
-          ledger_entries: T::Array[ModernTreasury::Models::LedgerTransactionCreateParams::LedgerEntry],
+          ledger_entries: T::Array[
+            T.any(
+              ModernTreasury::Models::LedgerTransactionCreateParams::LedgerEntry,
+              ModernTreasury::Internal::AnyHash
+            )
+          ],
           description: T.nilable(String),
           effective_at: Time,
           effective_date: Date,
           external_id: String,
           ledgerable_id: String,
-          ledgerable_type: Symbol,
+          ledgerable_type: ModernTreasury::Models::LedgerTransactionCreateParams::LedgerableType::OrSymbol,
           metadata: T::Hash[Symbol, String],
-          status: Symbol,
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          status: ModernTreasury::Models::LedgerTransactionCreateParams::Status::OrSymbol,
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         ledger_entries:,
         description: nil,
         effective_at: nil,
@@ -107,9 +105,7 @@ module ModernTreasury
         metadata: nil,
         status: nil,
         request_options: {}
-      )
-      end
-
+      ); end
       sig do
         override
           .returns(
@@ -120,93 +116,74 @@ module ModernTreasury
               effective_date: Date,
               external_id: String,
               ledgerable_id: String,
-              ledgerable_type: Symbol,
+              ledgerable_type: ModernTreasury::Models::LedgerTransactionCreateParams::LedgerableType::OrSymbol,
               metadata: T::Hash[Symbol, String],
-              status: Symbol,
+              status: ModernTreasury::Models::LedgerTransactionCreateParams::Status::OrSymbol,
               request_options: ModernTreasury::RequestOptions
             }
           )
       end
-      def to_hash
-      end
+      def to_hash; end
 
-      class LedgerEntry < ModernTreasury::BaseModel
+      class LedgerEntry < ModernTreasury::Internal::Type::BaseModel
+        # Value in specified currency's smallest unit. e.g. $10 would be represented
+        # as 1000. Can be any integer up to 36 digits.
         sig { returns(Integer) }
-        def amount
-        end
+        attr_accessor :amount
 
-        sig { params(_: Integer).returns(Integer) }
-        def amount=(_)
-        end
-
-        sig { returns(Symbol) }
-        def direction
-        end
-
-        sig { params(_: Symbol).returns(Symbol) }
-        def direction=(_)
-        end
+        # One of `credit`, `debit`. Describes the direction money is flowing in the
+        # transaction. A `credit` moves money from your account to someone else's. A
+        # `debit` pulls money from someone else's account to your own. Note that wire,
+        # rtp, and check payments will always be `credit`.
+        sig { returns(ModernTreasury::Models::TransactionDirection::OrSymbol) }
+        attr_accessor :direction
 
+        # The ledger account that this ledger entry is associated with.
         sig { returns(String) }
-        def ledger_account_id
-        end
-
-        sig { params(_: String).returns(String) }
-        def ledger_account_id=(_)
-        end
+        attr_accessor :ledger_account_id
 
+        # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), or `eq` (=) to lock on the
+        # account’s available balance. If any of these conditions would be false after the
+        # transaction is created, the entire call will fail with error code 422.
         sig { returns(T.nilable(T::Hash[Symbol, Integer])) }
-        def available_balance_amount
-        end
-
-        sig { params(_: T.nilable(T::Hash[Symbol, Integer])).returns(T.nilable(T::Hash[Symbol, Integer])) }
-        def available_balance_amount=(_)
-        end
+        attr_accessor :available_balance_amount
 
+        # Lock version of the ledger account. This can be passed when creating a ledger
+        # transaction to only succeed if no ledger transactions have posted since the
+        # given version. See our post about Designing the Ledgers API with Optimistic
+        # Locking for more details.
         sig { returns(T.nilable(Integer)) }
-        def lock_version
-        end
-
-        sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-        def lock_version=(_)
-        end
+        attr_accessor :lock_version
 
+        # 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
 
+        # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), or `eq` (=) to lock on the
+        # account’s pending balance. If any of these conditions would be false after the
+        # transaction is created, the entire call will fail with error code 422.
         sig { returns(T.nilable(T::Hash[Symbol, Integer])) }
-        def pending_balance_amount
-        end
-
-        sig { params(_: T.nilable(T::Hash[Symbol, Integer])).returns(T.nilable(T::Hash[Symbol, Integer])) }
-        def pending_balance_amount=(_)
-        end
+        attr_accessor :pending_balance_amount
 
+        # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), or `eq` (=) to lock on the
+        # account’s posted balance. If any of these conditions would be false after the
+        # transaction is created, the entire call will fail with error code 422.
         sig { returns(T.nilable(T::Hash[Symbol, Integer])) }
-        def posted_balance_amount
-        end
-
-        sig { params(_: T.nilable(T::Hash[Symbol, Integer])).returns(T.nilable(T::Hash[Symbol, Integer])) }
-        def posted_balance_amount=(_)
-        end
+        attr_accessor :posted_balance_amount
 
+        # If true, response will include the balance of the associated ledger account for
+        # the entry.
         sig { returns(T.nilable(T::Boolean)) }
-        def show_resulting_ledger_account_balances
-        end
-
-        sig { params(_: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
-        def show_resulting_ledger_account_balances=(_)
-        end
+        attr_accessor :show_resulting_ledger_account_balances
 
         sig do
           params(
             amount: Integer,
-            direction: Symbol,
+            direction: ModernTreasury::Models::TransactionDirection::OrSymbol,
             ledger_account_id: String,
             available_balance_amount: T.nilable(T::Hash[Symbol, Integer]),
             lock_version: T.nilable(Integer),
@@ -215,9 +192,9 @@ module ModernTreasury
             posted_balance_amount: T.nilable(T::Hash[Symbol, Integer]),
             show_resulting_ledger_account_balances: T.nilable(T::Boolean)
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(
+        def self.new(
           amount:,
           direction:,
           ledger_account_id:,
@@ -227,15 +204,13 @@ module ModernTreasury
           pending_balance_amount: nil,
           posted_balance_amount: nil,
           show_resulting_ledger_account_balances: nil
-        )
-        end
-
+        ); end
         sig do
           override
             .returns(
               {
                 amount: Integer,
-                direction: Symbol,
+                direction: ModernTreasury::Models::TransactionDirection::OrSymbol,
                 ledger_account_id: String,
                 available_balance_amount: T.nilable(T::Hash[Symbol, Integer]),
                 lock_version: T.nilable(Integer),
@@ -246,35 +221,62 @@ module ModernTreasury
               }
             )
         end
-        def to_hash
-        end
+        def to_hash; end
       end
 
-      class LedgerableType < ModernTreasury::Enum
-        abstract!
-
-        EXPECTED_PAYMENT = :expected_payment
-        INCOMING_PAYMENT_DETAIL = :incoming_payment_detail
-        PAPER_ITEM = :paper_item
-        PAYMENT_ORDER = :payment_order
-        RETURN = :return
-        REVERSAL = :reversal
+      # 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::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::LedgerTransactionCreateParams::LedgerableType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, ModernTreasury::Models::LedgerTransactionCreateParams::LedgerableType::TaggedSymbol) }
+
+        EXPECTED_PAYMENT =
+          T.let(
+            :expected_payment,
+            ModernTreasury::Models::LedgerTransactionCreateParams::LedgerableType::TaggedSymbol
+          )
+        INCOMING_PAYMENT_DETAIL =
+          T.let(
+            :incoming_payment_detail,
+            ModernTreasury::Models::LedgerTransactionCreateParams::LedgerableType::TaggedSymbol
+          )
+        PAPER_ITEM =
+          T.let(:paper_item, ModernTreasury::Models::LedgerTransactionCreateParams::LedgerableType::TaggedSymbol)
+        PAYMENT_ORDER =
+          T.let(:payment_order, ModernTreasury::Models::LedgerTransactionCreateParams::LedgerableType::TaggedSymbol)
+        RETURN =
+          T.let(:return, ModernTreasury::Models::LedgerTransactionCreateParams::LedgerableType::TaggedSymbol)
+        REVERSAL =
+          T.let(:reversal, ModernTreasury::Models::LedgerTransactionCreateParams::LedgerableType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
+        sig do
+          override
+            .returns(T::Array[ModernTreasury::Models::LedgerTransactionCreateParams::LedgerableType::TaggedSymbol])
         end
+        def self.values; end
       end
 
-      class Status < ModernTreasury::Enum
-        abstract!
+      # To post a ledger transaction at creation, use `posted`.
+      module Status
+        extend ModernTreasury::Internal::Type::Enum
 
-        ARCHIVED = :archived
-        PENDING = :pending
-        POSTED = :posted
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::LedgerTransactionCreateParams::Status) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, ModernTreasury::Models::LedgerTransactionCreateParams::Status::TaggedSymbol) }
 
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
-        end
+        ARCHIVED = T.let(:archived, ModernTreasury::Models::LedgerTransactionCreateParams::Status::TaggedSymbol)
+        PENDING = T.let(:pending, ModernTreasury::Models::LedgerTransactionCreateParams::Status::TaggedSymbol)
+        POSTED = T.let(:posted, ModernTreasury::Models::LedgerTransactionCreateParams::Status::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::LedgerTransactionCreateParams::Status::TaggedSymbol]) }
+        def self.values; end
       end
     end
   end

data/rbi/lib/modern_treasury/models/ledger_transaction_create_partial_post_params.rbi

@@ -2,56 +2,56 @@
 
 module ModernTreasury
   module Models
-    class LedgerTransactionCreatePartialPostParams < ModernTreasury::BaseModel
-      extend ModernTreasury::RequestParameters::Converter
-      include ModernTreasury::RequestParameters
+    class LedgerTransactionCreatePartialPostParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::RequestParameters
 
+      # An array of ledger entry objects to be set on the posted ledger transaction.
+      # There must be one entry for each of the existing entries with a lesser amount
+      # than the existing entry.
       sig { returns(T::Array[ModernTreasury::Models::LedgerTransactionCreatePartialPostParams::PostedLedgerEntry]) }
-      def posted_ledger_entries
-      end
-
-      sig do
-        params(_: T::Array[ModernTreasury::Models::LedgerTransactionCreatePartialPostParams::PostedLedgerEntry])
-          .returns(T::Array[ModernTreasury::Models::LedgerTransactionCreatePartialPostParams::PostedLedgerEntry])
-      end
-      def posted_ledger_entries=(_)
-      end
+      attr_accessor :posted_ledger_entries
 
+      # An optional free-form description for the posted ledger transaction. Maximum of
+      # 1000 characters allowed.
       sig { returns(T.nilable(String)) }
-      def description
-      end
+      attr_reader :description
 
-      sig { params(_: String).returns(String) }
-      def description=(_)
-      end
+      sig { params(description: String).void }
+      attr_writer :description
 
+      # The timestamp (IS08601 format) at which the posted ledger transaction happened
+      # for reporting purposes.
       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
 
+      # 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(
-          posted_ledger_entries: T::Array[ModernTreasury::Models::LedgerTransactionCreatePartialPostParams::PostedLedgerEntry],
+          posted_ledger_entries: T::Array[
+            T.any(
+              ModernTreasury::Models::LedgerTransactionCreatePartialPostParams::PostedLedgerEntry,
+              ModernTreasury::Internal::AnyHash
+            )
+          ],
           description: String,
           effective_at: Time,
           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(
         posted_ledger_entries:,
         description: nil,
         effective_at: nil,
@@ -72,77 +72,101 @@ module ModernTreasury
             }
           )
       end
-      def to_hash
-      end
+      def to_hash; end
 
-      class PostedLedgerEntry < ModernTreasury::BaseModel
+      class PostedLedgerEntry < ModernTreasury::Internal::Type::BaseModel
+        # Value in specified currency's smallest unit. e.g. $10 would be represented
+        # as 1000. Can be any integer up to 36 digits.
         sig { returns(Integer) }
-        def amount
-        end
-
-        sig { params(_: Integer).returns(Integer) }
-        def amount=(_)
-        end
+        attr_accessor :amount
 
-        sig { returns(Symbol) }
-        def direction
-        end
-
-        sig { params(_: Symbol).returns(Symbol) }
-        def direction=(_)
+        # One of `credit`, `debit`. Describes the direction money is flowing in the
+        # transaction. A `credit` moves money from your account to someone else's. A
+        # `debit` pulls money from someone else's account to your own. Note that wire,
+        # rtp, and check payments will always be `credit`.
+        sig do
+          returns(
+            ModernTreasury::Models::LedgerTransactionCreatePartialPostParams::PostedLedgerEntry::Direction::OrSymbol
+          )
         end
+        attr_accessor :direction
 
+        # The ledger account that this ledger entry is associated with.
         sig { returns(String) }
-        def ledger_account_id
-        end
-
-        sig { params(_: String).returns(String) }
-        def ledger_account_id=(_)
-        end
+        attr_accessor :ledger_account_id
 
+        # 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(
             amount: Integer,
-            direction: Symbol,
+            direction: ModernTreasury::Models::LedgerTransactionCreatePartialPostParams::PostedLedgerEntry::Direction::OrSymbol,
             ledger_account_id: String,
             metadata: T::Hash[Symbol, String]
           )
-            .void
-        end
-        def initialize(amount:, direction:, ledger_account_id:, metadata: nil)
+            .returns(T.attached_class)
         end
+        def self.new(amount:, direction:, ledger_account_id:, metadata: nil); end
 
         sig do
           override
             .returns(
               {
                 amount: Integer,
-                direction: Symbol,
+                direction: ModernTreasury::Models::LedgerTransactionCreatePartialPostParams::PostedLedgerEntry::Direction::OrSymbol,
                 ledger_account_id: String,
                 metadata: T::Hash[Symbol, String]
               }
             )
         end
-        def to_hash
-        end
-
-        class Direction < ModernTreasury::Enum
-          abstract!
-
-          CREDIT = :credit
-          DEBIT = :debit
+        def to_hash; end
+
+        # One of `credit`, `debit`. Describes the direction money is flowing in the
+        # transaction. A `credit` moves money from your account to someone else's. A
+        # `debit` pulls money from someone else's account to your own. Note that wire,
+        # rtp, and check payments will always be `credit`.
+        module Direction
+          extend ModernTreasury::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, ModernTreasury::Models::LedgerTransactionCreatePartialPostParams::PostedLedgerEntry::Direction)
+            end
+          OrSymbol =
+            T.type_alias do
+              T.any(
+                Symbol,
+                String,
+                ModernTreasury::Models::LedgerTransactionCreatePartialPostParams::PostedLedgerEntry::Direction::TaggedSymbol
+              )
+            end
+
+          CREDIT =
+            T.let(
+              :credit,
+              ModernTreasury::Models::LedgerTransactionCreatePartialPostParams::PostedLedgerEntry::Direction::TaggedSymbol
+            )
+          DEBIT =
+            T.let(
+              :debit,
+              ModernTreasury::Models::LedgerTransactionCreatePartialPostParams::PostedLedgerEntry::Direction::TaggedSymbol
+            )
 
-          sig { override.returns(T::Array[Symbol]) }
-          def self.values
+          sig do
+            override
+              .returns(
+                T::Array[
+                  ModernTreasury::Models::LedgerTransactionCreatePartialPostParams::PostedLedgerEntry::Direction::TaggedSymbol
+                ]
+              )
           end
+          def self.values; end
         end
       end
     end