finch-api 0.1.0.pre.alpha.13 → 0.1.0.pre.alpha.14

data/rbi/finch_api/models/jobs/manual_async_job.rbi

@@ -4,6 +4,9 @@ module FinchAPI
   module Models
     module Jobs
       class ManualAsyncJob < FinchAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
         # Specific information about the job, such as individual statuses for batch jobs.
         sig { returns(T.nilable(T::Array[T.anything])) }
         attr_accessor :body
@@ -11,48 +14,70 @@ module FinchAPI
         sig { returns(String) }
         attr_accessor :job_id
 
-        sig { returns(FinchAPI::Models::Jobs::ManualAsyncJob::Status::TaggedSymbol) }
+        sig { returns(FinchAPI::Jobs::ManualAsyncJob::Status::TaggedSymbol) }
         attr_accessor :status
 
         sig do
           params(
             body: T.nilable(T::Array[T.anything]),
             job_id: String,
-            status: FinchAPI::Models::Jobs::ManualAsyncJob::Status::OrSymbol
-          )
-            .returns(T.attached_class)
+            status: FinchAPI::Jobs::ManualAsyncJob::Status::OrSymbol
+          ).returns(T.attached_class)
         end
         def self.new(
           # Specific information about the job, such as individual statuses for batch jobs.
           body:,
           job_id:,
           status:
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                body: T.nilable(T::Array[T.anything]),
-                job_id: String,
-                status: FinchAPI::Models::Jobs::ManualAsyncJob::Status::TaggedSymbol
-              }
-            )
+          override.returns(
+            {
+              body: T.nilable(T::Array[T.anything]),
+              job_id: String,
+              status: FinchAPI::Jobs::ManualAsyncJob::Status::TaggedSymbol
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
 
         module Status
           extend FinchAPI::Internal::Type::Enum
 
-          TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::Jobs::ManualAsyncJob::Status) }
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, FinchAPI::Jobs::ManualAsyncJob::Status)
+            end
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-          PENDING = T.let(:pending, FinchAPI::Models::Jobs::ManualAsyncJob::Status::TaggedSymbol)
-          IN_PROGRESS = T.let(:in_progress, FinchAPI::Models::Jobs::ManualAsyncJob::Status::TaggedSymbol)
-          ERROR = T.let(:error, FinchAPI::Models::Jobs::ManualAsyncJob::Status::TaggedSymbol)
-          COMPLETE = T.let(:complete, FinchAPI::Models::Jobs::ManualAsyncJob::Status::TaggedSymbol)
+          PENDING =
+            T.let(
+              :pending,
+              FinchAPI::Jobs::ManualAsyncJob::Status::TaggedSymbol
+            )
+          IN_PROGRESS =
+            T.let(
+              :in_progress,
+              FinchAPI::Jobs::ManualAsyncJob::Status::TaggedSymbol
+            )
+          ERROR =
+            T.let(:error, FinchAPI::Jobs::ManualAsyncJob::Status::TaggedSymbol)
+          COMPLETE =
+            T.let(
+              :complete,
+              FinchAPI::Jobs::ManualAsyncJob::Status::TaggedSymbol
+            )
 
