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

data/rbi/lib/modern_treasury/models/internal_account_create_params.rbi

@@ -6,97 +6,80 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
+      # The identifier of the financial institution the account belongs to.
       sig { returns(String) }
-      def connection_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def connection_id=(_)
-      end
+      attr_accessor :connection_id
 
-      sig { returns(Symbol) }
-      def currency
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def currency=(_)
-      end
+      # Either "USD" or "CAD". Internal accounts created at Increase only supports
+      #   "USD".
+      sig { returns(ModernTreasury::Models::InternalAccountCreateParams::Currency::OrSymbol) }
+      attr_accessor :currency
 
+      # The nickname of the account.
       sig { returns(String) }
-      def name
-      end
-
-      sig { params(_: String).returns(String) }
-      def name=(_)
-      end
+      attr_accessor :name
 
+      # The legal name of the entity which owns the account.
       sig { returns(String) }
-      def party_name
-      end
-
-      sig { params(_: String).returns(String) }
-      def party_name=(_)
-      end
+      attr_accessor :party_name
 
+      # The Counterparty associated to this account.
       sig { returns(T.nilable(String)) }
-      def counterparty_id
-      end
+      attr_reader :counterparty_id
 
-      sig { params(_: String).returns(String) }
-      def counterparty_id=(_)
-      end
+      sig { params(counterparty_id: String).void }
+      attr_writer :counterparty_id
 
+      # The LegalEntity associated to this account.
       sig { returns(T.nilable(String)) }
-      def legal_entity_id
-      end
+      attr_reader :legal_entity_id
 
-      sig { params(_: String).returns(String) }
-      def legal_entity_id=(_)
-      end
+      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)) }
-      def parent_account_id
-      end
+      attr_reader :parent_account_id
 
-      sig { params(_: String).returns(String) }
-      def parent_account_id=(_)
-      end
+      sig { params(parent_account_id: String).void }
+      attr_writer :parent_account_id
 
+      # The address associated with the owner or null.
       sig { returns(T.nilable(ModernTreasury::Models::InternalAccountCreateParams::PartyAddress)) }
-      def party_address
-      end
+      attr_reader :party_address
 
       sig do
-        params(_: ModernTreasury::Models::InternalAccountCreateParams::PartyAddress)
-          .returns(ModernTreasury::Models::InternalAccountCreateParams::PartyAddress)
-      end
-      def party_address=(_)
+        params(
+          party_address: T.any(ModernTreasury::Models::InternalAccountCreateParams::PartyAddress, ModernTreasury::Util::AnyHash)
+        )
+          .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])) }
-      def vendor_attributes
-      end
+      attr_reader :vendor_attributes
 
-      sig { params(_: T::Hash[Symbol, String]).returns(T::Hash[Symbol, String]) }
-      def vendor_attributes=(_)
-      end
+      sig { params(vendor_attributes: T::Hash[Symbol, String]).void }
+      attr_writer :vendor_attributes
 
       sig do
         params(
           connection_id: String,
-          currency: Symbol,
+          currency: ModernTreasury::Models::InternalAccountCreateParams::Currency::OrSymbol,
           name: String,
           party_name: String,
           counterparty_id: String,
           legal_entity_id: String,
           parent_account_id: String,
-          party_address: ModernTreasury::Models::InternalAccountCreateParams::PartyAddress,
+          party_address: T.any(ModernTreasury::Models::InternalAccountCreateParams::PartyAddress, ModernTreasury::Util::AnyHash),
           vendor_attributes: T::Hash[Symbol, String],
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         connection_id:,
         currency:,
         name:,
@@ -115,7 +98,7 @@ module ModernTreasury
           .returns(
             {
               connection_id: String,
-              currency: Symbol,
+              currency: ModernTreasury::Models::InternalAccountCreateParams::Currency::OrSymbol,
               name: String,
               party_name: String,
               counterparty_id: String,
@@ -130,66 +113,51 @@ module ModernTreasury
       def to_hash
       end
 
-      class Currency < ModernTreasury::Enum
-        abstract!
+      # Either "USD" or "CAD". Internal accounts created at Increase only supports
+      #   "USD".
+      module Currency
+        extend ModernTreasury::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::InternalAccountCreateParams::Currency) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::InternalAccountCreateParams::Currency::TaggedSymbol) }
 
-        USD = :USD
-        CAD = :CAD
+        USD = T.let(:USD, ModernTreasury::Models::InternalAccountCreateParams::Currency::TaggedSymbol)
+        CAD = T.let(:CAD, ModernTreasury::Models::InternalAccountCreateParams::Currency::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[ModernTreasury::Models::InternalAccountCreateParams::Currency::TaggedSymbol]) }
         def self.values
         end
       end
 
       class PartyAddress < ModernTreasury::BaseModel
+        # Country code conforms to [ISO 3166-1 alpha-2]
         sig { returns(String) }
-        def country
-        end
-
-        sig { params(_: String).returns(String) }
-        def country=(_)
-        end
+        attr_accessor :country
 
         sig { returns(String) }
-        def line1
-        end
-
-        sig { params(_: String).returns(String) }
-        def line1=(_)
-        end
+        attr_accessor :line1
 
