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

data/rbi/finch_api/models/jobs/automated_async_job.rbi

@@ -4,6 +4,9 @@ module FinchAPI
   module Models
     module Jobs
       class AutomatedAsyncJob < FinchAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
         # The datetime the job completed.
         sig { returns(T.nilable(Time)) }
         attr_accessor :completed_at
@@ -23,14 +26,13 @@ module FinchAPI
         attr_accessor :job_url
 
         # The input parameters for the job.
-        sig { returns(T.nilable(FinchAPI::Models::Jobs::AutomatedAsyncJob::Params)) }
+        sig { returns(T.nilable(FinchAPI::Jobs::AutomatedAsyncJob::Params)) }
         attr_reader :params
 
         sig do
           params(
-            params: T.nilable(T.any(FinchAPI::Models::Jobs::AutomatedAsyncJob::Params, FinchAPI::Internal::AnyHash))
-          )
-            .void
+            params: T.nilable(FinchAPI::Jobs::AutomatedAsyncJob::Params::OrHash)
+          ).void
         end
         attr_writer :params
 
@@ -44,11 +46,11 @@ module FinchAPI
         sig { returns(T.nilable(Time)) }
         attr_accessor :started_at
 
-        sig { returns(FinchAPI::Models::Jobs::AutomatedAsyncJob::Status::TaggedSymbol) }
+        sig { returns(FinchAPI::Jobs::AutomatedAsyncJob::Status::TaggedSymbol) }
         attr_accessor :status
 
         # The type of automated job
-        sig { returns(FinchAPI::Models::Jobs::AutomatedAsyncJob::Type::TaggedSymbol) }
+        sig { returns(FinchAPI::Jobs::AutomatedAsyncJob::Type::TaggedSymbol) }
         attr_accessor :type
 
         sig do
@@ -57,13 +59,13 @@ module FinchAPI
             created_at: Time,
             job_id: String,
             job_url: String,
-            params: T.nilable(T.any(FinchAPI::Models::Jobs::AutomatedAsyncJob::Params, FinchAPI::Internal::AnyHash)),
+            params:
+              T.nilable(FinchAPI::Jobs::AutomatedAsyncJob::Params::OrHash),
             scheduled_at: T.nilable(Time),
             started_at: T.nilable(Time),