-          sig { override.returns(T::Array[FinchAPI::Models::Jobs::ManualAsyncJob::Status::TaggedSymbol]) }
-          def self.values; end
+          sig do
+            override.returns(
+              T::Array[FinchAPI::Jobs::ManualAsyncJob::Status::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
         end
       end
     end

data/rbi/finch_api/models/jobs/manual_retrieve_params.rbi

@@ -7,14 +7,20 @@ module FinchAPI
         extend FinchAPI::Internal::Type::RequestParameters::Converter
         include FinchAPI::Internal::Type::RequestParameters
 
+        OrHash =
+          T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
         sig do
-          params(request_options: T.any(FinchAPI::RequestOptions, FinchAPI::Internal::AnyHash))
-            .returns(T.attached_class)
+          params(request_options: FinchAPI::RequestOptions::OrHash).returns(
+            T.attached_class
+          )
+        end
+        def self.new(request_options: {})
         end
-        def self.new(request_options: {}); end
 
-        sig { override.returns({request_options: FinchAPI::RequestOptions}) }
-        def to_hash; end
+        sig { override.returns({ request_options: FinchAPI::RequestOptions }) }
+        def to_hash
+        end
       end
     end
   end

data/rbi/finch_api/models/location.rbi

@@ -3,6 +3,8 @@
 module FinchAPI
   module Models
     class Location < FinchAPI::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
       # City, district, suburb, town, or village.
       sig { returns(T.nilable(String)) }
       attr_accessor :city
@@ -43,8 +45,7 @@ module FinchAPI
           state: T.nilable(String),
           name: T.nilable(String),
           source_id: T.nilable(String)
-        )
-          .returns(T.attached_class)
+        ).returns(T.attached_class)
       end
       def self.new(
         # City, district, suburb, town, or village.
@@ -61,23 +62,25 @@ module FinchAPI
         state:,
         name: nil,
         source_id: nil
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              city: T.nilable(String),
-              country: T.nilable(String),
-              line1: T.nilable(String),
-              line2: T.nilable(String),
-              postal_code: T.nilable(String),
-              state: T.nilable(String),
-              name: T.nilable(String),
-              source_id: T.nilable(String)
-            }
-          )
+        override.returns(
+          {
+            city: T.nilable(String),
+            country: T.nilable(String),
+            line1: T.nilable(String),
+            line2: T.nilable(String),
+            postal_code: T.nilable(String),
+            state: T.nilable(String),
+            name: T.nilable(String),
+            source_id: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
     end
   end
 end

data/rbi/finch_api/models/money.rbi

@@ -3,6 +3,8 @@
 module FinchAPI
   module Models
     class Money < FinchAPI::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
       # Amount for money object (in cents)
       sig { returns(T.nilable(Integer)) }
       attr_accessor :amount
@@ -13,14 +15,21 @@ module FinchAPI
       sig { params(currency: String).void }
       attr_writer :currency
 
-      sig { params(amount: T.nilable(Integer), currency: String).returns(T.attached_class) }
+      sig do
+        params(amount: T.nilable(Integer), currency: String).returns(
+          T.attached_class
+        )
+      end
       def self.new(
         # Amount for money object (in cents)
         amount: nil,
         currency: nil
-      ); end
-      sig { override.returns({amount: T.nilable(Integer), currency: String}) }
-      def to_hash; end
+      )
+      end
+
+      sig { override.returns({ amount: T.nilable(Integer), currency: String }) }
+      def to_hash
+      end
     end
   end
 end

data/rbi/finch_api/models/operation_support.rbi

@@ -12,17 +12,25 @@ module FinchAPI
     module OperationSupport
       extend FinchAPI::Internal::Type::Enum
 
-      TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::OperationSupport) }
+      TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::OperationSupport) }
       OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-      SUPPORTED = T.let(:supported, FinchAPI::Models::OperationSupport::TaggedSymbol)
-      NOT_SUPPORTED_BY_FINCH = T.let(:not_supported_by_finch, FinchAPI::Models::OperationSupport::TaggedSymbol)
+      SUPPORTED = T.let(:supported, FinchAPI::OperationSupport::TaggedSymbol)
+      NOT_SUPPORTED_BY_FINCH =
+        T.let(:not_supported_by_finch, FinchAPI::OperationSupport::TaggedSymbol)
       NOT_SUPPORTED_BY_PROVIDER =
-        T.let(:not_supported_by_provider, FinchAPI::Models::OperationSupport::TaggedSymbol)
-      CLIENT_ACCESS_ONLY = T.let(:client_access_only, FinchAPI::Models::OperationSupport::TaggedSymbol)
+        T.let(
+          :not_supported_by_provider,
+          FinchAPI::OperationSupport::TaggedSymbol
+        )
+      CLIENT_ACCESS_ONLY =
+        T.let(:client_access_only, FinchAPI::OperationSupport::TaggedSymbol)
 
-      sig { override.returns(T::Array[FinchAPI::Models::OperationSupport::TaggedSymbol]) }
-      def self.values; end
+      sig do
+        override.returns(T::Array[FinchAPI::OperationSupport::TaggedSymbol])
+      end
+      def self.values
+      end
     end
   end
 end

data/rbi/finch_api/models/operation_support_matrix.rbi

@@ -3,6 +3,8 @@
 module FinchAPI
   module Models
     class OperationSupportMatrix < FinchAPI::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
       # - `supported`: This operation is supported by both the provider and Finch
       # - `not_supported_by_finch`: This operation is not supported by Finch but
       #   supported by the provider
@@ -10,10 +12,10 @@ module FinchAPI
       #   so Finch cannot support
       # - `client_access_only`: This behavior is supported by the provider, but only
       #   available to the client and not to Finch
