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

data/rbi/lib/modern_treasury/models/payment_flow.rbi

@@ -2,158 +2,133 @@
 
 module ModernTreasury
   module Models
-    class PaymentFlow < ModernTreasury::BaseModel
+    class PaymentFlow < ModernTreasury::Internal::Type::BaseModel
       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
 
+      # Value in specified currency's smallest unit. e.g. $10 would be represented
+      # as 1000. Can be any integer up to 36 digits.
       sig { returns(T.nilable(Integer)) }
-      def amount
-      end
+      attr_reader :amount
 
-      sig { params(_: Integer).returns(Integer) }
-      def amount=(_)
-      end
+      sig { params(amount: Integer).void }
+      attr_writer :amount
 
+      # The client token of the payment flow. This token can be used to embed a payment
+      # workflow 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
 
+      # The ID of a counterparty associated with the payment. As part of the payment
+      # workflow an external account will be associated with this counterparty.
       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(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
 
+      # The currency of the payment.
       sig { returns(T.nilable(String)) }
-      def currency
-      end
+      attr_reader :currency
 
-      sig { params(_: String).returns(String) }
-      def currency=(_)
-      end
+      sig { params(currency: String).void }
+      attr_writer :currency
 
-      sig { returns(T.nilable(Symbol)) }
-      def direction
-      end
+      # Describes the direction money is flowing in the transaction. Can only be
+      # `debit`. A `debit` pulls money from someone else's account to your own.
+      sig { returns(T.nilable(ModernTreasury::Models::PaymentFlow::Direction::TaggedSymbol)) }
+      attr_reader :direction
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def direction=(_)
-      end
+      sig { params(direction: ModernTreasury::Models::PaymentFlow::Direction::OrSymbol).void }
+      attr_writer :direction
 
+      # The due date for the flow. Can only be passed in when
+      # `effective_date_selection_enabled` is `true`.
       sig { returns(T.nilable(Date)) }
-      def due_date
-      end
-
-      sig { params(_: T.nilable(Date)).returns(T.nilable(Date)) }
-      def due_date=(_)
-      end
+      attr_accessor :due_date
 
+      # When `true`, your end-user can schedule the payment `effective_date` while
+      # completing the pre-built UI.
       sig { returns(T.nilable(T::Boolean)) }
-      def effective_date_selection_enabled
-      end
+      attr_reader :effective_date_selection_enabled
 
-      sig { params(_: T::Boolean).returns(T::Boolean) }
-      def effective_date_selection_enabled=(_)
-      end
+      sig { params(effective_date_selection_enabled: T::Boolean).void }
+      attr_writer :effective_date_selection_enabled
 
-      sig { returns(T.nilable(Symbol)) }
-      def existing_external_accounts_filter
-      end
+      # When `verified` and `external_account_collection` is `enabled`, filters the list
+      # of external accounts your end-user can select to those with a
+      # `verification_status` of `verified`.
+      sig { returns(T.nilable(ModernTreasury::Models::PaymentFlow::ExistingExternalAccountsFilter::TaggedSymbol)) }
+      attr_accessor :existing_external_accounts_filter
 
-      sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-      def existing_external_accounts_filter=(_)
-      end
+      # When `enabled`, your end-user can select from an existing external account when
+      # completing the flow. When `disabled`, your end-user must add new payment details
+      # when completing the flow.
+      sig { returns(T.nilable(ModernTreasury::Models::PaymentFlow::ExternalAccountCollection::TaggedSymbol)) }
+      attr_reader :external_account_collection
 
-      sig { returns(T.nilable(Symbol)) }
-      def external_account_collection
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def external_account_collection=(_)
+      sig do
+        params(
+          external_account_collection: ModernTreasury::Models::PaymentFlow::ExternalAccountCollection::OrSymbol
+        )
+          .void
       end
+      attr_writer :external_account_collection
 
+      # 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
 
+      # The ID of one of your organization's internal accounts.
       sig { returns(T.nilable(String)) }
-      def originating_account_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def originating_account_id=(_)
-      end
+      attr_accessor :originating_account_id
 
+      # If present, the ID of the payment order created using this flow.
       sig { returns(T.nilable(String)) }
-      def payment_order_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def payment_order_id=(_)
-      end
+      attr_accessor :payment_order_id
 
+      # If present, the ID of the external account created using this flow.
       sig { returns(T.nilable(String)) }
-      def receiving_account_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def receiving_account_id=(_)
-      end
+      attr_accessor :receiving_account_id
 
+      # This field is set after your end-user selects a payment date while completing
+      # the pre-built UI. This field is always `null` unless
+      # `effective_date_selection_enabled` is `true`.
       sig { returns(T.nilable(Date)) }
-      def selected_effective_date
-      end
+      attr_accessor :selected_effective_date
 
-      sig { params(_: T.nilable(Date)).returns(T.nilable(Date)) }
-      def selected_effective_date=(_)
-      end
+      # The current status of the payment flow. One of `pending`, `completed`,
+      # `expired`, or `cancelled`.
+      sig { returns(T.nilable(ModernTreasury::Models::PaymentFlow::Status::TaggedSymbol)) }
+      attr_reader :status
 
-      sig { returns(T.nilable(Symbol)) }
-      def status
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def status=(_)
-      end
+      sig { params(status: ModernTreasury::Models::PaymentFlow::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(
@@ -163,23 +138,23 @@ module ModernTreasury
           counterparty_id: T.nilable(String),
           created_at: Time,
           currency: String,
-          direction: Symbol,
+          direction: ModernTreasury::Models::PaymentFlow::Direction::OrSymbol,
           due_date: T.nilable(Date),
           effective_date_selection_enabled: T::Boolean,
-          existing_external_accounts_filter: T.nilable(Symbol),
-          external_account_collection: Symbol,
+          existing_external_accounts_filter: T.nilable(ModernTreasury::Models::PaymentFlow::ExistingExternalAccountsFilter::OrSymbol),
+          external_account_collection: ModernTreasury::Models::PaymentFlow::ExternalAccountCollection::OrSymbol,
           live_mode: T::Boolean,
           object: String,
           originating_account_id: T.nilable(String),
           payment_order_id: T.nilable(String),
           receiving_account_id: T.nilable(String),
           selected_effective_date: T.nilable(Date),
-          status: Symbol,
+          status: ModernTreasury::Models::PaymentFlow::Status::OrSymbol,
           updated_at: Time
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         id: nil,
         amount: nil,
         client_token: nil,
@@ -199,9 +174,7 @@ module ModernTreasury
         selected_effective_date: nil,
         status: nil,
         updated_at: nil
-      )
-      end
-
+      ); end
       sig do
         override
           .returns(
@@ -212,68 +185,95 @@ module ModernTreasury
               counterparty_id: T.nilable(String),
               created_at: Time,
               currency: String,
-              direction: Symbol,
+              direction: ModernTreasury::Models::PaymentFlow::Direction::TaggedSymbol,
               due_date: T.nilable(Date),
               effective_date_selection_enabled: T::Boolean,
-              existing_external_accounts_filter: T.nilable(Symbol),
-              external_account_collection: Symbol,
+              existing_external_accounts_filter: T.nilable(ModernTreasury::Models::PaymentFlow::ExistingExternalAccountsFilter::TaggedSymbol),
+              external_account_collection: ModernTreasury::Models::PaymentFlow::ExternalAccountCollection::TaggedSymbol,
               live_mode: T::Boolean,
               object: String,
               originating_account_id: T.nilable(String),
               payment_order_id: T.nilable(String),
               receiving_account_id: T.nilable(String),
               selected_effective_date: T.nilable(Date),
-              status: Symbol,
+              status: ModernTreasury::Models::PaymentFlow::Status::TaggedSymbol,
               updated_at: Time
             }
           )
       end
-      def to_hash
-      end
+      def to_hash; end
 
-      class Direction < ModernTreasury::Enum
-        abstract!
+      # Describes the direction money is flowing in the transaction. Can only be
+      # `debit`. A `debit` pulls money from someone else's account to your own.
+      module Direction
+        extend ModernTreasury::Internal::Type::Enum
 
-        CREDIT = :credit
-        DEBIT = :debit
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::PaymentFlow::Direction) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, ModernTreasury::Models::PaymentFlow::Direction::TaggedSymbol) }
 
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
-        end
+        CREDIT = T.let(:credit, ModernTreasury::Models::PaymentFlow::Direction::TaggedSymbol)
+        DEBIT = T.let(:debit, ModernTreasury::Models::PaymentFlow::Direction::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::PaymentFlow::Direction::TaggedSymbol]) }
+        def self.values; end
       end
 
