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

data/rbi/lib/modern_treasury/models/account_detail.rbi

@@ -4,82 +4,46 @@ module ModernTreasury
   module Models
     class AccountDetail < ModernTreasury::BaseModel
       sig { returns(String) }
-      def id
-      end
-
-      sig { params(_: String).returns(String) }
-      def id=(_)
-      end
+      attr_accessor :id
 
+      # The last 4 digits of the account_number.
       sig { returns(String) }
-      def account_number_safe
-      end
+      attr_accessor :account_number_safe
 
-      sig { params(_: String).returns(String) }
-      def account_number_safe=(_)
-      end
-
-      sig { returns(Symbol) }
-      def account_number_type
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def account_number_type=(_)
-      end
+      # One of `iban`, `clabe`, `wallet_address`, or `other`. Use `other` if the bank
+      #   account number is in a generic format.
+      sig { returns(ModernTreasury::Models::AccountDetail::AccountNumberType::TaggedSymbol) }
+      attr_accessor :account_number_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
 
+      # The account number for the bank account.
       sig { returns(T.nilable(String)) }
-      def account_number
-      end
+      attr_reader :account_number
 
-      sig { params(_: String).returns(String) }
-      def account_number=(_)
-      end
+      sig { params(account_number: String).void }
+      attr_writer :account_number
 
       sig do
         params(
           id: String,
           account_number_safe: String,
-          account_number_type: Symbol,
+          account_number_type: ModernTreasury::Models::AccountDetail::AccountNumberType::OrSymbol,
           created_at: Time,
           discarded_at: T.nilable(Time),
           live_mode: T::Boolean,
@@ -87,9 +51,9 @@ module ModernTreasury
           updated_at: Time,
           account_number: String
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         id:,
         account_number_safe:,
         account_number_type:,
@@ -108,7 +72,7 @@ module ModernTreasury
             {
               id: String,
               account_number_safe: String,
-              account_number_type: Symbol,
+              account_number_type: ModernTreasury::Models::AccountDetail::AccountNumberType::TaggedSymbol,
               created_at: Time,
               discarded_at: T.nilable(Time),
               live_mode: T::Boolean,
@@ -121,21 +85,28 @@ module ModernTreasury
       def to_hash
       end
 
-      class AccountNumberType < ModernTreasury::Enum
-        abstract!
-
-        AU_NUMBER = :au_number
-        CLABE = :clabe
-        HK_NUMBER = :hk_number
-        IBAN = :iban
-        ID_NUMBER = :id_number
-        NZ_NUMBER = :nz_number
-        OTHER = :other
-        PAN = :pan
-        SG_NUMBER = :sg_number
-        WALLET_ADDRESS = :wallet_address
-
-        sig { override.returns(T::Array[Symbol]) }
+      # One of `iban`, `clabe`, `wallet_address`, or `other`. Use `other` if the bank
+      #   account number is in a generic format.
+      module AccountNumberType
+        extend ModernTreasury::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::AccountDetail::AccountNumberType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::AccountDetail::AccountNumberType::TaggedSymbol) }
+
+        AU_NUMBER = T.let(:au_number, ModernTreasury::Models::AccountDetail::AccountNumberType::TaggedSymbol)
+        CLABE = T.let(:clabe, ModernTreasury::Models::AccountDetail::AccountNumberType::TaggedSymbol)
+        HK_NUMBER = T.let(:hk_number, ModernTreasury::Models::AccountDetail::AccountNumberType::TaggedSymbol)
+        IBAN = T.let(:iban, ModernTreasury::Models::AccountDetail::AccountNumberType::TaggedSymbol)
+        ID_NUMBER = T.let(:id_number, ModernTreasury::Models::AccountDetail::AccountNumberType::TaggedSymbol)
+        NZ_NUMBER = T.let(:nz_number, ModernTreasury::Models::AccountDetail::AccountNumberType::TaggedSymbol)
+        OTHER = T.let(:other, ModernTreasury::Models::AccountDetail::AccountNumberType::TaggedSymbol)
+        PAN = T.let(:pan, ModernTreasury::Models::AccountDetail::AccountNumberType::TaggedSymbol)
+        SG_NUMBER = T.let(:sg_number, ModernTreasury::Models::AccountDetail::AccountNumberType::TaggedSymbol)
+        WALLET_ADDRESS =
+          T.let(:wallet_address, ModernTreasury::Models::AccountDetail::AccountNumberType::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::AccountDetail::AccountNumberType::TaggedSymbol]) }
         def self.values
         end
       end