+        # Locality or City.
         sig { returns(String) }
-        def locality
-        end
-
-        sig { params(_: String).returns(String) }
-        def locality=(_)
-        end
+        attr_accessor :locality
 
+        # The postal code of the address.
         sig { returns(String) }
-        def postal_code
-        end
-
-        sig { params(_: String).returns(String) }
-        def postal_code=(_)
-        end
+        attr_accessor :postal_code
 
+        # Region or State.
         sig { returns(String) }
-        def region
-        end
-
-        sig { params(_: String).returns(String) }
-        def region=(_)
-        end
+        attr_accessor :region
 
         sig { returns(T.nilable(String)) }
-        def line2
-        end
+        attr_reader :line2
 
-        sig { params(_: String).returns(String) }
-        def line2=(_)
-        end
+        sig { params(line2: String).void }
+        attr_writer :line2
 
+        # The address associated with the owner or null.
         sig do
           params(
             country: String,
@@ -199,9 +167,9 @@ module ModernTreasury
             region: String,
             line2: String
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(country:, line1:, locality:, postal_code:, region:, line2: nil)
+        def self.new(country:, line1:, locality:, postal_code:, region:, line2: nil)
         end
 
         sig do

data/rbi/lib/modern_treasury/models/internal_account_list_params.rbi

@@ -7,84 +7,73 @@ module ModernTreasury
       include ModernTreasury::RequestParameters
 
       sig { returns(T.nilable(String)) }
-      def after_cursor
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def after_cursor=(_)
-      end
+      attr_accessor :after_cursor
 
+      # Only return internal accounts associated with this counterparty.
       sig { returns(T.nilable(String)) }
-      def counterparty_id
-      end
+      attr_reader :counterparty_id
 
-      sig { params(_: String).returns(String) }
-      def counterparty_id=(_)
-      end
+      sig { params(counterparty_id: String).void }
+      attr_writer :counterparty_id
 
-      sig { returns(T.nilable(Symbol)) }
-      def currency
-      end
+      # Only return internal accounts with this currency.
+      sig { returns(T.nilable(ModernTreasury::Models::Currency::OrSymbol)) }
+      attr_reader :currency
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def currency=(_)
-      end
+      sig { params(currency: ModernTreasury::Models::Currency::OrSymbol).void }
+      attr_writer :currency
 
+      # Only return internal accounts associated with this legal entity.
       sig { returns(T.nilable(String)) }
-      def legal_entity_id
-      end
+      attr_reader :legal_entity_id
 
-      sig { params(_: String).returns(String) }
-      def legal_entity_id=(_)
-      end
+      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])) }
-      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 payment_direction
-      end
+      # Only return internal accounts that can originate payments with this direction.
+      sig { returns(T.nilable(ModernTreasury::Models::TransactionDirection::OrSymbol)) }
+      attr_reader :payment_direction
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def payment_direction=(_)
-      end
+      sig { params(payment_direction: ModernTreasury::Models::TransactionDirection::OrSymbol).void }
+      attr_writer :payment_direction
 
-      sig { returns(T.nilable(Symbol)) }
-      def payment_type
-      end
+      # Only return internal accounts that can make this type of payment.
+      sig { returns(T.nilable(ModernTreasury::Models::InternalAccountListParams::PaymentType::OrSymbol)) }
+      attr_reader :payment_type
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def payment_type=(_)
-      end
+      sig { params(payment_type: ModernTreasury::Models::InternalAccountListParams::PaymentType::OrSymbol).void }
+      attr_writer :payment_type
 
       sig { returns(T.nilable(Integer)) }
-      def per_page
-      end
+      attr_reader :per_page
 
