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

data/rbi/lib/modern_treasury/models/external_account.rbi

@@ -2,177 +2,90 @@
 
 module ModernTreasury
   module Models
-    class ExternalAccount < ModernTreasury::BaseModel
+    class ExternalAccount < ModernTreasury::Internal::Type::BaseModel
       sig { returns(String) }
-      def id
-      end
-
-      sig { params(_: String).returns(String) }
-      def id=(_)
-      end
+      attr_accessor :id
 
       sig { returns(T::Array[ModernTreasury::Models::AccountDetail]) }
-      def account_details
-      end
-
-      sig do
-        params(_: T::Array[ModernTreasury::Models::AccountDetail])
-          .returns(T::Array[ModernTreasury::Models::AccountDetail])
-      end
-      def account_details=(_)
-      end
-
-      sig { returns(Symbol) }
-      def account_type
-      end
+      attr_accessor :account_details
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def account_type=(_)
-      end
+      # Can be `checking`, `savings` or `other`.
+      sig { returns(ModernTreasury::Models::ExternalAccountType::TaggedSymbol) }
+      attr_accessor :account_type
 
       sig { returns(T::Array[ModernTreasury::Models::ExternalAccount::ContactDetail]) }
-      def contact_details
-      end
-
-      sig do
-        params(_: T::Array[ModernTreasury::Models::ExternalAccount::ContactDetail])
-          .returns(T::Array[ModernTreasury::Models::ExternalAccount::ContactDetail])
-      end
-      def contact_details=(_)
-      end
+      attr_accessor :contact_details
 
       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
+      attr_accessor :created_at
 
       sig { returns(T.nilable(Time)) }
-      def discarded_at
-      end
-
-      sig { params(_: T.nilable(Time)).returns(T.nilable(Time)) }
-      def discarded_at=(_)
-      end
+      attr_accessor :discarded_at
 
+      # If the external account links to a ledger account in Modern Treasury, the id of
+      # the ledger account will be populated here.
       sig { returns(T.nilable(String)) }
-      def ledger_account_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def ledger_account_id=(_)
-      end
+      attr_accessor :ledger_account_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
 
+      # A nickname for the external account. This is only for internal usage and won't
+      # affect any payments
       sig { returns(T.nilable(String)) }
-      def name
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def name=(_)
-      end
+      attr_accessor :name
 
       sig { returns(String) }
-      def object
-      end
-
-      sig { params(_: String).returns(String) }
-      def object=(_)
-      end
+      attr_accessor :object
 
+      # The address associated with the owner or `null`.
       sig { returns(T.nilable(ModernTreasury::Models::ExternalAccount::PartyAddress)) }
-      def party_address
-      end
+      attr_reader :party_address
 
       sig do
-        params(_: T.nilable(ModernTreasury::Models::ExternalAccount::PartyAddress))
-          .returns(T.nilable(ModernTreasury::Models::ExternalAccount::PartyAddress))
-      end
-      def party_address=(_)
+        params(
+          party_address: T.nilable(T.any(ModernTreasury::Models::ExternalAccount::PartyAddress, ModernTreasury::Internal::AnyHash))
+        )
+          .void
       end
+      attr_writer :party_address
 
+      # The legal name of the entity which owns the account.
       sig { returns(String) }
-      def party_name
-      end
+      attr_accessor :party_name
 
-      sig { params(_: String).returns(String) }
-      def party_name=(_)
-      end
-
-      sig { returns(T.nilable(Symbol)) }
-      def party_type
-      end
-
-      sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-      def party_type=(_)
-      end
+      # Either `individual` or `business`.
+      sig { returns(T.nilable(ModernTreasury::Models::ExternalAccount::PartyType::TaggedSymbol)) }
+      attr_accessor :party_type
 
       sig { returns(T::Array[ModernTreasury::Models::RoutingDetail]) }
-      def routing_details
-      end
-
-      sig do
-        params(_: T::Array[ModernTreasury::Models::RoutingDetail])
-          .returns(T::Array[ModernTreasury::Models::RoutingDetail])
-      end
-      def routing_details=(_)
-      end
+      attr_accessor :routing_details
 
       sig { returns(Time) }
-      def updated_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def updated_at=(_)
-      end
-
-      sig { returns(T.nilable(Symbol)) }
-      def verification_source
-      end
-
-      sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-      def verification_source=(_)
-      end
+      attr_accessor :updated_at
 