data/rbi/lib/modern_treasury/models/account_detail_create_params.rbi

@@ -6,49 +6,45 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
-      sig { returns(Symbol) }
-      def accounts_type
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def accounts_type=(_)
-      end
+      sig { returns(ModernTreasury::Models::AccountDetailCreateParams::AccountsType::OrSymbol) }
+      attr_accessor :accounts_type
 
+      # The account number for the bank account.
       sig { returns(String) }
-      def account_number
-      end
+      attr_accessor :account_number
 
-      sig { params(_: String).returns(String) }
-      def account_number=(_)
-      end
-
-      sig { returns(T.nilable(Symbol)) }
-      def account_number_type
-      end
+      # One of `iban`, `clabe`, `wallet_address`, or `other`. Use `other` if the bank
+      #   account number is in a generic format.
+      sig { returns(T.nilable(ModernTreasury::Models::AccountDetailCreateParams::AccountNumberType::OrSymbol)) }
+      attr_reader :account_number_type
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def account_number_type=(_)
+      sig do
+        params(
+          account_number_type: ModernTreasury::Models::AccountDetailCreateParams::AccountNumberType::OrSymbol
+        )
+          .void
       end
+      attr_writer :account_number_type
 
       sig do
         params(
-          accounts_type: Symbol,
+          accounts_type: ModernTreasury::Models::AccountDetailCreateParams::AccountsType::OrSymbol,
           account_number: String,
-          account_number_type: Symbol,
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          account_number_type: ModernTreasury::Models::AccountDetailCreateParams::AccountNumberType::OrSymbol,
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(accounts_type:, account_number:, account_number_type: nil, request_options: {})
+      def self.new(accounts_type:, account_number:, account_number_type: nil, request_options: {})
       end
 
       sig do
         override
           .returns(
             {
-              accounts_type: Symbol,
+              accounts_type: ModernTreasury::Models::AccountDetailCreateParams::AccountsType::OrSymbol,
               account_number: String,
-              account_number_type: Symbol,
+              account_number_type: ModernTreasury::Models::AccountDetailCreateParams::AccountNumberType::OrSymbol,
               request_options: ModernTreasury::RequestOptions
             }
           )
@@ -56,31 +52,53 @@ module ModernTreasury
       def to_hash
       end
 
-      class AccountsType < ModernTreasury::Enum
-        abstract!
+      module AccountsType
+        extend ModernTreasury::Enum
 
-        EXTERNAL_ACCOUNTS = :external_accounts
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::AccountDetailCreateParams::AccountsType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::AccountDetailCreateParams::AccountsType::TaggedSymbol) }
 
-        sig { override.returns(T::Array[Symbol]) }
+        EXTERNAL_ACCOUNTS =
+          T.let(:external_accounts, ModernTreasury::Models::AccountDetailCreateParams::AccountsType::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::AccountDetailCreateParams::AccountsType::TaggedSymbol]) }
         def self.values
         end
       end
 
-      class AccountNumberType < ModernTreasury::Enum
-        abstract!
+      # One of `iban`, `clabe`, `wallet_address`, or `other`. Use `other` if the bank
+      #   account number is in a generic format.
+      module AccountNumberType
+        extend ModernTreasury::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::AccountDetailCreateParams::AccountNumberType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::AccountDetailCreateParams::AccountNumberType::TaggedSymbol) }
 