-      sig { returns(T.nilable(FinchAPI::Models::OperationSupport::TaggedSymbol)) }
+      sig { returns(T.nilable(FinchAPI::OperationSupport::TaggedSymbol)) }
       attr_reader :create
 
-      sig { params(create: FinchAPI::Models::OperationSupport::OrSymbol).void }
+      sig { params(create: FinchAPI::OperationSupport::OrSymbol).void }
       attr_writer :create
 
       # - `supported`: This operation is supported by both the provider and Finch
@@ -23,10 +25,10 @@ module FinchAPI
       #   so Finch cannot support
       # - `client_access_only`: This behavior is supported by the provider, but only
       #   available to the client and not to Finch
-      sig { returns(T.nilable(FinchAPI::Models::OperationSupport::TaggedSymbol)) }
+      sig { returns(T.nilable(FinchAPI::OperationSupport::TaggedSymbol)) }
       attr_reader :delete
 
-      sig { params(delete: FinchAPI::Models::OperationSupport::OrSymbol).void }
+      sig { params(delete: FinchAPI::OperationSupport::OrSymbol).void }
       attr_writer :delete
 
       # - `supported`: This operation is supported by both the provider and Finch
@@ -36,10 +38,10 @@ module FinchAPI
       #   so Finch cannot support
       # - `client_access_only`: This behavior is supported by the provider, but only
       #   available to the client and not to Finch
-      sig { returns(T.nilable(FinchAPI::Models::OperationSupport::TaggedSymbol)) }
+      sig { returns(T.nilable(FinchAPI::OperationSupport::TaggedSymbol)) }
       attr_reader :read
 
-      sig { params(read: FinchAPI::Models::OperationSupport::OrSymbol).void }
+      sig { params(read: FinchAPI::OperationSupport::OrSymbol).void }
       attr_writer :read
 
       # - `supported`: This operation is supported by both the provider and Finch
@@ -49,20 +51,19 @@ module FinchAPI
       #   so Finch cannot support
       # - `client_access_only`: This behavior is supported by the provider, but only
       #   available to the client and not to Finch
-      sig { returns(T.nilable(FinchAPI::Models::OperationSupport::TaggedSymbol)) }
+      sig { returns(T.nilable(FinchAPI::OperationSupport::TaggedSymbol)) }
       attr_reader :update
 
-      sig { params(update: FinchAPI::Models::OperationSupport::OrSymbol).void }
+      sig { params(update: FinchAPI::OperationSupport::OrSymbol).void }
       attr_writer :update
 
       sig do
         params(
-          create: FinchAPI::Models::OperationSupport::OrSymbol,
-          delete: FinchAPI::Models::OperationSupport::OrSymbol,
-          read: FinchAPI::Models::OperationSupport::OrSymbol,
-          update: FinchAPI::Models::OperationSupport::OrSymbol
-        )
-          .returns(T.attached_class)
+          create: FinchAPI::OperationSupport::OrSymbol,
+          delete: FinchAPI::OperationSupport::OrSymbol,
+          read: FinchAPI::OperationSupport::OrSymbol,
+          update: FinchAPI::OperationSupport::OrSymbol
+        ).returns(T.attached_class)
       end
       def self.new(
         # - `supported`: This operation is supported by both the provider and Finch
@@ -97,19 +98,21 @@ module FinchAPI
         # - `client_access_only`: This behavior is supported by the provider, but only
         #   available to the client and not to Finch
         update: nil
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              create: FinchAPI::Models::OperationSupport::TaggedSymbol,
-              delete: FinchAPI::Models::OperationSupport::TaggedSymbol,
-              read: FinchAPI::Models::OperationSupport::TaggedSymbol,
-              update: FinchAPI::Models::OperationSupport::TaggedSymbol
-            }
-          )
+        override.returns(
+          {
+            create: FinchAPI::OperationSupport::TaggedSymbol,
+            delete: FinchAPI::OperationSupport::TaggedSymbol,
+            read: FinchAPI::OperationSupport::TaggedSymbol,
+            update: FinchAPI::OperationSupport::TaggedSymbol
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
     end
   end
 end

data/rbi/finch_api/models/paging.rbi

@@ -3,6 +3,8 @@
 module FinchAPI
   module Models
     class Paging < FinchAPI::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
       # The current start index of the returned list of elements
       sig { returns(Integer) }
       attr_accessor :offset
@@ -20,9 +22,12 @@ module FinchAPI
         offset:,
         # The total number of elements for the entire query (not just the given page)
         count: nil
-      ); end
-      sig { override.returns({offset: Integer, count: Integer}) }
-      def to_hash; end
+      )
+      end
+
+      sig { override.returns({ offset: Integer, count: Integer }) }
+      def to_hash
+      end
     end
   end
 end

