modern_treasury 0.1.0.pre.alpha.18 → 0.1.0.pre.alpha.20

data/rbi/modern_treasury/models/internal_account_create_params.rbi

@@ -0,0 +1,369 @@
+# typed: strong
+
+module ModernTreasury
+  module Models
+    class InternalAccountCreateParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            ModernTreasury::InternalAccountCreateParams,
+            ModernTreasury::Internal::AnyHash
+          )
+        end
+
+      # The identifier of the financial institution the account belongs to.
+      sig { returns(String) }
+      attr_accessor :connection_id
+
+      # Either "USD" or "CAD". Internal accounts created at Increase only supports
+      # "USD".
+      sig do
+        returns(ModernTreasury::InternalAccountCreateParams::Currency::OrSymbol)
+      end
+      attr_accessor :currency
+
+      # The nickname of the account.
+      sig { returns(String) }
+      attr_accessor :name
+
+      # The legal name of the entity which owns the account.
+      sig { returns(String) }
+      attr_accessor :party_name
+
+      # The account type, used to provision the appropriate account at the financial
+      # institution.
+      sig do
+        returns(
+          T.nilable(
+            ModernTreasury::InternalAccountCreateParams::AccountType::OrSymbol
+          )
+        )
+      end
+      attr_reader :account_type
+
+      sig do
+        params(
+          account_type:
+            ModernTreasury::InternalAccountCreateParams::AccountType::OrSymbol
+        ).void
+      end
+      attr_writer :account_type
+
+      # The Counterparty associated to this account.
+      sig { returns(T.nilable(String)) }
+      attr_reader :counterparty_id
+
+      sig { params(counterparty_id: String).void }
+      attr_writer :counterparty_id
+
+      # The LegalEntity associated to this account.
+      sig { returns(T.nilable(String)) }
+      attr_reader :legal_entity_id
+
+      sig { params(legal_entity_id: String).void }
+      attr_writer :legal_entity_id
+
+      # The parent internal account of this new account.
+      sig { returns(T.nilable(String)) }
+      attr_reader :parent_account_id
+
+      sig { params(parent_account_id: String).void }
+      attr_writer :parent_account_id
+
+      # The address associated with the owner or null.
+      sig do
+        returns(
+          T.nilable(ModernTreasury::InternalAccountCreateParams::PartyAddress)
+        )
+      end
+      attr_reader :party_address
+
+      sig do
+        params(
+          party_address:
+            ModernTreasury::InternalAccountCreateParams::PartyAddress::OrHash
+        ).void
+      end
+      attr_writer :party_address
+
+      # A hash of vendor specific attributes that will be used when creating the account
+      # at the vendor specified by the given connection.
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :vendor_attributes
+
+      sig { params(vendor_attributes: T::Hash[Symbol, String]).void }
+      attr_writer :vendor_attributes
+
+      sig do
+        params(
+          connection_id: String,
+          currency:
+            ModernTreasury::InternalAccountCreateParams::Currency::OrSymbol,
+          name: String,
+          party_name: String,
+          account_type:
+            ModernTreasury::InternalAccountCreateParams::AccountType::OrSymbol,
+          counterparty_id: String,
+          legal_entity_id: String,
+          parent_account_id: String,
+          party_address:
+            ModernTreasury::InternalAccountCreateParams::PartyAddress::OrHash,
+          vendor_attributes: T::Hash[Symbol, String],
+          request_options: ModernTreasury::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The identifier of the financial institution the account belongs to.
+        connection_id:,
+        # Either "USD" or "CAD". Internal accounts created at Increase only supports
+        # "USD".
+        currency:,
+        # The nickname of the account.
+        name:,
+        # The legal name of the entity which owns the account.
+        party_name:,
+        # The account type, used to provision the appropriate account at the financial
+        # institution.
+        account_type: nil,
+        # The Counterparty associated to this account.
+        counterparty_id: nil,
+        # The LegalEntity associated to this account.
+        legal_entity_id: nil,
+        # The parent internal account of this new account.
+        parent_account_id: nil,
+        # The address associated with the owner or null.
+        party_address: nil,
+        # A hash of vendor specific attributes that will be used when creating the account
+        # at the vendor specified by the given connection.
+        vendor_attributes: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            connection_id: String,
+            currency:
+              ModernTreasury::InternalAccountCreateParams::Currency::OrSymbol,
+            name: String,
+            party_name: String,
+            account_type:
+              ModernTreasury::InternalAccountCreateParams::AccountType::OrSymbol,
+            counterparty_id: String,
+            legal_entity_id: String,
+            parent_account_id: String,
+            party_address:
+              ModernTreasury::InternalAccountCreateParams::PartyAddress,
+            vendor_attributes: T::Hash[Symbol, String],
+            request_options: ModernTreasury::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Either "USD" or "CAD". Internal accounts created at Increase only supports
+      # "USD".
+      module Currency
+        extend ModernTreasury::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, ModernTreasury::InternalAccountCreateParams::Currency)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        USD =
+          T.let(
+            :USD,
+            ModernTreasury::InternalAccountCreateParams::Currency::TaggedSymbol
+          )
+        CAD =
+          T.let(
+            :CAD,
+            ModernTreasury::InternalAccountCreateParams::Currency::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              ModernTreasury::InternalAccountCreateParams::Currency::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # The account type, used to provision the appropriate account at the financial
+      # institution.
+      module AccountType
+        extend ModernTreasury::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(
+              Symbol,
+              ModernTreasury::InternalAccountCreateParams::AccountType
+            )
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        BASE_WALLET =
+          T.let(
+            :base_wallet,
+            ModernTreasury::InternalAccountCreateParams::AccountType::TaggedSymbol
+          )
+        CASH =
+          T.let(
+            :cash,
+            ModernTreasury::InternalAccountCreateParams::AccountType::TaggedSymbol
+          )
+        CHECKING =
+          T.let(
+            :checking,
+            ModernTreasury::InternalAccountCreateParams::AccountType::TaggedSymbol
+          )
+        CRYPTO_WALLET =
+          T.let(
+            :crypto_wallet,
+            ModernTreasury::InternalAccountCreateParams::AccountType::TaggedSymbol
+          )
+        ETHEREUM_WALLET =
+          T.let(
+            :ethereum_wallet,
+            ModernTreasury::InternalAccountCreateParams::AccountType::TaggedSymbol
+          )
+        GENERAL_LEDGER =
+          T.let(
+            :general_ledger,
+            ModernTreasury::InternalAccountCreateParams::AccountType::TaggedSymbol
+          )
+        LOAN =
+          T.let(
+            :loan,
+            ModernTreasury::InternalAccountCreateParams::AccountType::TaggedSymbol
+          )
+        NON_RESIDENT =
+          T.let(
+            :non_resident,
+            ModernTreasury::InternalAccountCreateParams::AccountType::TaggedSymbol
+          )
+        OTHER =
+          T.let(
+            :other,
+            ModernTreasury::InternalAccountCreateParams::AccountType::TaggedSymbol
+          )
+        OVERDRAFT =
+          T.let(
+            :overdraft,
+            ModernTreasury::InternalAccountCreateParams::AccountType::TaggedSymbol
+          )
+        POLYGON_WALLET =
+          T.let(
+            :polygon_wallet,
+            ModernTreasury::InternalAccountCreateParams::AccountType::TaggedSymbol
+          )
+        SAVINGS =
+          T.let(
+            :savings,
+            ModernTreasury::InternalAccountCreateParams::AccountType::TaggedSymbol
+          )
+        SOLANA_WALLET =
+          T.let(
+            :solana_wallet,
+            ModernTreasury::InternalAccountCreateParams::AccountType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              ModernTreasury::InternalAccountCreateParams::AccountType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
+      class PartyAddress < ModernTreasury::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              ModernTreasury::InternalAccountCreateParams::PartyAddress,
+              ModernTreasury::Internal::AnyHash
+            )
+          end
+
+        # Country code conforms to [ISO 3166-1 alpha-2]
+        sig { returns(String) }
+        attr_accessor :country
+
+        sig { returns(String) }
+        attr_accessor :line1
+
+        # Locality or City.
+        sig { returns(String) }
+        attr_accessor :locality
+
+        # The postal code of the address.
+        sig { returns(String) }
+        attr_accessor :postal_code
+
+        # Region or State.
+        sig { returns(String) }
+        attr_accessor :region
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :line2
+
+        sig { params(line2: String).void }
+        attr_writer :line2
+
+        # The address associated with the owner or null.
+        sig do
+          params(
+            country: String,
+            line1: String,
+            locality: String,
+            postal_code: String,
+            region: String,
+            line2: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Country code conforms to [ISO 3166-1 alpha-2]
+          country:,
+          line1:,
+          # Locality or City.
+          locality:,
+          # The postal code of the address.
+          postal_code:,
+          # Region or State.
+          region:,
+          line2: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              country: String,
+              line1: String,
+              locality: String,
+              postal_code: String,
+              region: String,
+              line2: String
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/modern_treasury/models/internal_account_list_params.rbi

@@ -0,0 +1,335 @@
+# typed: strong
+
+module ModernTreasury
+  module Models
+    class InternalAccountListParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            ModernTreasury::InternalAccountListParams,
+            ModernTreasury::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :after_cursor
+
+      # Only return internal accounts associated with this counterparty.
+      sig { returns(T.nilable(String)) }
+      attr_reader :counterparty_id
+
+      sig { params(counterparty_id: String).void }
+      attr_writer :counterparty_id
+
+      # Only return internal accounts with this currency.
+      sig { returns(T.nilable(ModernTreasury::Currency::OrSymbol)) }
+      attr_reader :currency
+
+      sig { params(currency: ModernTreasury::Currency::OrSymbol).void }
+      attr_writer :currency
+
+      # Only return internal accounts associated with this legal entity.
+      sig { returns(T.nilable(String)) }
+      attr_reader :legal_entity_id
+
+      sig { params(legal_entity_id: String).void }
+      attr_writer :legal_entity_id
+
+      # For example, if you want to query for records with metadata key `Type` and value
+      # `Loan`, the query would be `metadata%5BType%5D=Loan`. This encodes the query
+      # parameters.
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :metadata
+
+      sig { params(metadata: T::Hash[Symbol, String]).void }
+      attr_writer :metadata
+
+      # Only return internal accounts that can originate payments with this direction.
+      sig { returns(T.nilable(ModernTreasury::TransactionDirection::OrSymbol)) }
+      attr_reader :payment_direction
+
+      sig do
+        params(
+          payment_direction: ModernTreasury::TransactionDirection::OrSymbol
+        ).void
+      end
+      attr_writer :payment_direction
+
+      # Only return internal accounts that can make this type of payment.
+      sig do
+        returns(
+          T.nilable(
+            ModernTreasury::InternalAccountListParams::PaymentType::OrSymbol
+          )
+        )
+      end
+      attr_reader :payment_type
+
+      sig do
+        params(
+          payment_type:
+            ModernTreasury::InternalAccountListParams::PaymentType::OrSymbol
+        ).void
+      end
+      attr_writer :payment_type
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :per_page
+
+      sig { params(per_page: Integer).void }
+      attr_writer :per_page
+
+      sig do
+        params(
+          after_cursor: T.nilable(String),
+          counterparty_id: String,
+          currency: ModernTreasury::Currency::OrSymbol,
+          legal_entity_id: String,
+          metadata: T::Hash[Symbol, String],
+          payment_direction: ModernTreasury::TransactionDirection::OrSymbol,
+          payment_type:
+            ModernTreasury::InternalAccountListParams::PaymentType::OrSymbol,
+          per_page: Integer,
+          request_options: ModernTreasury::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        after_cursor: nil,
+        # Only return internal accounts associated with this counterparty.
+        counterparty_id: nil,
+        # Only return internal accounts with this currency.
+        currency: nil,
+        # Only return internal accounts associated with this legal entity.
+        legal_entity_id: nil,
+        # For example, if you want to query for records with metadata key `Type` and value
+        # `Loan`, the query would be `metadata%5BType%5D=Loan`. This encodes the query
+        # parameters.
+        metadata: nil,
+        # Only return internal accounts that can originate payments with this direction.
+        payment_direction: nil,
+        # Only return internal accounts that can make this type of payment.
+        payment_type: nil,
+        per_page: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            after_cursor: T.nilable(String),
+            counterparty_id: String,
+            currency: ModernTreasury::Currency::OrSymbol,
+            legal_entity_id: String,
+            metadata: T::Hash[Symbol, String],
+            payment_direction: ModernTreasury::TransactionDirection::OrSymbol,
+            payment_type:
+              ModernTreasury::InternalAccountListParams::PaymentType::OrSymbol,
+            per_page: Integer,
+            request_options: ModernTreasury::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Only return internal accounts that can make this type of payment.
+      module PaymentType
+        extend ModernTreasury::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(
+              Symbol,
+              ModernTreasury::InternalAccountListParams::PaymentType
+            )
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ACH =
+          T.let(
+            :ach,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        AU_BECS =
+          T.let(
+            :au_becs,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        BACS =
+          T.let(
+            :bacs,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        BASE =
+          T.let(
+            :base,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        BOOK =
+          T.let(
+            :book,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        CARD =
+          T.let(
+            :card,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        CHATS =
+          T.let(
+            :chats,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        CHECK =
+          T.let(
+            :check,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        CROSS_BORDER =
+          T.let(
+            :cross_border,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        DK_NETS =
+          T.let(
+            :dk_nets,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        EFT =
+          T.let(
+            :eft,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        ETHEREUM =
+          T.let(
+            :ethereum,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        HU_ICS =
+          T.let(
+            :hu_ics,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        INTERAC =
+          T.let(
+            :interac,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        MASAV =
+          T.let(
+            :masav,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        MX_CCEN =
+          T.let(
+            :mx_ccen,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        NEFT =
+          T.let(
+            :neft,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        NICS =
+          T.let(
+            :nics,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        NZ_BECS =
+          T.let(
+            :nz_becs,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        PL_ELIXIR =
+          T.let(
+            :pl_elixir,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        POLYGON =
+          T.let(
+            :polygon,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        PROVXCHANGE =
+          T.let(
+            :provxchange,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        RO_SENT =
+          T.let(
+            :ro_sent,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        RTP =
+          T.let(
+            :rtp,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        SE_BANKGIROT =
+          T.let(
+            :se_bankgirot,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        SEN =
+          T.let(
+            :sen,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        SEPA =
+          T.let(
+            :sepa,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        SG_GIRO =
+          T.let(
+            :sg_giro,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        SIC =
+          T.let(
+            :sic,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        SIGNET =
+          T.let(
+            :signet,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        SKNBI =
+          T.let(
+            :sknbi,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        SOLANA =
+          T.let(
+            :solana,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        WIRE =
+          T.let(
+            :wire,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+        ZENGIN =
+          T.let(
+            :zengin,
+            ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              ModernTreasury::InternalAccountListParams::PaymentType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end