-      sig { returns(Symbol) }
-      def verification_status
-      end
+      sig { returns(T.nilable(ModernTreasury::Models::ExternalAccount::VerificationSource::TaggedSymbol)) }
+      attr_accessor :verification_source
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def verification_status=(_)
-      end
+      sig { returns(ModernTreasury::Models::ExternalAccount::VerificationStatus::TaggedSymbol) }
+      attr_accessor :verification_status
 
       sig do
         params(
           id: String,
-          account_details: T::Array[ModernTreasury::Models::AccountDetail],
-          account_type: Symbol,
-          contact_details: T::Array[ModernTreasury::Models::ExternalAccount::ContactDetail],
+          account_details: T::Array[T.any(ModernTreasury::Models::AccountDetail, ModernTreasury::Internal::AnyHash)],
+          account_type: ModernTreasury::Models::ExternalAccountType::OrSymbol,
+          contact_details: T::Array[T.any(ModernTreasury::Models::ExternalAccount::ContactDetail, ModernTreasury::Internal::AnyHash)],
           counterparty_id: T.nilable(String),
           created_at: Time,
           discarded_at: T.nilable(Time),
@@ -181,17 +94,17 @@ module ModernTreasury
           metadata: T::Hash[Symbol, String],
           name: T.nilable(String),
           object: String,
-          party_address: T.nilable(ModernTreasury::Models::ExternalAccount::PartyAddress),
+          party_address: T.nilable(T.any(ModernTreasury::Models::ExternalAccount::PartyAddress, ModernTreasury::Internal::AnyHash)),
           party_name: String,
-          party_type: T.nilable(Symbol),
-          routing_details: T::Array[ModernTreasury::Models::RoutingDetail],
+          party_type: T.nilable(ModernTreasury::Models::ExternalAccount::PartyType::OrSymbol),
+          routing_details: T::Array[T.any(ModernTreasury::Models::RoutingDetail, ModernTreasury::Internal::AnyHash)],
           updated_at: Time,
-          verification_source: T.nilable(Symbol),
-          verification_status: Symbol
+          verification_source: T.nilable(ModernTreasury::Models::ExternalAccount::VerificationSource::OrSymbol),
+          verification_status: ModernTreasury::Models::ExternalAccount::VerificationStatus::OrSymbol
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         id:,
         account_details:,
         account_type:,
@@ -211,16 +124,14 @@ module ModernTreasury
         updated_at:,
         verification_source:,
         verification_status:
-      )
-      end
-
+      ); end
       sig do
         override
           .returns(
             {
               id: String,
               account_details: T::Array[ModernTreasury::Models::AccountDetail],
-              account_type: Symbol,
+              account_type: ModernTreasury::Models::ExternalAccountType::TaggedSymbol,
               contact_details: T::Array[ModernTreasury::Models::ExternalAccount::ContactDetail],
               counterparty_id: T.nilable(String),
               created_at: Time,
@@ -232,96 +143,57 @@ module ModernTreasury
               object: String,
               party_address: T.nilable(ModernTreasury::Models::ExternalAccount::PartyAddress),
               party_name: String,
-              party_type: T.nilable(Symbol),
+              party_type: T.nilable(ModernTreasury::Models::ExternalAccount::PartyType::TaggedSymbol),
               routing_details: T::Array[ModernTreasury::Models::RoutingDetail],
               updated_at: Time,
-              verification_source: T.nilable(Symbol),
-              verification_status: Symbol
+              verification_source: T.nilable(ModernTreasury::Models::ExternalAccount::VerificationSource::TaggedSymbol),
+              verification_status: ModernTreasury::Models::ExternalAccount::VerificationStatus::TaggedSymbol
             }
           )
       end
-      def to_hash
-      end
+      def to_hash; end
 
-      class ContactDetail < ModernTreasury::BaseModel
+      class ContactDetail < ModernTreasury::Internal::Type::BaseModel
         sig { returns(String) }
-        def id
-        end
-
-        sig { params(_: String).returns(String) }
-        def id=(_)
-        end
+        attr_accessor :id
 
         sig { returns(String) }
-        def contact_identifier
-        end
+        attr_accessor :contact_identifier
 
-        sig { params(_: String).returns(String) }
-        def contact_identifier=(_)
-        end
-
-        sig { returns(Symbol) }
-        def contact_identifier_type
-        end
-
-        sig { params(_: Symbol).returns(Symbol) }
-        def contact_identifier_type=(_)
-        end
+        sig { returns(ModernTreasury::Models::ExternalAccount::ContactDetail::ContactIdentifierType::TaggedSymbol) }
+        attr_accessor :contact_identifier_type
 
         sig { returns(Time) }