-      sig { params(_: Integer).returns(Integer) }
-      def per_page=(_)
-      end
+      sig { params(per_page: Integer).void }
+      attr_writer :per_page
 
       sig do
         params(
           after_cursor: T.nilable(String),
           counterparty_id: String,
-          currency: Symbol,
+          currency: ModernTreasury::Models::Currency::OrSymbol,
           legal_entity_id: String,
           metadata: T::Hash[Symbol, String],
-          payment_direction: Symbol,
-          payment_type: Symbol,
+          payment_direction: ModernTreasury::Models::TransactionDirection::OrSymbol,
+          payment_type: ModernTreasury::Models::InternalAccountListParams::PaymentType::OrSymbol,
           per_page: Integer,
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         after_cursor: nil,
         counterparty_id: nil,
         currency: nil,
@@ -103,11 +92,11 @@ module ModernTreasury
             {
               after_cursor: T.nilable(String),
               counterparty_id: String,
-              currency: Symbol,
+              currency: ModernTreasury::Models::Currency::OrSymbol,
               legal_entity_id: String,
               metadata: T::Hash[Symbol, String],
-              payment_direction: Symbol,
-              payment_type: Symbol,
+              payment_direction: ModernTreasury::Models::TransactionDirection::OrSymbol,
+              payment_type: ModernTreasury::Models::InternalAccountListParams::PaymentType::OrSymbol,
               per_page: Integer,
               request_options: ModernTreasury::RequestOptions
             }
@@ -116,41 +105,51 @@ module ModernTreasury
       def to_hash
       end
 
-      class PaymentType < ModernTreasury::Enum
-        abstract!
-
-        ACH = :ach
-        AU_BECS = :au_becs
-        BACS = :bacs
-        BOOK = :book
-        CARD = :card
-        CHATS = :chats
-        CHECK = :check
-        CROSS_BORDER = :cross_border
-        DK_NETS = :dk_nets
-        EFT = :eft
-        HU_ICS = :hu_ics
-        INTERAC = :interac
-        MASAV = :masav
-        MX_CCEN = :mx_ccen
-        NEFT = :neft
-        NICS = :nics
-        NZ_BECS = :nz_becs
-        PL_ELIXIR = :pl_elixir
-        PROVXCHANGE = :provxchange
-        RO_SENT = :ro_sent
-        RTP = :rtp
-        SE_BANKGIROT = :se_bankgirot
-        SEN = :sen
-        SEPA = :sepa
-        SG_GIRO = :sg_giro
-        SIC = :sic
-        SIGNET = :signet
-        SKNBI = :sknbi
-        WIRE = :wire
-        ZENGIN = :zengin
-
-        sig { override.returns(T::Array[Symbol]) }
+      # Only return internal accounts that can make this type of payment.
+      module PaymentType
+        extend ModernTreasury::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::InternalAccountListParams::PaymentType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol) }
+
+        ACH = T.let(:ach, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        AU_BECS = T.let(:au_becs, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        BACS = T.let(:bacs, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        BOOK = T.let(:book, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        CARD = T.let(:card, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        CHATS = T.let(:chats, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        CHECK = T.let(:check, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        CROSS_BORDER =
+          T.let(:cross_border, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        DK_NETS = T.let(:dk_nets, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        EFT = T.let(:eft, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        HU_ICS = T.let(:hu_ics, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        INTERAC = T.let(:interac, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        MASAV = T.let(:masav, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        MX_CCEN = T.let(:mx_ccen, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        NEFT = T.let(:neft, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        NICS = T.let(:nics, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        NZ_BECS = T.let(:nz_becs, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        PL_ELIXIR =
+          T.let(:pl_elixir, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        PROVXCHANGE =
+          T.let(:provxchange, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        RO_SENT = T.let(:ro_sent, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        RTP = T.let(:rtp, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        SE_BANKGIROT =
+          T.let(:se_bankgirot, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        SEN = T.let(:sen, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        SEPA = T.let(:sepa, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        SG_GIRO = T.let(:sg_giro, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        SIC = T.let(:sic, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        SIGNET = T.let(:signet, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        SKNBI = T.let(:sknbi, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        WIRE = T.let(:wire, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+        ZENGIN = T.let(:zengin, ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::InternalAccountListParams::PaymentType::TaggedSymbol]) }
         def self.values
         end
       end

data/rbi/lib/modern_treasury/models/internal_account_retrieve_params.rbi

@@ -6,8 +6,11 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
-      sig { params(request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])).void }
-      def initialize(request_options: {})
+      sig do
+        params(request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
+          .returns(T.attached_class)
+      end
+      def self.new(request_options: {})
       end
 
       sig { override.returns({request_options: ModernTreasury::RequestOptions}) }

data/rbi/lib/modern_treasury/models/internal_account_update_params.rbi

@@ -6,45 +6,41 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
+      # The Counterparty associated to this account.
       sig { returns(T.nilable(String)) }
-      def counterparty_id
-      end
+      attr_reader :counterparty_id
 
-      sig { params(_: String).returns(String) }
-      def counterparty_id=(_)
-      end
+      sig { params(counterparty_id: String).void }
+      attr_writer :counterparty_id
 
+      # The Ledger Account associated to this account.
       sig { returns(T.nilable(String)) }
-      def ledger_account_id
-      end
+      attr_reader :ledger_account_id
 
-      sig { params(_: String).returns(String) }
-      def ledger_account_id=(_)
-      end
+      sig { params(ledger_account_id: String).void }
+      attr_writer :ledger_account_id
 
+      # Additional data in the form of key-value pairs. Pairs can be removed by passing
+      #   an empty string or `null` as the value.
       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
 
+      # The nickname for the internal account.
       sig { returns(T.nilable(String)) }
-      def name
-      end
+      attr_reader :name
 
-      sig { params(_: String).returns(String) }
-      def name=(_)
-      end
+      sig { params(name: String).void }
+      attr_writer :name
 
+      # The parent internal account for this account.
       sig { returns(T.nilable(String)) }
-      def parent_account_id
-      end
+      attr_reader :parent_account_id
 
-      sig { params(_: String).returns(String) }
-      def parent_account_id=(_)
-      end
+      sig { params(parent_account_id: String).void }
+      attr_writer :parent_account_id
 
       sig do
         params(
@@ -53,11 +49,11 @@ module ModernTreasury
           metadata: T::Hash[Symbol, String],
           name: String,
           parent_account_id: String,
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         counterparty_id: nil,
         ledger_account_id: nil,
         metadata: nil,