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

data/rbi/lib/modern_treasury/models/ledger_transaction_update_params.rbi

@@ -2,83 +2,94 @@
 
 module ModernTreasury
   module Models
-    class LedgerTransactionUpdateParams < ModernTreasury::BaseModel
-      extend ModernTreasury::RequestParameters::Converter
-      include ModernTreasury::RequestParameters
+    class LedgerTransactionUpdateParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::RequestParameters
 
+      # 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
 
+      # An array of ledger entry objects.
       sig { returns(T.nilable(T::Array[ModernTreasury::Models::LedgerTransactionUpdateParams::LedgerEntry])) }
-      def ledger_entries
-      end
+      attr_reader :ledger_entries
 
       sig do
-        params(_: T::Array[ModernTreasury::Models::LedgerTransactionUpdateParams::LedgerEntry])
-          .returns(T::Array[ModernTreasury::Models::LedgerTransactionUpdateParams::LedgerEntry])
-      end
-      def ledger_entries=(_)
+        params(
+          ledger_entries: T::Array[
+            T.any(
+              ModernTreasury::Models::LedgerTransactionUpdateParams::LedgerEntry,
+              ModernTreasury::Internal::AnyHash
+            )
+          ]
+        )
+          .void
       end
+      attr_writer :ledger_entries
 
+      # 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::LedgerTransactionUpdateParams::LedgerableType::OrSymbol)) }
+      attr_reader :ledgerable_type
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def ledgerable_type=(_)
+      sig do
+        params(ledgerable_type: ModernTreasury::Models::LedgerTransactionUpdateParams::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::LedgerTransactionUpdateParams::Status::OrSymbol)) }
+      attr_reader :status
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def status=(_)
-      end
+      sig { params(status: ModernTreasury::Models::LedgerTransactionUpdateParams::Status::OrSymbol).void }
+      attr_writer :status
 
       sig do
         params(
           description: T.nilable(String),
           effective_at: Time,
-          ledger_entries: T::Array[ModernTreasury::Models::LedgerTransactionUpdateParams::LedgerEntry],
+          ledger_entries: T::Array[
+            T.any(
+              ModernTreasury::Models::LedgerTransactionUpdateParams::LedgerEntry,
+              ModernTreasury::Internal::AnyHash
+            )
+          ],
           ledgerable_id: String,
-          ledgerable_type: Symbol,
+          ledgerable_type: ModernTreasury::Models::LedgerTransactionUpdateParams::LedgerableType::OrSymbol,
           metadata: T::Hash[Symbol, String],
-          status: Symbol,
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          status: ModernTreasury::Models::LedgerTransactionUpdateParams::Status::OrSymbol,
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         description: nil,
         effective_at: nil,
         ledger_entries: nil,
@@ -87,9 +98,7 @@ module ModernTreasury
         metadata: nil,
         status: nil,
         request_options: {}
-      )
-      end
-
+      ); end
       sig do
         override
           .returns(
@@ -98,93 +107,74 @@ module ModernTreasury
               effective_at: Time,
               ledger_entries: T::Array[ModernTreasury::Models::LedgerTransactionUpdateParams::LedgerEntry],
               ledgerable_id: String,
-              ledgerable_type: Symbol,
+              ledgerable_type: ModernTreasury::Models::LedgerTransactionUpdateParams::LedgerableType::OrSymbol,
               metadata: T::Hash[Symbol, String],
-              status: Symbol,
+              status: ModernTreasury::Models::LedgerTransactionUpdateParams::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
-
-        sig { params(_: Integer).returns(Integer) }
-        def amount=(_)
-        end
+        attr_accessor :amount
 
-        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),
@@ -193,9 +183,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:,
@@ -205,15 +195,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),
@@ -224,35 +212,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::LedgerTransactionUpdateParams::LedgerableType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, ModernTreasury::Models::LedgerTransactionUpdateParams::LedgerableType::TaggedSymbol) }
+
+        EXPECTED_PAYMENT =
+          T.let(
+            :expected_payment,
+            ModernTreasury::Models::LedgerTransactionUpdateParams::LedgerableType::TaggedSymbol
+          )
+        INCOMING_PAYMENT_DETAIL =
+          T.let(
+            :incoming_payment_detail,
+            ModernTreasury::Models::LedgerTransactionUpdateParams::LedgerableType::TaggedSymbol
+          )
+        PAPER_ITEM =
+          T.let(:paper_item, ModernTreasury::Models::LedgerTransactionUpdateParams::LedgerableType::TaggedSymbol)
+        PAYMENT_ORDER =
+          T.let(:payment_order, ModernTreasury::Models::LedgerTransactionUpdateParams::LedgerableType::TaggedSymbol)
+        RETURN =
+          T.let(:return, ModernTreasury::Models::LedgerTransactionUpdateParams::LedgerableType::TaggedSymbol)
+        REVERSAL =
+          T.let(:reversal, ModernTreasury::Models::LedgerTransactionUpdateParams::LedgerableType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
+        sig do
+          override
+            .returns(T::Array[ModernTreasury::Models::LedgerTransactionUpdateParams::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::LedgerTransactionUpdateParams::Status) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, ModernTreasury::Models::LedgerTransactionUpdateParams::Status::TaggedSymbol) }
 
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
-        end
+        ARCHIVED = T.let(:archived, ModernTreasury::Models::LedgerTransactionUpdateParams::Status::TaggedSymbol)
+        PENDING = T.let(:pending, ModernTreasury::Models::LedgerTransactionUpdateParams::Status::TaggedSymbol)
+        POSTED = T.let(:posted, ModernTreasury::Models::LedgerTransactionUpdateParams::Status::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::LedgerTransactionUpdateParams::Status::TaggedSymbol]) }
+        def self.values; end
       end
     end
   end