-      class ExistingExternalAccountsFilter < ModernTreasury::Enum
-        abstract!
+      # When `verified` and `external_account_collection` is `enabled`, filters the list
+      # of external accounts your end-user can select to those with a
+      # `verification_status` of `verified`.
+      module ExistingExternalAccountsFilter
+        extend ModernTreasury::Internal::Type::Enum
 
-        VERIFIED = T.let(:verified, T.nilable(Symbol))
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::PaymentFlow::ExistingExternalAccountsFilter) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, ModernTreasury::Models::PaymentFlow::ExistingExternalAccountsFilter::TaggedSymbol) }
 
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
+        VERIFIED =
+          T.let(:verified, ModernTreasury::Models::PaymentFlow::ExistingExternalAccountsFilter::TaggedSymbol)
+
+        sig do
+          override
+            .returns(T::Array[ModernTreasury::Models::PaymentFlow::ExistingExternalAccountsFilter::TaggedSymbol])
         end
+        def self.values; end
       end
 
-      class ExternalAccountCollection < ModernTreasury::Enum
-        abstract!
+      # When `enabled`, your end-user can select from an existing external account when
+      # completing the flow. When `disabled`, your end-user must add new payment details
+      # when completing the flow.
+      module ExternalAccountCollection
+        extend ModernTreasury::Internal::Type::Enum
 