-        AU_NUMBER = :au_number
-        CLABE = :clabe
-        HK_NUMBER = :hk_number
-        IBAN = :iban
-        ID_NUMBER = :id_number
-        NZ_NUMBER = :nz_number
-        OTHER = :other
-        PAN = :pan
-        SG_NUMBER = :sg_number
-        WALLET_ADDRESS = :wallet_address
+        AU_NUMBER =
+          T.let(:au_number, ModernTreasury::Models::AccountDetailCreateParams::AccountNumberType::TaggedSymbol)
+        CLABE = T.let(:clabe, ModernTreasury::Models::AccountDetailCreateParams::AccountNumberType::TaggedSymbol)
+        HK_NUMBER =
+          T.let(:hk_number, ModernTreasury::Models::AccountDetailCreateParams::AccountNumberType::TaggedSymbol)
+        IBAN = T.let(:iban, ModernTreasury::Models::AccountDetailCreateParams::AccountNumberType::TaggedSymbol)
+        ID_NUMBER =
+          T.let(:id_number, ModernTreasury::Models::AccountDetailCreateParams::AccountNumberType::TaggedSymbol)
+        NZ_NUMBER =
+          T.let(:nz_number, ModernTreasury::Models::AccountDetailCreateParams::AccountNumberType::TaggedSymbol)
+        OTHER = T.let(:other, ModernTreasury::Models::AccountDetailCreateParams::AccountNumberType::TaggedSymbol)
+        PAN = T.let(:pan, ModernTreasury::Models::AccountDetailCreateParams::AccountNumberType::TaggedSymbol)
+        SG_NUMBER =
+          T.let(:sg_number, ModernTreasury::Models::AccountDetailCreateParams::AccountNumberType::TaggedSymbol)
+        WALLET_ADDRESS =
+          T.let(:wallet_address, ModernTreasury::Models::AccountDetailCreateParams::AccountNumberType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig do
+          override
+            .returns(T::Array[ModernTreasury::Models::AccountDetailCreateParams::AccountNumberType::TaggedSymbol])
+        end
         def self.values
         end
       end

data/rbi/lib/modern_treasury/models/account_detail_delete_params.rbi

@@ -6,50 +6,48 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
-      sig { returns(Symbol) }
-      def accounts_type
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def accounts_type=(_)
-      end
+      sig { returns(ModernTreasury::Models::AccountDetailDeleteParams::AccountsType::OrSymbol) }
+      attr_accessor :accounts_type
 
       sig { returns(String) }
-      def account_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def account_id=(_)
-      end
+      attr_accessor :account_id
 
       sig do
         params(
-          accounts_type: Symbol,
+          accounts_type: ModernTreasury::Models::AccountDetailDeleteParams::AccountsType::OrSymbol,
           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(accounts_type:, account_id:, request_options: {})
+      def self.new(accounts_type:, account_id:, request_options: {})
       end
 
       sig do
         override
-          .returns({
-                     accounts_type: Symbol,
-                     account_id: String,
-                     request_options: ModernTreasury::RequestOptions
-                   })
+          .returns(
+            {
+              accounts_type: ModernTreasury::Models::AccountDetailDeleteParams::AccountsType::OrSymbol,
+              account_id: String,
+              request_options: ModernTreasury::RequestOptions
+            }
+          )
       end
       def to_hash
       end
 
-      class AccountsType < ModernTreasury::Enum
-        abstract!
+      module AccountsType
+        extend ModernTreasury::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::AccountDetailDeleteParams::AccountsType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::AccountDetailDeleteParams::AccountsType::TaggedSymbol) }
 
-        EXTERNAL_ACCOUNTS = :external_accounts
+        EXTERNAL_ACCOUNTS =
+          T.let(:external_accounts, ModernTreasury::Models::AccountDetailDeleteParams::AccountsType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[ModernTreasury::Models::AccountDetailDeleteParams::AccountsType::TaggedSymbol]) }
         def self.values
         end
       end

data/rbi/lib/modern_treasury/models/account_detail_list_params.rbi