-        def created_at
-        end
-
-        sig { params(_: Time).returns(Time) }
-        def created_at=(_)
-        end
+        attr_accessor :created_at
 
         sig { returns(T.nilable(Time)) }
-        def discarded_at
-        end
-
-        sig { params(_: T.nilable(Time)).returns(T.nilable(Time)) }
-        def discarded_at=(_)
-        end
+        attr_accessor :discarded_at
 
+        # 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
 
         sig { returns(Time) }
-        def updated_at
-        end
-
-        sig { params(_: Time).returns(Time) }
-        def updated_at=(_)
-        end
+        attr_accessor :updated_at
 
         sig do
           params(
             id: String,
             contact_identifier: String,
-            contact_identifier_type: Symbol,
+            contact_identifier_type: ModernTreasury::Models::ExternalAccount::ContactDetail::ContactIdentifierType::OrSymbol,
             created_at: Time,
             discarded_at: T.nilable(Time),
             live_mode: T::Boolean,
             object: String,
             updated_at: Time
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(
+        def self.new(
           id:,
           contact_identifier:,
           contact_identifier_type:,
@@ -330,16 +202,14 @@ module ModernTreasury
           live_mode:,
           object:,
           updated_at:
-        )
-        end
-
+        ); end
         sig do
           override
             .returns(
               {
                 id: String,
                 contact_identifier: String,
-                contact_identifier_type: Symbol,
+                contact_identifier_type: ModernTreasury::Models::ExternalAccount::ContactDetail::ContactIdentifierType::TaggedSymbol,
                 created_at: Time,
                 discarded_at: T.nilable(Time),
                 live_mode: T::Boolean,
@@ -348,111 +218,86 @@ module ModernTreasury
               }
             )
         end
-        def to_hash
-        end
-
-        class ContactIdentifierType < ModernTreasury::Enum
-          abstract!
-
-          EMAIL = :email
-          PHONE_NUMBER = :phone_number
-          WEBSITE = :website
+        def to_hash; end
+
+        module ContactIdentifierType
+          extend ModernTreasury::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, ModernTreasury::Models::ExternalAccount::ContactDetail::ContactIdentifierType) }
+          OrSymbol =
+            T.type_alias do
+              T.any(
+                Symbol,
+                String,
+                ModernTreasury::Models::ExternalAccount::ContactDetail::ContactIdentifierType::TaggedSymbol
+              )
+            end
+
+          EMAIL =
+            T.let(:email, ModernTreasury::Models::ExternalAccount::ContactDetail::ContactIdentifierType::TaggedSymbol)
+          PHONE_NUMBER =
+            T.let(
+              :phone_number,
+              ModernTreasury::Models::ExternalAccount::ContactDetail::ContactIdentifierType::TaggedSymbol
+            )
+          WEBSITE =
+            T.let(
+              :website,
+              ModernTreasury::Models::ExternalAccount::ContactDetail::ContactIdentifierType::TaggedSymbol
+            )
 
-          sig { override.returns(T::Array[Symbol]) }
-          def self.values
+          sig do
+            override
+              .returns(
+                T::Array[ModernTreasury::Models::ExternalAccount::ContactDetail::ContactIdentifierType::TaggedSymbol]
+              )
           end
+          def self.values; end
         end
       end
 
-      class PartyAddress < ModernTreasury::BaseModel
+      class PartyAddress < ModernTreasury::Internal::Type::BaseModel
         sig { returns(String) }
-        def id
-        end
-
-        sig { params(_: String).returns(String) }
-        def id=(_)
-        end
+        attr_accessor :id
 
+        # Country code conforms to [ISO 3166-1 alpha-2]
         sig { returns(T.nilable(String)) }
-        def country
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def country=(_)
-        end
+        attr_accessor :country
 
         sig { returns(Time) }
-        def created_at
-        end
-
-        sig { params(_: Time).returns(Time) }
-        def created_at=(_)
-        end
+        attr_accessor :created_at
 
         sig { returns(T.nilable(String)) }
-        def line1
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def line1=(_)
-        end
+        attr_accessor :line1
 
         sig { returns(T.nilable(String)) }
-        def line2
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def line2=(_)
-        end
+        attr_accessor :line2
 
