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

data/rbi/lib/modern_treasury/models/internal_account.rbi

@@ -4,175 +4,100 @@ module ModernTreasury
   module Models
     class InternalAccount < ModernTreasury::BaseModel
       sig { returns(String) }
-      def id
-      end
-
-      sig { params(_: String).returns(String) }
-      def id=(_)
-      end
+      attr_accessor :id
 
+      # An array of account detail objects.
       sig { returns(T::Array[ModernTreasury::Models::AccountDetail]) }
-      def account_details
-      end
+      attr_accessor :account_details
 
-      sig do
-        params(_: T::Array[ModernTreasury::Models::AccountDetail])
-          .returns(T::Array[ModernTreasury::Models::AccountDetail])
-      end
-      def account_details=(_)
-      end
-
-      sig { returns(T.nilable(Symbol)) }
-      def account_type
-      end
-
-      sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-      def account_type=(_)
-      end
+      # Can be checking, savings or other.
+      sig { returns(T.nilable(ModernTreasury::Models::InternalAccount::AccountType::TaggedSymbol)) }
+      attr_accessor :account_type
 
+      # Specifies which financial institution the accounts belong to.
       sig { returns(ModernTreasury::Models::Connection) }
-      def connection
-      end
+      attr_reader :connection
 
-      sig { params(_: ModernTreasury::Models::Connection).returns(ModernTreasury::Models::Connection) }
-      def connection=(_)
-      end
+      sig { params(connection: T.any(ModernTreasury::Models::Connection, ModernTreasury::Util::AnyHash)).void }
+      attr_writer :connection
 
+      # The Counterparty associated to this account.
       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(Symbol) }
-      def currency
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def currency=(_)
-      end
+      # The currency of the account.
+      sig { returns(ModernTreasury::Models::Currency::TaggedSymbol) }
+      attr_accessor :currency
 
+      # If the internal 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
 
+      # The Legal Entity associated to this account
       sig { returns(T.nilable(String)) }
-      def legal_entity_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def legal_entity_id=(_)
-      end
+      attr_accessor :legal_entity_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 account.
       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 parent InternalAccount of this account.
       sig { returns(T.nilable(String)) }
-      def parent_account_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def parent_account_id=(_)
-      end
+      attr_accessor :parent_account_id
 
+      # The address associated with the owner or null.
       sig { returns(T.nilable(ModernTreasury::Models::InternalAccount::PartyAddress)) }
-      def party_address
-      end
+      attr_reader :party_address
 
       sig do
-        params(_: T.nilable(ModernTreasury::Models::InternalAccount::PartyAddress))
-          .returns(T.nilable(ModernTreasury::Models::InternalAccount::PartyAddress))
-      end
-      def party_address=(_)
+        params(
+          party_address: T.nilable(T.any(ModernTreasury::Models::InternalAccount::PartyAddress, ModernTreasury::Util::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::InternalAccount::PartyType::TaggedSymbol)) }
+      attr_accessor :party_type
 
+      # An array of routing detail objects.
       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