-            status: FinchAPI::Models::Jobs::AutomatedAsyncJob::Status::OrSymbol,
-            type: FinchAPI::Models::Jobs::AutomatedAsyncJob::Type::OrSymbol
-          )
-            .returns(T.attached_class)
+            status: FinchAPI::Jobs::AutomatedAsyncJob::Status::OrSymbol,
+            type: FinchAPI::Jobs::AutomatedAsyncJob::Type::OrSymbol
+          ).returns(T.attached_class)
         end
         def self.new(
           # The datetime the job completed.
@@ -87,26 +89,31 @@ module FinchAPI
           status:,
           # The type of automated job
           type:
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                completed_at: T.nilable(Time),
-                created_at: Time,
-                job_id: String,
-                job_url: String,
-                params: T.nilable(FinchAPI::Models::Jobs::AutomatedAsyncJob::Params),
-                scheduled_at: T.nilable(Time),
-                started_at: T.nilable(Time),
-                status: FinchAPI::Models::Jobs::AutomatedAsyncJob::Status::TaggedSymbol,
-                type: FinchAPI::Models::Jobs::AutomatedAsyncJob::Type::TaggedSymbol
-              }
-            )
+          override.returns(
+            {
+              completed_at: T.nilable(Time),
+              created_at: Time,
+              job_id: String,
+              job_url: String,
+              params: T.nilable(FinchAPI::Jobs::AutomatedAsyncJob::Params),
+              scheduled_at: T.nilable(Time),
+              started_at: T.nilable(Time),
+              status: FinchAPI::Jobs::AutomatedAsyncJob::Status::TaggedSymbol,
+              type: FinchAPI::Jobs::AutomatedAsyncJob::Type::TaggedSymbol
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
 
         class Params < FinchAPI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
           # The ID of the individual that the job was completed for.
           sig { returns(T.nilable(String)) }
           attr_reader :individual_id
@@ -119,42 +126,91 @@ module FinchAPI
           def self.new(
             # The ID of the individual that the job was completed for.
             individual_id: nil
-          ); end
-          sig { override.returns({individual_id: String}) }
-          def to_hash; end
+          )
+          end
+
+          sig { override.returns({ individual_id: String }) }
+          def to_hash
+          end
         end
 
         module Status
           extend FinchAPI::Internal::Type::Enum
 
-          TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::Jobs::AutomatedAsyncJob::Status) }
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, FinchAPI::Jobs::AutomatedAsyncJob::Status)
+            end
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-          PENDING = T.let(:pending, FinchAPI::Models::Jobs::AutomatedAsyncJob::Status::TaggedSymbol)
-          IN_PROGRESS = T.let(:in_progress, FinchAPI::Models::Jobs::AutomatedAsyncJob::Status::TaggedSymbol)
-          COMPLETE = T.let(:complete, FinchAPI::Models::Jobs::AutomatedAsyncJob::Status::TaggedSymbol)
-          ERROR = T.let(:error, FinchAPI::Models::Jobs::AutomatedAsyncJob::Status::TaggedSymbol)
-          REAUTH_ERROR = T.let(:reauth_error, FinchAPI::Models::Jobs::AutomatedAsyncJob::Status::TaggedSymbol)
+          PENDING =
+            T.let(
+              :pending,
+              FinchAPI::Jobs::AutomatedAsyncJob::Status::TaggedSymbol
+            )
+          IN_PROGRESS =
+            T.let(
+              :in_progress,
+              FinchAPI::Jobs::AutomatedAsyncJob::Status::TaggedSymbol
+            )
+          COMPLETE =
+            T.let(
+              :complete,
+              FinchAPI::Jobs::AutomatedAsyncJob::Status::TaggedSymbol
+            )
+          ERROR =
+            T.let(
+              :error,
+              FinchAPI::Jobs::AutomatedAsyncJob::Status::TaggedSymbol
+            )
+          REAUTH_ERROR =
+            T.let(
+              :reauth_error,
+              FinchAPI::Jobs::AutomatedAsyncJob::Status::TaggedSymbol
+            )
           PERMISSIONS_ERROR =
-            T.let(:permissions_error, FinchAPI::Models::Jobs::AutomatedAsyncJob::Status::TaggedSymbol)
+            T.let(
+              :permissions_error,
+              FinchAPI::Jobs::AutomatedAsyncJob::Status::TaggedSymbol
+            )
 
-          sig { override.returns(T::Array[FinchAPI::Models::Jobs::AutomatedAsyncJob::Status::TaggedSymbol]) }
-          def self.values; end
+          sig do
+            override.returns(
+              T::Array[FinchAPI::Jobs::AutomatedAsyncJob::Status::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
         end
 
         # The type of automated job
         module Type
           extend FinchAPI::Internal::Type::Enum
 
-          TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::Jobs::AutomatedAsyncJob::Type) }
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, FinchAPI::Jobs::AutomatedAsyncJob::Type)
+            end
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-          DATA_SYNC_ALL = T.let(:data_sync_all, FinchAPI::Models::Jobs::AutomatedAsyncJob::Type::TaggedSymbol)
+          DATA_SYNC_ALL =
+            T.let(
+              :data_sync_all,
+              FinchAPI::Jobs::AutomatedAsyncJob::Type::TaggedSymbol
+            )
           W4_FORM_EMPLOYEE_SYNC =
-            T.let(:w4_form_employee_sync, FinchAPI::Models::Jobs::AutomatedAsyncJob::Type::TaggedSymbol)
+            T.let(
+              :w4_form_employee_sync,
+              FinchAPI::Jobs::AutomatedAsyncJob::Type::TaggedSymbol
+            )
 
-          sig { override.returns(T::Array[FinchAPI::Models::Jobs::AutomatedAsyncJob::Type::TaggedSymbol]) }
-          def self.values; end
+          sig do
+            override.returns(
+              T::Array[FinchAPI::Jobs::AutomatedAsyncJob::Type::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
         end
       end
     end

data/rbi/finch_api/models/jobs/automated_create_params.rbi

@@ -7,60 +7,81 @@ 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) }
+
         # The type of job to start.
-        sig { returns(FinchAPI::Models::Jobs::AutomatedCreateParams::Type::OrSymbol) }
+        sig { returns(FinchAPI::Jobs::AutomatedCreateParams::Type::OrSymbol) }
         attr_accessor :type
 