data/rbi/finch_api/models/pay_statement_event.rbi

@@ -3,39 +3,50 @@
 module FinchAPI
   module Models
     class PayStatementEvent < FinchAPI::Models::BaseWebhookEvent
-      sig { returns(T.nilable(FinchAPI::Models::PayStatementEvent::Data)) }
+      OrHash = T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
+      sig { returns(T.nilable(FinchAPI::PayStatementEvent::Data)) }
       attr_reader :data
 
-      sig { params(data: T.any(FinchAPI::Models::PayStatementEvent::Data, FinchAPI::Internal::AnyHash)).void }
+      sig { params(data: FinchAPI::PayStatementEvent::Data::OrHash).void }
       attr_writer :data
 
-      sig { returns(T.nilable(FinchAPI::Models::PayStatementEvent::EventType::TaggedSymbol)) }
+      sig do
+        returns(T.nilable(FinchAPI::PayStatementEvent::EventType::TaggedSymbol))
+      end
       attr_reader :event_type
 
-      sig { params(event_type: FinchAPI::Models::PayStatementEvent::EventType::OrSymbol).void }
+      sig do
+        params(
+          event_type: FinchAPI::PayStatementEvent::EventType::OrSymbol
+        ).void
+      end
       attr_writer :event_type
 
       sig do
         params(
-          data: T.any(FinchAPI::Models::PayStatementEvent::Data, FinchAPI::Internal::AnyHash),
-          event_type: FinchAPI::Models::PayStatementEvent::EventType::OrSymbol
-        )
-          .returns(T.attached_class)
+          data: FinchAPI::PayStatementEvent::Data::OrHash,
+          event_type: FinchAPI::PayStatementEvent::EventType::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(data: nil, event_type: nil)
       end
-      def self.new(data: nil, event_type: nil); end
 
       sig do
-        override
-          .returns(
-            {
-              data: FinchAPI::Models::PayStatementEvent::Data,
-              event_type: FinchAPI::Models::PayStatementEvent::EventType::TaggedSymbol
-            }
-          )
+        override.returns(
+          {
+            data: FinchAPI::PayStatementEvent::Data,
+            event_type: FinchAPI::PayStatementEvent::EventType::TaggedSymbol
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       class Data < FinchAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
         # The ID of the individual associated with the pay statement.
         sig { returns(T.nilable(String)) }
         attr_reader :individual_id
@@ -50,32 +61,54 @@ module FinchAPI
         sig { params(payment_id: String).void }
         attr_writer :payment_id
 
-        sig { params(individual_id: String, payment_id: String).returns(T.attached_class) }
+        sig do
+          params(individual_id: String, payment_id: String).returns(
+            T.attached_class
+          )
+        end
         def self.new(
           # The ID of the individual associated with the pay statement.
           individual_id: nil,
           # The ID of the payment associated with the pay statement.
           payment_id: nil
-        ); end
-        sig { override.returns({individual_id: String, payment_id: String}) }
-        def to_hash; end
+        )
+        end
+
+        sig { override.returns({ individual_id: String, payment_id: String }) }
+        def to_hash
+        end
       end
 
       module EventType
         extend FinchAPI::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::PayStatementEvent::EventType) }
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, FinchAPI::PayStatementEvent::EventType) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
         PAY_STATEMENT_CREATED =
-          T.let(:"pay_statement.created", FinchAPI::Models::PayStatementEvent::EventType::TaggedSymbol)
+          T.let(
+            :"pay_statement.created",
+            FinchAPI::PayStatementEvent::EventType::TaggedSymbol
+          )
         PAY_STATEMENT_UPDATED =
-          T.let(:"pay_statement.updated", FinchAPI::Models::PayStatementEvent::EventType::TaggedSymbol)
+          T.let(
+            :"pay_statement.updated",
+            FinchAPI::PayStatementEvent::EventType::TaggedSymbol
+          )
         PAY_STATEMENT_DELETED =
-          T.let(:"pay_statement.deleted", FinchAPI::Models::PayStatementEvent::EventType::TaggedSymbol)
+          T.let(
+            :"pay_statement.deleted",
+            FinchAPI::PayStatementEvent::EventType::TaggedSymbol
+          )
 
