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

data/rbi/lib/modern_treasury/models/account_collection_flow.rbi

@@ -2,112 +2,99 @@
 
 module ModernTreasury
   module Models
-    class AccountCollectionFlow < ModernTreasury::BaseModel
+    class AccountCollectionFlow < ModernTreasury::Internal::Type::BaseModel
+      # The ID of a counterparty. An external account created with this flow will be
+      # associated with this counterparty.
       sig { returns(String) }
-      def counterparty_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def counterparty_id=(_)
-      end
+      attr_accessor :counterparty_id
 
-      sig { returns(T::Array[Symbol]) }
-      def payment_types
-      end
-
-      sig { params(_: T::Array[Symbol]).returns(T::Array[Symbol]) }
-      def payment_types=(_)
-      end
+      sig { returns(T::Array[ModernTreasury::Models::AccountCollectionFlow::PaymentType::TaggedSymbol]) }
+      attr_accessor :payment_types
 
       sig { returns(T.nilable(String)) }
-      def id
-      end
+      attr_reader :id
 
-      sig { params(_: String).returns(String) }
-      def id=(_)
-      end
+      sig { params(id: String).void }
+      attr_writer :id
 
+      # The client token of the account collection flow. This token can be used to embed
+      # account collection in your client-side application.
       sig { returns(T.nilable(String)) }
-      def client_token
-      end
+      attr_reader :client_token
 
-      sig { params(_: String).returns(String) }
-      def client_token=(_)
-      end
+      sig { params(client_token: String).void }
+      attr_writer :client_token
 
       sig { returns(T.nilable(Time)) }
-      def created_at
-      end
+      attr_reader :created_at
 
-      sig { params(_: Time).returns(Time) }
-      def created_at=(_)
-      end
+      sig { params(created_at: Time).void }
+      attr_writer :created_at
 
+      # If present, the ID of the external account created using this flow.
       sig { returns(T.nilable(String)) }
-      def external_account_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def external_account_id=(_)
-      end
+      attr_accessor :external_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.nilable(T::Boolean)) }
-      def live_mode
-      end
+      attr_reader :live_mode
 
-      sig { params(_: T::Boolean).returns(T::Boolean) }
-      def live_mode=(_)
-      end
+      sig { params(live_mode: T::Boolean).void }
+      attr_writer :live_mode
 
       sig { returns(T.nilable(String)) }
-      def object
-      end
+      attr_reader :object
 
-      sig { params(_: String).returns(String) }
-      def object=(_)
-      end
+      sig { params(object: String).void }
+      attr_writer :object
 
-      sig { returns(T.nilable(T::Array[Symbol])) }
-      def receiving_countries
+      sig do
+        returns(
+          T.nilable(T::Array[ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry::TaggedSymbol])
+        )
       end
+      attr_reader :receiving_countries
 
-      sig { params(_: T::Array[Symbol]).returns(T::Array[Symbol]) }
-      def receiving_countries=(_)
+      sig do
+        params(
+          receiving_countries: T::Array[ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry::OrSymbol]
+        )
+          .void
       end
+      attr_writer :receiving_countries
 
-      sig { returns(T.nilable(Symbol)) }
-      def status
-      end
+      # The current status of the account collection flow. One of `pending`,
+      # `completed`, `expired`, or `cancelled`.
+      sig { returns(T.nilable(ModernTreasury::Models::AccountCollectionFlow::Status::TaggedSymbol)) }
+      attr_reader :status
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def status=(_)
-      end
+      sig { params(status: ModernTreasury::Models::AccountCollectionFlow::Status::OrSymbol).void }
+      attr_writer :status
 
       sig { returns(T.nilable(Time)) }
-      def updated_at
-      end
+      attr_reader :updated_at
 