-        DISABLED = :disabled
-        ENABLED = :enabled
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::PaymentFlow::ExternalAccountCollection) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, ModernTreasury::Models::PaymentFlow::ExternalAccountCollection::TaggedSymbol) }
 
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
-        end
+        DISABLED = T.let(:disabled, ModernTreasury::Models::PaymentFlow::ExternalAccountCollection::TaggedSymbol)
+        ENABLED = T.let(:enabled, ModernTreasury::Models::PaymentFlow::ExternalAccountCollection::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::PaymentFlow::ExternalAccountCollection::TaggedSymbol]) }
+        def self.values; end
       end
 
-      class Status < ModernTreasury::Enum
-        abstract!
+      # The current status of the payment flow. One of `pending`, `completed`,
+      # `expired`, or `cancelled`.
+      module Status
+        extend ModernTreasury::Internal::Type::Enum
 
-        CANCELLED = :cancelled
-        COMPLETED = :completed
-        EXPIRED = :expired
-        PENDING = :pending
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::PaymentFlow::Status) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, ModernTreasury::Models::PaymentFlow::Status::TaggedSymbol) }
 
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
-        end
+        CANCELLED = T.let(:cancelled, ModernTreasury::Models::PaymentFlow::Status::TaggedSymbol)
+        COMPLETED = T.let(:completed, ModernTreasury::Models::PaymentFlow::Status::TaggedSymbol)
+        EXPIRED = T.let(:expired, ModernTreasury::Models::PaymentFlow::Status::TaggedSymbol)
+        PENDING = T.let(:pending, ModernTreasury::Models::PaymentFlow::Status::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::PaymentFlow::Status::TaggedSymbol]) }
+        def self.values; end
       end
     end
   end

data/rbi/lib/modern_treasury/models/payment_flow_create_params.rbi

@@ -2,71 +2,55 @@
 
 module ModernTreasury
   module Models