-        sig { returns(FinchAPI::Models::Jobs::AutomatedCreateParams::Params) }
+        sig { returns(FinchAPI::Jobs::AutomatedCreateParams::Params) }
         attr_reader :params
 
         sig do
-          params(params: T.any(FinchAPI::Models::Jobs::AutomatedCreateParams::Params, FinchAPI::Internal::AnyHash))
-            .void
+          params(
+            params: FinchAPI::Jobs::AutomatedCreateParams::Params::OrHash
+          ).void
         end
         attr_writer :params
 
         sig do
           params(
-            type: FinchAPI::Models::Jobs::AutomatedCreateParams::Type::OrSymbol,
-            params: T.any(FinchAPI::Models::Jobs::AutomatedCreateParams::Params, FinchAPI::Internal::AnyHash),
-            request_options: T.any(FinchAPI::RequestOptions, FinchAPI::Internal::AnyHash)
-          )
-            .returns(T.attached_class)
+            type: FinchAPI::Jobs::AutomatedCreateParams::Type::OrSymbol,
+            params: FinchAPI::Jobs::AutomatedCreateParams::Params::OrHash,
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(T.attached_class)
         end
         def self.new(
           # The type of job to start.
           type:,
           params:,
           request_options: {}
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                type: FinchAPI::Models::Jobs::AutomatedCreateParams::Type::OrSymbol,
-                params: FinchAPI::Models::Jobs::AutomatedCreateParams::Params,
-                request_options: FinchAPI::RequestOptions
-              }
-            )
+          override.returns(
+            {
+              type: FinchAPI::Jobs::AutomatedCreateParams::Type::OrSymbol,
+              params: FinchAPI::Jobs::AutomatedCreateParams::Params,
+              request_options: FinchAPI::RequestOptions
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
 
         # The type of job to start.
         module Type
           extend FinchAPI::Internal::Type::Enum
 
-          TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::Jobs::AutomatedCreateParams::Type) }
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, FinchAPI::Jobs::AutomatedCreateParams::Type)
+            end
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
           W4_FORM_EMPLOYEE_SYNC =
-            T.let(:w4_form_employee_sync, FinchAPI::Models::Jobs::AutomatedCreateParams::Type::TaggedSymbol)
+            T.let(
+              :w4_form_employee_sync,
+              FinchAPI::Jobs::AutomatedCreateParams::Type::TaggedSymbol
+            )
 