-      sig { params(_: Time).returns(Time) }
-      def updated_at=(_)
-      end
+      sig { params(updated_at: Time).void }
+      attr_writer :updated_at
 
       sig do
         params(
           counterparty_id: String,
-          payment_types: T::Array[Symbol],
+          payment_types: T::Array[ModernTreasury::Models::AccountCollectionFlow::PaymentType::OrSymbol],
           id: String,
           client_token: String,
           created_at: Time,
           external_account_id: T.nilable(String),
           live_mode: T::Boolean,
           object: String,
-          receiving_countries: T::Array[Symbol],
-          status: Symbol,
+          receiving_countries: T::Array[ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry::OrSymbol],
+          status: ModernTreasury::Models::AccountCollectionFlow::Status::OrSymbol,
           updated_at: Time
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         counterparty_id:,
         payment_types:,
         id: nil,
@@ -119,79 +106,91 @@ module ModernTreasury
         receiving_countries: nil,
         status: nil,
         updated_at: nil
-      )
-      end
-
+      ); end
       sig do
         override
           .returns(
             {
               counterparty_id: String,
-              payment_types: T::Array[Symbol],
+              payment_types: T::Array[ModernTreasury::Models::AccountCollectionFlow::PaymentType::TaggedSymbol],
               id: String,
               client_token: String,
               created_at: Time,
               external_account_id: T.nilable(String),
               live_mode: T::Boolean,
               object: String,
-              receiving_countries: T::Array[Symbol],
-              status: Symbol,
+              receiving_countries: T::Array[ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry::TaggedSymbol],
+              status: ModernTreasury::Models::AccountCollectionFlow::Status::TaggedSymbol,
               updated_at: Time
             }
           )
       end
-      def to_hash
-      end
-
-      class PaymentType < ModernTreasury::Enum
-        abstract!
-
-        ACH = :ach
-        WIRE = :wire
-
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
-        end
-      end
-
-      class ReceivingCountry < ModernTreasury::Enum
-        abstract!
-
-        USA = :USA
-        AUS = :AUS
-        BEL = :BEL
-        CAN = :CAN
-        CHL = :CHL
-        CHN = :CHN
-        COL = :COL
-        FRA = :FRA
-        DEU = :DEU
-        HKG = :HKG
-        IND = :IND
-        IRL = :IRL
-        ITA = :ITA
-        MEX = :MEX
-        NLD = :NLD
-        PER = :PER
-        ESP = :ESP
-        GBR = :GBR
-
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
-        end
-      end
-
-      class Status < ModernTreasury::Enum
-        abstract!
-
-        CANCELLED = :cancelled
-        COMPLETED = :completed
-        EXPIRED = :expired
-        PENDING = :pending
-
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
-        end
+      def to_hash; end
+
+      # An account created with this flow will support payments of one of these types.
+      module PaymentType
+        extend ModernTreasury::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::AccountCollectionFlow::PaymentType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, ModernTreasury::Models::AccountCollectionFlow::PaymentType::TaggedSymbol) }
+
+        ACH = T.let(:ach, ModernTreasury::Models::AccountCollectionFlow::PaymentType::TaggedSymbol)
+        WIRE = T.let(:wire, ModernTreasury::Models::AccountCollectionFlow::PaymentType::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::AccountCollectionFlow::PaymentType::TaggedSymbol]) }
+        def self.values; end
+      end
+
+      # An account created with this flow will support wires from the US to these
+      # countries.
+      module ReceivingCountry
+        extend ModernTreasury::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry::TaggedSymbol) }
+
+        USA = T.let(:USA, ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry::TaggedSymbol)
+        AUS = T.let(:AUS, ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry::TaggedSymbol)
+        BEL = T.let(:BEL, ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry::TaggedSymbol)
+        CAN = T.let(:CAN, ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry::TaggedSymbol)
+        CHL = T.let(:CHL, ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry::TaggedSymbol)
+        CHN = T.let(:CHN, ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry::TaggedSymbol)
+        COL = T.let(:COL, ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry::TaggedSymbol)
+        FRA = T.let(:FRA, ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry::TaggedSymbol)
+        DEU = T.let(:DEU, ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry::TaggedSymbol)
+        HKG = T.let(:HKG, ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry::TaggedSymbol)
+        IND = T.let(:IND, ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry::TaggedSymbol)
+        IRL = T.let(:IRL, ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry::TaggedSymbol)
+        ITA = T.let(:ITA, ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry::TaggedSymbol)
+        MEX = T.let(:MEX, ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry::TaggedSymbol)
+        NLD = T.let(:NLD, ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry::TaggedSymbol)
+        PER = T.let(:PER, ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry::TaggedSymbol)
+        ESP = T.let(:ESP, ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry::TaggedSymbol)
+        GBR = T.let(:GBR, ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry::TaggedSymbol]) }
+        def self.values; end
+      end
+
+      # The current status of the account collection flow. One of `pending`,
+      # `completed`, `expired`, or `cancelled`.
+      module Status
+        extend ModernTreasury::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::AccountCollectionFlow::Status) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, ModernTreasury::Models::AccountCollectionFlow::Status::TaggedSymbol) }
+
+        CANCELLED = T.let(:cancelled, ModernTreasury::Models::AccountCollectionFlow::Status::TaggedSymbol)
+        COMPLETED = T.let(:completed, ModernTreasury::Models::AccountCollectionFlow::Status::TaggedSymbol)
+        EXPIRED = T.let(:expired, ModernTreasury::Models::AccountCollectionFlow::Status::TaggedSymbol)
+        PENDING = T.let(:pending, ModernTreasury::Models::AccountCollectionFlow::Status::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::AccountCollectionFlow::Status::TaggedSymbol]) }
+        def self.values; end
       end
     end
   end