+      attr_accessor :updated_at
 
       sig do
         params(
           id: String,
-          account_details: T::Array[ModernTreasury::Models::AccountDetail],
-          account_type: T.nilable(Symbol),
-          connection: ModernTreasury::Models::Connection,
+          account_details: T::Array[T.any(ModernTreasury::Models::AccountDetail, ModernTreasury::Util::AnyHash)],
+          account_type: T.nilable(ModernTreasury::Models::InternalAccount::AccountType::OrSymbol),
+          connection: T.any(ModernTreasury::Models::Connection, ModernTreasury::Util::AnyHash),
           counterparty_id: T.nilable(String),
           created_at: Time,
-          currency: Symbol,
+          currency: ModernTreasury::Models::Currency::OrSymbol,
           ledger_account_id: T.nilable(String),
           legal_entity_id: T.nilable(String),
           live_mode: T::Boolean,
@@ -180,15 +105,15 @@ module ModernTreasury
           name: T.nilable(String),
           object: String,
           parent_account_id: T.nilable(String),
-          party_address: T.nilable(ModernTreasury::Models::InternalAccount::PartyAddress),
+          party_address: T.nilable(T.any(ModernTreasury::Models::InternalAccount::PartyAddress, ModernTreasury::Util::AnyHash)),
           party_name: String,
-          party_type: T.nilable(Symbol),
-          routing_details: T::Array[ModernTreasury::Models::RoutingDetail],
+          party_type: T.nilable(ModernTreasury::Models::InternalAccount::PartyType::OrSymbol),
+          routing_details: T::Array[T.any(ModernTreasury::Models::RoutingDetail, ModernTreasury::Util::AnyHash)],
           updated_at: Time
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         id:,
         account_details:,
         account_type:,
@@ -217,11 +142,11 @@ module ModernTreasury
             {
               id: String,
               account_details: T::Array[ModernTreasury::Models::AccountDetail],
-              account_type: T.nilable(Symbol),
+              account_type: T.nilable(ModernTreasury::Models::InternalAccount::AccountType::TaggedSymbol),
               connection: ModernTreasury::Models::Connection,
               counterparty_id: T.nilable(String),
               created_at: Time,
-              currency: Symbol,
+              currency: ModernTreasury::Models::Currency::TaggedSymbol,
               ledger_account_id: T.nilable(String),
               legal_entity_id: T.nilable(String),
               live_mode: T::Boolean,
@@ -231,7 +156,7 @@ module ModernTreasury
               parent_account_id: T.nilable(String),
               party_address: T.nilable(ModernTreasury::Models::InternalAccount::PartyAddress),
               party_name: String,
-              party_type: T.nilable(Symbol),
+              party_type: T.nilable(ModernTreasury::Models::InternalAccount::PartyType::TaggedSymbol),
               routing_details: T::Array[ModernTreasury::Models::RoutingDetail],
               updated_at: Time
             }
@@ -240,112 +165,70 @@ module ModernTreasury
       def to_hash
       end
 
-      class AccountType < ModernTreasury::Enum
-        abstract!
+      # Can be checking, savings or other.
+      module AccountType
+        extend ModernTreasury::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::InternalAccount::AccountType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::InternalAccount::AccountType::TaggedSymbol) }
 
-        CASH = T.let(:cash, T.nilable(Symbol))
-        CHECKING = T.let(:checking, T.nilable(Symbol))
-        GENERAL_LEDGER = T.let(:general_ledger, T.nilable(Symbol))
-        LOAN = T.let(:loan, T.nilable(Symbol))
-        NON_RESIDENT = T.let(:non_resident, T.nilable(Symbol))
-        OTHER = T.let(:other, T.nilable(Symbol))
-        OVERDRAFT = T.let(:overdraft, T.nilable(Symbol))
-        SAVINGS = T.let(:savings, T.nilable(Symbol))
+        CASH = T.let(:cash, ModernTreasury::Models::InternalAccount::AccountType::TaggedSymbol)
+        CHECKING = T.let(:checking, ModernTreasury::Models::InternalAccount::AccountType::TaggedSymbol)
+        GENERAL_LEDGER =
+          T.let(:general_ledger, ModernTreasury::Models::InternalAccount::AccountType::TaggedSymbol)
+        LOAN = T.let(:loan, ModernTreasury::Models::InternalAccount::AccountType::TaggedSymbol)
+        NON_RESIDENT = T.let(:non_resident, ModernTreasury::Models::InternalAccount::AccountType::TaggedSymbol)
+        OTHER = T.let(:other, ModernTreasury::Models::InternalAccount::AccountType::TaggedSymbol)
+        OVERDRAFT = T.let(:overdraft, ModernTreasury::Models::InternalAccount::AccountType::TaggedSymbol)
+        SAVINGS = T.let(:savings, ModernTreasury::Models::InternalAccount::AccountType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[ModernTreasury::Models::InternalAccount::AccountType::TaggedSymbol]) }
         def self.values
         end
       end
 
       class PartyAddress < ModernTreasury::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,
@@ -360,9 +243,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:,
@@ -399,13 +282,18 @@ module ModernTreasury
         end
       end
 
-      class PartyType < ModernTreasury::Enum
-        abstract!
+      # Either individual or business.
+      module PartyType
+        extend ModernTreasury::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::InternalAccount::PartyType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::InternalAccount::PartyType::TaggedSymbol) }
 
-        BUSINESS = T.let(:business, T.nilable(Symbol))
-        INDIVIDUAL = T.let(:individual, T.nilable(Symbol))
+        BUSINESS = T.let(:business, ModernTreasury::Models::InternalAccount::PartyType::TaggedSymbol)
+        INDIVIDUAL = T.let(:individual, ModernTreasury::Models::InternalAccount::PartyType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[ModernTreasury::Models::InternalAccount::PartyType::TaggedSymbol]) }
         def self.values
         end
       end