-          sig { override.returns(T::Array[FinchAPI::Models::Jobs::AutomatedCreateParams::Type::TaggedSymbol]) }
-          def self.values; end
+          sig do
+            override.returns(
+              T::Array[
+                FinchAPI::Jobs::AutomatedCreateParams::Type::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
         end
 
         class Params < FinchAPI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
           # The unique ID of the individual for W-4 data sync.
           sig { returns(String) }
           attr_accessor :individual_id
@@ -69,9 +90,12 @@ module FinchAPI
           def self.new(
             # The unique ID of the individual for W-4 data sync.
             individual_id:
-          ); end
-          sig { override.returns({individual_id: String}) }
-          def to_hash; end
+          )
+          end
+
+          sig { override.returns({ individual_id: String }) }
+          def to_hash
+          end
         end
       end
     end

data/rbi/finch_api/models/jobs/automated_create_response.rbi

@@ -4,6 +4,9 @@ module FinchAPI
   module Models
     module Jobs
       class AutomatedCreateResponse < FinchAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
         # The number of allowed refreshes per hour (per hour, fixed window)
         sig { returns(Integer) }
         attr_accessor :allowed_refreshes
@@ -21,8 +24,12 @@ module FinchAPI
         attr_accessor :remaining_refreshes
 
         sig do
-          params(allowed_refreshes: Integer, job_id: String, job_url: String, remaining_refreshes: Integer)
-            .returns(T.attached_class)
+          params(
+            allowed_refreshes: Integer,
+            job_id: String,
+            job_url: String,
+            remaining_refreshes: Integer
+          ).returns(T.attached_class)
         end
         def self.new(
           # The number of allowed refreshes per hour (per hour, fixed window)
@@ -33,17 +40,21 @@ module FinchAPI
           job_url:,
           # The number of remaining refreshes available (per hour, fixed window)
           remaining_refreshes:
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns({
-                       allowed_refreshes: Integer,
-                       job_id: String,
-                       job_url: String,
-                       remaining_refreshes: Integer
-                     })
+          override.returns(
+            {
+              allowed_refreshes: Integer,
+              job_id: String,
+              job_url: String,
+              remaining_refreshes: Integer
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
       end
     end
   end

data/rbi/finch_api/models/jobs/automated_list_params.rbi

@@ -7,6 +7,9 @@ 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) }
+
         # Number of items to return
         sig { returns(T.nilable(Integer)) }
         attr_reader :limit
@@ -25,9 +28,8 @@ module FinchAPI
           params(
             limit: Integer,
             offset: Integer,
-            request_options: T.any(FinchAPI::RequestOptions, FinchAPI::Internal::AnyHash)
-          )
-            .returns(T.attached_class)
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(T.attached_class)
         end
         def self.new(
           # Number of items to return
@@ -35,9 +37,20 @@ module FinchAPI
           # Index to start from (defaults to 0)
           offset: nil,
           request_options: {}
-        ); end
-        sig { override.returns({limit: Integer, offset: Integer, request_options: FinchAPI::RequestOptions}) }
-        def to_hash; end
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              limit: Integer,
+              offset: Integer,
+              request_options: FinchAPI::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
       end
     end
   end

data/rbi/finch_api/models/jobs/automated_list_response.rbi

@@ -4,56 +4,72 @@ module FinchAPI
   module Models
     module Jobs
       class AutomatedListResponse < FinchAPI::Internal::Type::BaseModel
-        sig { returns(T::Array[FinchAPI::Models::Jobs::AutomatedAsyncJob]) }
+        OrHash =
+          T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
+        sig { returns(T::Array[FinchAPI::Jobs::AutomatedAsyncJob]) }
         attr_accessor :data
 
         sig { returns(FinchAPI::Models::Jobs::AutomatedListResponse::Meta) }
         attr_reader :meta
 
-        sig { params(meta: T.any(FinchAPI::Models::Jobs::AutomatedListResponse::Meta, FinchAPI::Internal::AnyHash)).void }
+        sig do
+          params(
+            meta: FinchAPI::Models::Jobs::AutomatedListResponse::Meta::OrHash
+          ).void
+        end
         attr_writer :meta
 
         sig do
           params(
-            data: T::Array[T.any(FinchAPI::Models::Jobs::AutomatedAsyncJob, FinchAPI::Internal::AnyHash)],
-            meta: T.any(FinchAPI::Models::Jobs::AutomatedListResponse::Meta, FinchAPI::Internal::AnyHash)
-          )
-            .returns(T.attached_class)
+            data: T::Array[FinchAPI::Jobs::AutomatedAsyncJob::OrHash],
+            meta: FinchAPI::Models::Jobs::AutomatedListResponse::Meta::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(data:, meta:)
         end
-        def self.new(data:, meta:); end
 
         sig do
-          override
-            .returns(
-              {
-                data: T::Array[FinchAPI::Models::Jobs::AutomatedAsyncJob],
-                meta: FinchAPI::Models::Jobs::AutomatedListResponse::Meta
-              }
-            )
+          override.returns(
+            {
+              data: T::Array[FinchAPI::Jobs::AutomatedAsyncJob],
+              meta: FinchAPI::Models::Jobs::AutomatedListResponse::Meta
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
 
         class Meta < FinchAPI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
           # Information about remaining quotas for this connection. Only applicable for
           # customers opted in to use Finch's Data Sync Refresh endpoint
           # (`POST /jobs/automated`). Please contact a Finch representative for more
           # details.
-          sig { returns(T.nilable(FinchAPI::Models::Jobs::AutomatedListResponse::Meta::Quotas)) }
+          sig do
+            returns(
+              T.nilable(
+                FinchAPI::Models::Jobs::AutomatedListResponse::Meta::Quotas
+              )
+            )
+          end
           attr_reader :quotas
 
           sig do
             params(
-              quotas: T.any(FinchAPI::Models::Jobs::AutomatedListResponse::Meta::Quotas, FinchAPI::Internal::AnyHash)
-            )
-              .void
+              quotas:
+                FinchAPI::Models::Jobs::AutomatedListResponse::Meta::Quotas::OrHash
+            ).void
           end
           attr_writer :quotas
 
           sig do
             params(
-              quotas: T.any(FinchAPI::Models::Jobs::AutomatedListResponse::Meta::Quotas, FinchAPI::Internal::AnyHash)
-            )
-              .returns(T.attached_class)
+              quotas:
+                FinchAPI::Models::Jobs::AutomatedListResponse::Meta::Quotas::OrHash
+            ).returns(T.attached_class)
           end
           def self.new(
             # Information about remaining quotas for this connection. Only applicable for
@@ -61,22 +77,38 @@ module FinchAPI
             # (`POST /jobs/automated`). Please contact a Finch representative for more
             # details.
             quotas: nil
-          ); end
-          sig { override.returns({quotas: FinchAPI::Models::Jobs::AutomatedListResponse::Meta::Quotas}) }
-          def to_hash; end
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                quotas:
+                  FinchAPI::Models::Jobs::AutomatedListResponse::Meta::Quotas
+              }
+            )
+          end
+          def to_hash
+          end
 
           class Quotas < FinchAPI::Internal::Type::BaseModel