data/rbi/lib/modern_treasury/models/account_collection_flow_create_params.rbi

@@ -2,45 +2,42 @@
 
 module ModernTreasury
   module Models
-    class AccountCollectionFlowCreateParams < ModernTreasury::BaseModel
-      extend ModernTreasury::RequestParameters::Converter
-      include ModernTreasury::RequestParameters
+    class AccountCollectionFlowCreateParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::RequestParameters
 
+      # Required.
       sig { returns(String) }
-      def counterparty_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def counterparty_id=(_)
-      end
+      attr_accessor :counterparty_id
 
       sig { returns(T::Array[String]) }
-      def payment_types
-      end
+      attr_accessor :payment_types
 
-      sig { params(_: T::Array[String]).returns(T::Array[String]) }
-      def payment_types=(_)
-      end
-
-      sig { returns(T.nilable(T::Array[Symbol])) }
-      def receiving_countries
+      sig do
+        returns(
+          T.nilable(T::Array[ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::OrSymbol])
+        )
       end
+      attr_reader :receiving_countries
 
-      sig { params(_: T::Array[Symbol]).returns(T::Array[Symbol]) }
-      def receiving_countries=(_)
+      sig do
+        params(
+          receiving_countries: T::Array[ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::OrSymbol]
+        )
+          .void
       end
+      attr_writer :receiving_countries
 
       sig do
         params(
           counterparty_id: String,
           payment_types: T::Array[String],
-          receiving_countries: T::Array[Symbol],
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          receiving_countries: T::Array[ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::OrSymbol],
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash)
         )
-          .void
-      end
-      def initialize(counterparty_id:, payment_types:, receiving_countries: nil, request_options: {})
+          .returns(T.attached_class)
       end
+      def self.new(counterparty_id:, payment_types:, receiving_countries: nil, request_options: {}); end
 
       sig do
         override
@@ -48,39 +45,72 @@ module ModernTreasury
             {
               counterparty_id: String,
               payment_types: T::Array[String],
-              receiving_countries: T::Array[Symbol],
+              receiving_countries: T::Array[ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::OrSymbol],
               request_options: ModernTreasury::RequestOptions
             }
           )
       end
-      def to_hash
-      end
+      def to_hash; end
+
+      # Optional. Array of 3-digit ISO country codes.
+      module ReceivingCountry
+        extend ModernTreasury::Internal::Type::Enum
 
-      class ReceivingCountry < ModernTreasury::Enum
-        abstract!
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry) }
+        OrSymbol =
+          T.type_alias do
+            T.any(
+              Symbol,
+              String,
+              ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::TaggedSymbol
+            )
+          end
 