-        sig { override.returns(T::Array[FinchAPI::Models::PayStatementEvent::EventType::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[FinchAPI::PayStatementEvent::EventType::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
       end
     end
   end

data/rbi/finch_api/models/payment_event.rbi

@@ -3,39 +3,48 @@
 module FinchAPI
   module Models
     class PaymentEvent < FinchAPI::Models::BaseWebhookEvent
-      sig { returns(T.nilable(FinchAPI::Models::PaymentEvent::Data)) }
+      OrHash = T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
+      sig { returns(T.nilable(FinchAPI::PaymentEvent::Data)) }
       attr_reader :data
 
-      sig { params(data: T.any(FinchAPI::Models::PaymentEvent::Data, FinchAPI::Internal::AnyHash)).void }
+      sig { params(data: FinchAPI::PaymentEvent::Data::OrHash).void }
       attr_writer :data
 
-      sig { returns(T.nilable(FinchAPI::Models::PaymentEvent::EventType::TaggedSymbol)) }
+      sig do
+        returns(T.nilable(FinchAPI::PaymentEvent::EventType::TaggedSymbol))
+      end
       attr_reader :event_type
 
-      sig { params(event_type: FinchAPI::Models::PaymentEvent::EventType::OrSymbol).void }
+      sig do
+        params(event_type: FinchAPI::PaymentEvent::EventType::OrSymbol).void
+      end
       attr_writer :event_type
 
       sig do
         params(
-          data: T.any(FinchAPI::Models::PaymentEvent::Data, FinchAPI::Internal::AnyHash),
-          event_type: FinchAPI::Models::PaymentEvent::EventType::OrSymbol
-        )
-          .returns(T.attached_class)
+          data: FinchAPI::PaymentEvent::Data::OrHash,
+          event_type: FinchAPI::PaymentEvent::EventType::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(data: nil, event_type: nil)
       end
-      def self.new(data: nil, event_type: nil); end
 
       sig do
-        override
-          .returns(
-            {
-              data: FinchAPI::Models::PaymentEvent::Data,
-              event_type: FinchAPI::Models::PaymentEvent::EventType::TaggedSymbol
-            }
-          )
+        override.returns(
+          {
+            data: FinchAPI::PaymentEvent::Data,
+            event_type: FinchAPI::PaymentEvent::EventType::TaggedSymbol
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       class Data < FinchAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
         # The date of the payment.
         sig { returns(String) }
         attr_accessor :pay_date
@@ -44,29 +53,52 @@ module FinchAPI
         sig { returns(String) }
         attr_accessor :payment_id
 
-        sig { params(pay_date: String, payment_id: String).returns(T.attached_class) }
+        sig do
+          params(pay_date: String, payment_id: String).returns(T.attached_class)
+        end
         def self.new(
           # The date of the payment.
           pay_date:,
           # The ID of the payment.
           payment_id:
-        ); end
-        sig { override.returns({pay_date: String, payment_id: String}) }
-        def to_hash; end
+        )
+        end
+
+        sig { override.returns({ pay_date: String, payment_id: String }) }
+        def to_hash
+        end
       end
 
       module EventType
         extend FinchAPI::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::PaymentEvent::EventType) }
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, FinchAPI::PaymentEvent::EventType) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        PAYMENT_CREATED = T.let(:"payment.created", FinchAPI::Models::PaymentEvent::EventType::TaggedSymbol)
-        PAYMENT_UPDATED = T.let(:"payment.updated", FinchAPI::Models::PaymentEvent::EventType::TaggedSymbol)
-        PAYMENT_DELETED = T.let(:"payment.deleted", FinchAPI::Models::PaymentEvent::EventType::TaggedSymbol)
+        PAYMENT_CREATED =
+          T.let(
+            :"payment.created",
+            FinchAPI::PaymentEvent::EventType::TaggedSymbol
+          )
+        PAYMENT_UPDATED =
+          T.let(
+            :"payment.updated",
+            FinchAPI::PaymentEvent::EventType::TaggedSymbol
+          )
+        PAYMENT_DELETED =
+          T.let(
+            :"payment.deleted",
+            FinchAPI::PaymentEvent::EventType::TaggedSymbol
+          )
 
-        sig { override.returns(T::Array[FinchAPI::Models::PaymentEvent::EventType::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[FinchAPI::PaymentEvent::EventType::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
       end
     end
   end