+        # 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
 
+        # Locality or City.
         sig { returns(T.nilable(String)) }
-        def locality
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def locality=(_)
-        end
+        attr_accessor :locality
 
         sig { returns(String) }
-        def object
-        end
-
-        sig { params(_: String).returns(String) }
-        def object=(_)
-        end
+        attr_accessor :object
 
+        # The postal code of the address.
         sig { returns(T.nilable(String)) }
-        def postal_code
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def postal_code=(_)
-        end
+        attr_accessor :postal_code
 
+        # Region or State.
         sig { returns(T.nilable(String)) }
-        def region
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def region=(_)
-        end
+        attr_accessor :region
 
         sig { returns(Time) }
-        def updated_at
-        end
-
-        sig { params(_: Time).returns(Time) }
-        def updated_at=(_)
-        end
+        attr_accessor :updated_at
 
+        # The address associated with the owner or `null`.
         sig do
           params(
             id: String,
@@ -467,9 +312,9 @@ module ModernTreasury
             region: T.nilable(String),
             updated_at: Time
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(
+        def self.new(
           id:,
           country:,
           created_at:,
@@ -481,9 +326,7 @@ module ModernTreasury
           postal_code:,
           region:,
           updated_at:
-        )
-        end
-
+        ); end
         sig do
           override
             .returns(
@@ -502,43 +345,58 @@ module ModernTreasury
               }
             )
         end
-        def to_hash
-        end
+        def to_hash; end
       end
 
-      class PartyType < ModernTreasury::Enum
-        abstract!
+      # Either `individual` or `business`.
+      module PartyType
+        extend ModernTreasury::Internal::Type::Enum
 
-        BUSINESS = T.let(:business, T.nilable(Symbol))
-        INDIVIDUAL = T.let(:individual, T.nilable(Symbol))
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::ExternalAccount::PartyType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, ModernTreasury::Models::ExternalAccount::PartyType::TaggedSymbol) }
 
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
-        end
+        BUSINESS = T.let(:business, ModernTreasury::Models::ExternalAccount::PartyType::TaggedSymbol)
+        INDIVIDUAL = T.let(:individual, ModernTreasury::Models::ExternalAccount::PartyType::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::ExternalAccount::PartyType::TaggedSymbol]) }
+        def self.values; end
       end
 
-      class VerificationSource < ModernTreasury::Enum
-        abstract!
+      module VerificationSource
+        extend ModernTreasury::Internal::Type::Enum
 
-        ACH_PRENOTE = T.let(:ach_prenote, T.nilable(Symbol))
-        MICRODEPOSITS = T.let(:microdeposits, T.nilable(Symbol))
-        PLAID = T.let(:plaid, T.nilable(Symbol))
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::ExternalAccount::VerificationSource) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, ModernTreasury::Models::ExternalAccount::VerificationSource::TaggedSymbol) }
 
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
-        end
+        ACH_PRENOTE =
+          T.let(:ach_prenote, ModernTreasury::Models::ExternalAccount::VerificationSource::TaggedSymbol)
+        MICRODEPOSITS =
+          T.let(:microdeposits, ModernTreasury::Models::ExternalAccount::VerificationSource::TaggedSymbol)
+        PLAID = T.let(:plaid, ModernTreasury::Models::ExternalAccount::VerificationSource::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::ExternalAccount::VerificationSource::TaggedSymbol]) }
+        def self.values; end
       end
 
-      class VerificationStatus < ModernTreasury::Enum
-        abstract!
+      module VerificationStatus
+        extend ModernTreasury::Internal::Type::Enum
 
-        PENDING_VERIFICATION = :pending_verification
-        UNVERIFIED = :unverified
-        VERIFIED = :verified
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::ExternalAccount::VerificationStatus) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, ModernTreasury::Models::ExternalAccount::VerificationStatus::TaggedSymbol) }
 
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
-        end
+        PENDING_VERIFICATION =
+          T.let(:pending_verification, ModernTreasury::Models::ExternalAccount::VerificationStatus::TaggedSymbol)
+        UNVERIFIED =
+          T.let(:unverified, ModernTreasury::Models::ExternalAccount::VerificationStatus::TaggedSymbol)
+        VERIFIED = T.let(:verified, ModernTreasury::Models::ExternalAccount::VerificationStatus::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::ExternalAccount::VerificationStatus::TaggedSymbol]) }
+        def self.values; end
       end
     end
   end