-        USA = :USA
-        AUS = :AUS
-        BEL = :BEL
-        CAN = :CAN
-        CHL = :CHL
-        CHN = :CHN
-        COL = :COL
-        FRA = :FRA
-        DEU = :DEU
-        HKG = :HKG
-        IND = :IND
-        IRL = :IRL
-        ITA = :ITA
-        MEX = :MEX
-        NLD = :NLD
-        PER = :PER
-        ESP = :ESP
-        GBR = :GBR
+        USA =
+          T.let(:USA, ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::TaggedSymbol)
+        AUS =
+          T.let(:AUS, ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::TaggedSymbol)
+        BEL =
+          T.let(:BEL, ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::TaggedSymbol)
+        CAN =
+          T.let(:CAN, ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::TaggedSymbol)
+        CHL =
+          T.let(:CHL, ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::TaggedSymbol)
+        CHN =
+          T.let(:CHN, ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::TaggedSymbol)
+        COL =
+          T.let(:COL, ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::TaggedSymbol)
+        FRA =
+          T.let(:FRA, ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::TaggedSymbol)
+        DEU =
+          T.let(:DEU, ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::TaggedSymbol)
+        HKG =
+          T.let(:HKG, ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::TaggedSymbol)
+        IND =
+          T.let(:IND, ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::TaggedSymbol)
+        IRL =
+          T.let(:IRL, ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::TaggedSymbol)
+        ITA =
+          T.let(:ITA, ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::TaggedSymbol)
+        MEX =
+          T.let(:MEX, ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::TaggedSymbol)
+        NLD =
+          T.let(:NLD, ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::TaggedSymbol)
+        PER =
+          T.let(:PER, ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::TaggedSymbol)
+        ESP =
+          T.let(:ESP, ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::TaggedSymbol)
+        GBR =
+          T.let(:GBR, ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
+        sig do
+          override
+            .returns(
+              T::Array[ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::TaggedSymbol]
+            )
         end
+        def self.values; end
       end
     end
   end

data/rbi/lib/modern_treasury/models/account_collection_flow_list_params.rbi

@@ -2,57 +2,42 @@
 
 module ModernTreasury
   module Models
-    class AccountCollectionFlowListParams < ModernTreasury::BaseModel
-      extend ModernTreasury::RequestParameters::Converter
-      include ModernTreasury::RequestParameters
+    class AccountCollectionFlowListParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::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
 
       sig { returns(T.nilable(String)) }
-      def client_token
-      end
+      attr_reader :client_token
 
-      sig { params(_: String).returns(String) }
-      def client_token=(_)
-      end
+      sig { params(client_token: String).void }
+      attr_writer :client_token
 
       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(String)) }
-      def external_account_id
-      end
+      attr_reader :external_account_id
 
-      sig { params(_: String).returns(String) }
-      def external_account_id=(_)
-      end
+      sig { params(external_account_id: String).void }
+      attr_writer :external_account_id
 
       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 { returns(T.nilable(String)) }
-      def status
-      end
+      attr_reader :status
 
-      sig { params(_: String).returns(String) }
-      def status=(_)
-      end
+      sig { params(status: String).void }
+      attr_writer :status
 
       sig do
         params(
@@ -62,11 +47,11 @@ module ModernTreasury
           external_account_id: String,
           per_page: Integer,
           status: String,
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         after_cursor: nil,
         client_token: nil,
         counterparty_id: nil,
@@ -74,9 +59,7 @@ module ModernTreasury
         per_page: nil,
         status: nil,
         request_options: {}
-      )
-      end
-
+      ); end
       sig do
         override
           .returns(
@@ -91,8 +74,7 @@ module ModernTreasury
             }
           )
       end
-      def to_hash
-      end
+      def to_hash; end
     end
   end
 end

data/rbi/lib/modern_treasury/models/account_collection_flow_retrieve_params.rbi

@@ -2,17 +2,18 @@
 
 module ModernTreasury
   module Models
-    class AccountCollectionFlowRetrieveParams < ModernTreasury::BaseModel
-      extend ModernTreasury::RequestParameters::Converter
-      include ModernTreasury::RequestParameters
+    class AccountCollectionFlowRetrieveParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::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::Internal::AnyHash))
+          .returns(T.attached_class)
       end
+      def self.new(request_options: {}); end
 
       sig { override.returns({request_options: ModernTreasury::RequestOptions}) }
-      def to_hash
-      end
+      def to_hash; end
     end
   end
 end