-    class PaymentFlowCreateParams < ModernTreasury::BaseModel
-      extend ModernTreasury::RequestParameters::Converter
-      include ModernTreasury::RequestParameters
+    class PaymentFlowCreateParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::RequestParameters
 
+      # Required. Value in specified currency's smallest unit. e.g. $10 would be
+      # represented as 1000. Can be any integer up to 36 digits.
       sig { returns(Integer) }
-      def amount
-      end
-
-      sig { params(_: Integer).returns(Integer) }
-      def amount=(_)
-      end
+      attr_accessor :amount
 
+      # Required. The ID of a counterparty associated with the payment. As part of the
+      # payment workflow an external account will be associated with this model.
       sig { returns(String) }
-      def counterparty_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def counterparty_id=(_)
-      end
+      attr_accessor :counterparty_id
 
+      # Required. The currency of the payment.
       sig { returns(String) }
-      def currency
-      end
+      attr_accessor :currency
 
-      sig { params(_: String).returns(String) }
-      def currency=(_)
-      end
-
-      sig { returns(Symbol) }
-      def direction
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def direction=(_)
-      end
+      # Required. Describes the direction money is flowing in the transaction. Can only
+      # be `debit`. A `debit` pulls money from someone else's account to your own.
+      sig { returns(ModernTreasury::Models::PaymentFlowCreateParams::Direction::OrSymbol) }
+      attr_accessor :direction
 
+      # Required. The ID of one of your organization's internal accounts.
       sig { returns(String) }
-      def originating_account_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def originating_account_id=(_)
-      end
+      attr_accessor :originating_account_id
 
+      # Optional. Can only be passed in when `effective_date_selection_enabled` is
+      # `true`. When set, the due date is shown to your end-user in the pre-built UI as
+      # they are selecting a payment `effective_date`.
       sig { returns(T.nilable(Date)) }
-      def due_date
-      end
+      attr_reader :due_date
 
-      sig { params(_: Date).returns(Date) }
-      def due_date=(_)
-      end
+      sig { params(due_date: Date).void }
+      attr_writer :due_date
 
       sig do
         params(
           amount: Integer,
           counterparty_id: String,
           currency: String,
-          direction: Symbol,
+          direction: ModernTreasury::Models::PaymentFlowCreateParams::Direction::OrSymbol,
           originating_account_id: String,
           due_date: Date,
-          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(
         amount:,
         counterparty_id:,
         currency:,
@@ -74,9 +58,7 @@ module ModernTreasury
         originating_account_id:,
         due_date: nil,
         request_options: {}
-      )
-      end
-
+      ); end
       sig do
         override
           .returns(
@@ -84,25 +66,29 @@ module ModernTreasury
               amount: Integer,
               counterparty_id: String,
               currency: String,
-              direction: Symbol,
+              direction: ModernTreasury::Models::PaymentFlowCreateParams::Direction::OrSymbol,
               originating_account_id: String,
               due_date: Date,
               request_options: ModernTreasury::RequestOptions
             }
           )
       end
-      def to_hash
-      end
+      def to_hash; end
+
+      # Required. Describes the direction money is flowing in the transaction. Can only
+      # be `debit`. A `debit` pulls money from someone else's account to your own.
+      module Direction
+        extend ModernTreasury::Internal::Type::Enum
 
-      class Direction < ModernTreasury::Enum
-        abstract!
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::PaymentFlowCreateParams::Direction) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, ModernTreasury::Models::PaymentFlowCreateParams::Direction::TaggedSymbol) }
 
-        CREDIT = :credit
-        DEBIT = :debit
+        CREDIT = T.let(:credit, ModernTreasury::Models::PaymentFlowCreateParams::Direction::TaggedSymbol)
+        DEBIT = T.let(:debit, ModernTreasury::Models::PaymentFlowCreateParams::Direction::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
-        end
+        sig { override.returns(T::Array[ModernTreasury::Models::PaymentFlowCreateParams::Direction::TaggedSymbol]) }
+        def self.values; end
       end
     end
   end