@@ -6,47 +6,35 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
-      sig { returns(Symbol) }
-      def accounts_type
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def accounts_type=(_)
-      end
+      sig { returns(ModernTreasury::Models::AccountsType::OrSymbol) }
+      attr_accessor :accounts_type
 
       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
 
       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(
-          accounts_type: Symbol,
+          accounts_type: ModernTreasury::Models::AccountsType::OrSymbol,
           after_cursor: T.nilable(String),
           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(accounts_type:, after_cursor: nil, per_page: nil, request_options: {})
+      def self.new(accounts_type:, after_cursor: nil, per_page: nil, request_options: {})
       end
 
       sig do
         override
           .returns(
             {
-              accounts_type: Symbol,
+              accounts_type: ModernTreasury::Models::AccountsType::OrSymbol,
               after_cursor: T.nilable(String),
               per_page: Integer,
               request_options: ModernTreasury::RequestOptions

data/rbi/lib/modern_treasury/models/account_detail_retrieve_params.rbi

@@ -6,40 +6,32 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
-      sig { returns(Symbol) }
-      def accounts_type
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def accounts_type=(_)
-      end
+      sig { returns(ModernTreasury::Models::AccountsType::OrSymbol) }
+      attr_accessor :accounts_type
 
       sig { returns(String) }
-      def account_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def account_id=(_)
-      end
+      attr_accessor :account_id
 
       sig do
         params(
-          accounts_type: Symbol,
+          accounts_type: ModernTreasury::Models::AccountsType::OrSymbol,
           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(accounts_type:, account_id:, request_options: {})
+      def self.new(accounts_type:, account_id:, request_options: {})
       end
 
       sig do
         override
-          .returns({
-                     accounts_type: Symbol,
-                     account_id: String,
-                     request_options: ModernTreasury::RequestOptions
-                   })
+          .returns(
+            {
+              accounts_type: ModernTreasury::Models::AccountsType::OrSymbol,
+              account_id: String,
+              request_options: ModernTreasury::RequestOptions
+            }
+          )
       end
       def to_hash
       end

data/rbi/lib/modern_treasury/models/accounts_type.rbi

@@ -2,13 +2,16 @@
 
 module ModernTreasury
   module Models
-    class AccountsType < ModernTreasury::Enum
-      abstract!
+    module AccountsType
+      extend ModernTreasury::Enum
 
-      EXTERNAL_ACCOUNTS = :external_accounts
-      INTERNAL_ACCOUNTS = :internal_accounts
+      TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::AccountsType) }
+      OrSymbol = T.type_alias { T.any(Symbol, ModernTreasury::Models::AccountsType::TaggedSymbol) }
 
-      sig { override.returns(T::Array[Symbol]) }
+      EXTERNAL_ACCOUNTS = T.let(:external_accounts, ModernTreasury::Models::AccountsType::TaggedSymbol)
+      INTERNAL_ACCOUNTS = T.let(:internal_accounts, ModernTreasury::Models::AccountsType::TaggedSymbol)
+
+      sig { override.returns(T::Array[ModernTreasury::Models::AccountsType::TaggedSymbol]) }
       def self.values
       end
     end

data/rbi/lib/modern_treasury/models/async_response.rbi

@@ -4,23 +4,13 @@ module ModernTreasury
   module Models
     class AsyncResponse < ModernTreasury::BaseModel
       sig { returns(String) }
-      def id
-      end
-
-      sig { params(_: String).returns(String) }
-      def id=(_)
-      end
+      attr_accessor :id
 
       sig { returns(String) }
-      def object
-      end
-
-      sig { params(_: String).returns(String) }
-      def object=(_)
-      end
+      attr_accessor :object
 
-      sig { params(id: String, object: String).void }
-      def initialize(id:, object:)
+      sig { params(id: String, object: String).returns(T.attached_class) }
+      def self.new(id:, object:)
       end
 
       sig { override.returns({id: String, object: String}) }

data/rbi/lib/modern_treasury/models/bank_settings.rbi

@@ -4,84 +4,44 @@ module ModernTreasury
   module Models
     class BankSettings < ModernTreasury::BaseModel
       sig { returns(String) }
-      def id
-      end
-
-      sig { params(_: String).returns(String) }
-      def id=(_)
-      end
+      attr_accessor :id
 
+      # The percentage of backup withholding to apply to the legal entity.
       sig { returns(T.nilable(Integer)) }
-      def backup_withholding_percentage
-      end
-
-      sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-      def backup_withholding_percentage=(_)
-      end
+      attr_accessor :backup_withholding_percentage
 
       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
 
+      # Whether backup withholding is enabled. See more here -
+      #   https://www.irs.gov/businesses/small-businesses-self-employed/backup-withholding.
       sig { returns(T.nilable(T::Boolean)) }
-      def enable_backup_withholding
-      end
-
-      sig { params(_: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
-      def enable_backup_withholding=(_)
-      end
+      attr_accessor :enable_backup_withholding
 
+      # 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
 
+      # Cross River Bank specific setting to opt out of privacy policy.
       sig { returns(T.nilable(T::Boolean)) }
-      def privacy_opt_out
-      end
-
-      sig { params(_: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
-      def privacy_opt_out=(_)
-      end
+      attr_accessor :privacy_opt_out
 
+      # It covers, among other types of insider loans, extensions of credit by a member
+      #   bank to an executive officer, director, or principal shareholder of the member
+      #   bank; a bank holding company of which the member bank is a subsidiary; and any
+      #   other subsidiary of that bank holding company.
       sig { returns(T.nilable(T::Boolean)) }
-      def regulation_o
-      end
-
-      sig { params(_: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
-      def regulation_o=(_)
-      end
+      attr_accessor :regulation_o
 
       sig { returns(Time) }
-      def updated_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def updated_at=(_)
-      end
+      attr_accessor :updated_at
 
       sig do
         params(
@@ -96,9 +56,9 @@ module ModernTreasury
           regulation_o: T.nilable(T::Boolean),
           updated_at: Time
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         id:,
         backup_withholding_percentage:,
         created_at:,