-            sig { returns(T.nilable(FinchAPI::Models::Jobs::AutomatedListResponse::Meta::Quotas::DataSyncAll)) }
-            attr_reader :data_sync_all
+            OrHash =
+              T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
 
             sig do
-              params(
-                data_sync_all: T.any(
-                  FinchAPI::Models::Jobs::AutomatedListResponse::Meta::Quotas::DataSyncAll,
-                  FinchAPI::Internal::AnyHash
+              returns(
+                T.nilable(
+                  FinchAPI::Models::Jobs::AutomatedListResponse::Meta::Quotas::DataSyncAll
                 )
               )
-                .void
+            end
+            attr_reader :data_sync_all
+
+            sig do
+              params(
+                data_sync_all:
+                  FinchAPI::Models::Jobs::AutomatedListResponse::Meta::Quotas::DataSyncAll::OrHash
+              ).void
             end
             attr_writer :data_sync_all
 
@@ -86,21 +118,28 @@ module FinchAPI
             # details.
             sig do
               params(
-                data_sync_all: T.any(
-                  FinchAPI::Models::Jobs::AutomatedListResponse::Meta::Quotas::DataSyncAll,
-                  FinchAPI::Internal::AnyHash
-                )
-              )
-                .returns(T.attached_class)
+                data_sync_all:
+                  FinchAPI::Models::Jobs::AutomatedListResponse::Meta::Quotas::DataSyncAll::OrHash
+              ).returns(T.attached_class)
+            end
+            def self.new(data_sync_all: nil)
             end
-            def self.new(data_sync_all: nil); end
 
             sig do
-              override.returns({data_sync_all: FinchAPI::Models::Jobs::AutomatedListResponse::Meta::Quotas::DataSyncAll})
+              override.returns(
+                {
+                  data_sync_all:
+                    FinchAPI::Models::Jobs::AutomatedListResponse::Meta::Quotas::DataSyncAll
+                }
+              )
+            end
+            def to_hash
             end
-            def to_hash; end
 
             class DataSyncAll < FinchAPI::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
               sig { returns(T.nilable(Integer)) }
               attr_reader :allowed_refreshes
 
@@ -114,12 +153,21 @@ module FinchAPI
               attr_writer :remaining_refreshes
 
               sig do
-                params(allowed_refreshes: Integer, remaining_refreshes: Integer).returns(T.attached_class)
+                params(
+                  allowed_refreshes: Integer,
+                  remaining_refreshes: Integer
+                ).returns(T.attached_class)
+              end
+              def self.new(allowed_refreshes: nil, remaining_refreshes: nil)
               end
-              def self.new(allowed_refreshes: nil, remaining_refreshes: nil); end
 
-              sig { override.returns({allowed_refreshes: Integer, remaining_refreshes: Integer}) }
-              def to_hash; end
+              sig do
+                override.returns(
+                  { allowed_refreshes: Integer, remaining_refreshes: Integer }
+                )
+              end
+              def to_hash
+              end
             end
           end
         end

data/rbi/finch_api/models/jobs/automated_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