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

data/rbi/finch_api/resources/hris/company.rbi

@@ -8,12 +8,18 @@ module FinchAPI
         attr_reader :pay_statement_item
 
         # Read basic company data
-        sig { params(request_options: FinchAPI::RequestOpts).returns(FinchAPI::Models::HRIS::HRISCompany) }
-        def retrieve(request_options: {}); end
+        sig do
+          params(request_options: FinchAPI::RequestOptions::OrHash).returns(
+            FinchAPI::HRIS::HRISCompany
+          )
+        end
+        def retrieve(request_options: {})
+        end
 
         # @api private
         sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-        def self.new(client:); end
+        def self.new(client:)
+        end
       end
     end
   end

data/rbi/finch_api/resources/hris/directory.rbi

@@ -6,8 +6,15 @@ module FinchAPI
       class Directory
         # Read company directory and organization structure
         sig do
-          params(limit: Integer, offset: Integer, request_options: FinchAPI::RequestOpts)
-            .returns(FinchAPI::Internal::IndividualsPage[FinchAPI::Models::HRIS::IndividualInDirectory])
+          params(
+            limit: Integer,
+            offset: Integer,
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(
+            FinchAPI::Internal::IndividualsPage[
+              FinchAPI::HRIS::IndividualInDirectory
+            ]
+          )
         end
         def list(
           # Number of employees to return (defaults to all)
@@ -15,10 +22,13 @@ module FinchAPI
           # Index to start from (defaults to 0)
           offset: nil,
           request_options: {}
-        ); end
+        )
+        end
+
         # @api private
         sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-        def self.new(client:); end
+        def self.new(client:)
+        end
       end
     end
   end

data/rbi/finch_api/resources/hris/documents.rbi

@@ -11,10 +11,9 @@ module FinchAPI
             individual_ids: T::Array[String],
             limit: Integer,
             offset: Integer,
-            types: T::Array[FinchAPI::Models::HRIS::DocumentListParams::Type::OrSymbol],
-            request_options: FinchAPI::RequestOpts
-          )
-            .returns(FinchAPI::Models::HRIS::DocumentListResponse)
+            types: T::Array[FinchAPI::HRIS::DocumentListParams::Type::OrSymbol],
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(FinchAPI::Models::HRIS::DocumentListResponse)
         end
         def list(
           # Comma-delimited list of stable Finch uuids for each individual. If empty,
@@ -28,21 +27,28 @@ module FinchAPI
           # types
           types: nil,
           request_options: {}
-        ); end
+        )
+        end
+
         # **Beta:** This endpoint is in beta and may change. Retrieve details of a
         # specific document by its ID.
         sig do
-          params(document_id: String, request_options: FinchAPI::RequestOpts)
-            .returns(T.any(FinchAPI::Models::HRIS::W42020, FinchAPI::Models::HRIS::W42005))
+          params(
+            document_id: String,
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(T.any(FinchAPI::HRIS::W42020, FinchAPI::HRIS::W42005))
         end
         def retreive(
           # The unique identifier of the document.
           document_id,
           request_options: {}
-        ); end
+        )
+        end
+
         # @api private
         sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-        def self.new(client:); end
+        def self.new(client:)
+        end
       end
     end
   end

data/rbi/finch_api/resources/hris/employments.rbi

@@ -7,19 +7,28 @@ module FinchAPI
         # Read individual employment and income data
         sig do
           params(
-            requests: T::Array[T.any(FinchAPI::Models::HRIS::EmploymentRetrieveManyParams::Request, FinchAPI::Internal::AnyHash)],
-            request_options: FinchAPI::RequestOpts
+            requests:
+              T::Array[
+                FinchAPI::HRIS::EmploymentRetrieveManyParams::Request::OrHash
+              ],
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(
+            FinchAPI::Internal::ResponsesPage[
+              FinchAPI::HRIS::EmploymentDataResponse
+            ]
           )
-            .returns(FinchAPI::Internal::ResponsesPage[FinchAPI::Models::HRIS::EmploymentDataResponse])
         end
         def retrieve_many(
           # The array of batch requests.
           requests:,
           request_options: {}
-        ); end
+        )
+        end
+
         # @api private
         sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-        def self.new(client:); end
+        def self.new(client:)
+        end
       end
     end
   end

data/rbi/finch_api/resources/hris/individuals.rbi

@@ -7,19 +7,28 @@ module FinchAPI
         # Read individual data, excluding income and employment data
         sig do
           params(
-            options: T.nilable(
-              T.any(FinchAPI::Models::HRIS::IndividualRetrieveManyParams::Options, FinchAPI::Internal::AnyHash)
-            ),
-            requests: T::Array[T.any(FinchAPI::Models::HRIS::IndividualRetrieveManyParams::Request, FinchAPI::Internal::AnyHash)],
-            request_options: FinchAPI::RequestOpts
+            options:
+              T.nilable(
+                FinchAPI::HRIS::IndividualRetrieveManyParams::Options::OrHash
+              ),
+            requests:
+              T::Array[
+                FinchAPI::HRIS::IndividualRetrieveManyParams::Request::OrHash
+              ],
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(
+            FinchAPI::Internal::ResponsesPage[
+              FinchAPI::HRIS::IndividualResponse
+            ]
           )
-            .returns(FinchAPI::Internal::ResponsesPage[FinchAPI::Models::HRIS::IndividualResponse])
         end
-        def retrieve_many(options: nil, requests: nil, request_options: {}); end
+        def retrieve_many(options: nil, requests: nil, request_options: {})
+        end
 
         # @api private
         sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-        def self.new(client:); end
+        def self.new(client:)
+        end
       end
     end
   end

data/rbi/finch_api/resources/hris/pay_statements.rbi

@@ -10,19 +10,28 @@ module FinchAPI
         # supports Benefits.
         sig do
           params(
-            requests: T::Array[T.any(FinchAPI::Models::HRIS::PayStatementRetrieveManyParams::Request, FinchAPI::Internal::AnyHash)],
-            request_options: FinchAPI::RequestOpts
+            requests:
+              T::Array[
+                FinchAPI::HRIS::PayStatementRetrieveManyParams::Request::OrHash
+              ],
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(
+            FinchAPI::Internal::ResponsesPage[
+              FinchAPI::HRIS::PayStatementResponse
+            ]
           )
-            .returns(FinchAPI::Internal::ResponsesPage[FinchAPI::Models::HRIS::PayStatementResponse])
         end
         def retrieve_many(
           # The array of batch requests.
           requests:,
           request_options: {}
-        ); end
+        )
+        end
+
         # @api private
         sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-        def self.new(client:); end
+        def self.new(client:)
+        end
       end
     end
   end

data/rbi/finch_api/resources/hris/payments.rbi

@@ -6,8 +6,11 @@ module FinchAPI
       class Payments
         # Read payroll and contractor related payments by the company.
         sig do
-          params(end_date: Date, start_date: Date, request_options: FinchAPI::RequestOpts)
-            .returns(FinchAPI::Internal::SinglePage[FinchAPI::Models::HRIS::Payment])
+          params(
+            end_date: Date,
+            start_date: Date,
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(FinchAPI::Internal::SinglePage[FinchAPI::HRIS::Payment])
         end
         def list(
           # The end date to retrieve payments by a company (inclusive) in `YYYY-MM-DD`
@@ -17,10 +20,13 @@ module FinchAPI
           # format.
           start_date:,
           request_options: {}
-        ); end
+        )
+        end
+
         # @api private
         sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-        def self.new(client:); end
+        def self.new(client:)
+        end
       end
     end
   end

data/rbi/finch_api/resources/hris.rbi

@@ -29,7 +29,8 @@ module FinchAPI
 
       # @api private
       sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-      def self.new(client:); end
+      def self.new(client:)
+      end
     end
   end
 end

data/rbi/finch_api/resources/jobs/automated.rbi

@@ -20,31 +20,38 @@ module FinchAPI
         # access to this endpoint, please contact your Finch account manager.
         sig do
           params(
-            type: FinchAPI::Models::Jobs::AutomatedCreateParams::Type::OrSymbol,
-            params: T.any(FinchAPI::Models::Jobs::AutomatedCreateParams::Params, FinchAPI::Internal::AnyHash),
-            request_options: FinchAPI::RequestOpts
-          )
-            .returns(FinchAPI::Models::Jobs::AutomatedCreateResponse)
+            type: FinchAPI::Jobs::AutomatedCreateParams::Type::OrSymbol,
+            params: FinchAPI::Jobs::AutomatedCreateParams::Params::OrHash,
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(FinchAPI::Models::Jobs::AutomatedCreateResponse)
         end
         def create(
           # The type of job to start.
           type:,
           params:,
           request_options: {}
-        ); end
+        )
+        end
+
         # Get an automated job by `job_id`.
         sig do
-          params(job_id: String, request_options: FinchAPI::RequestOpts)
-            .returns(FinchAPI::Models::Jobs::AutomatedAsyncJob)
+          params(
+            job_id: String,
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(FinchAPI::Jobs::AutomatedAsyncJob)
+        end
+        def retrieve(job_id, request_options: {})
         end
-        def retrieve(job_id, request_options: {}); end
 
         # Get all automated jobs. Automated jobs are completed by a machine. By default,
         # jobs are sorted in descending order by submission time. For scheduled jobs such
         # as data syncs, only the next scheduled job is shown.
         sig do
-          params(limit: Integer, offset: Integer, request_options: FinchAPI::RequestOpts)
-            .returns(FinchAPI::Models::Jobs::AutomatedListResponse)
+          params(
+            limit: Integer,
+            offset: Integer,
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(FinchAPI::Models::Jobs::AutomatedListResponse)
         end
         def list(
           # Number of items to return
@@ -52,10 +59,13 @@ module FinchAPI
           # Index to start from (defaults to 0)
           offset: nil,
           request_options: {}
-        ); end
+        )
+        end
+
         # @api private
         sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-        def self.new(client:); end
+        def self.new(client:)
+        end
       end
     end
   end

data/rbi/finch_api/resources/jobs/manual.rbi

@@ -7,14 +7,18 @@ module FinchAPI
         # Get a manual job by `job_id`. Manual jobs are completed by a human and include
         # Assisted Benefits jobs.
         sig do
-          params(job_id: String, request_options: FinchAPI::RequestOpts)
-            .returns(FinchAPI::Models::Jobs::ManualAsyncJob)
+          params(
+            job_id: String,
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(FinchAPI::Jobs::ManualAsyncJob)
+        end
+        def retrieve(job_id, request_options: {})
         end
-        def retrieve(job_id, request_options: {}); end
 
         # @api private
         sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-        def self.new(client:); end
+        def self.new(client:)
+        end
       end
     end
   end

data/rbi/finch_api/resources/jobs.rbi

@@ -11,7 +11,8 @@ module FinchAPI
 
       # @api private
       sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-      def self.new(client:); end
+      def self.new(client:)
+      end
     end
   end
 end

data/rbi/finch_api/resources/payroll/pay_groups.rbi

@@ -6,25 +6,33 @@ module FinchAPI
       class PayGroups
         # Read information from a single pay group
         sig do
-          params(pay_group_id: String, request_options: FinchAPI::RequestOpts)
-            .returns(FinchAPI::Models::Payroll::PayGroupRetrieveResponse)
+          params(
+            pay_group_id: String,
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(FinchAPI::Models::Payroll::PayGroupRetrieveResponse)
+        end
+        def retrieve(pay_group_id, request_options: {})
         end
-        def retrieve(pay_group_id, request_options: {}); end
 
         # Read company pay groups and frequencies
         sig do
           params(
             individual_id: String,
             pay_frequencies: T::Array[String],
-            request_options: FinchAPI::RequestOpts
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(
+            FinchAPI::Internal::SinglePage[
+              FinchAPI::Models::Payroll::PayGroupListResponse
+            ]
           )
-            .returns(FinchAPI::Internal::SinglePage[FinchAPI::Models::Payroll::PayGroupListResponse])
         end
-        def list(individual_id: nil, pay_frequencies: nil, request_options: {}); end
+        def list(individual_id: nil, pay_frequencies: nil, request_options: {})
+        end
 
         # @api private
         sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-        def self.new(client:); end
+        def self.new(client:)
+        end
       end
     end
   end

data/rbi/finch_api/resources/payroll.rbi

@@ -8,7 +8,8 @@ module FinchAPI
 
       # @api private
       sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-      def self.new(client:); end
+      def self.new(client:)
+      end
     end
   end
 end

data/rbi/finch_api/resources/providers.rbi

@@ -5,14 +5,17 @@ module FinchAPI
     class Providers
       # Return details on all available payroll and HR systems.
       sig do
-        params(request_options: FinchAPI::RequestOpts)
-          .returns(FinchAPI::Internal::SinglePage[FinchAPI::Models::Provider])
+        params(request_options: FinchAPI::RequestOptions::OrHash).returns(
+          FinchAPI::Internal::SinglePage[FinchAPI::Provider]
+        )
+      end
+      def list(request_options: {})
       end
-      def list(request_options: {}); end
 
       # @api private
       sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-      def self.new(client:); end
+      def self.new(client:)
+      end
     end
   end
 end

data/rbi/finch_api/resources/request_forwarding.rbi

@@ -14,9 +14,8 @@ module FinchAPI
           data: T.nilable(String),
           headers: T.nilable(T.anything),
           params: T.nilable(T.anything),
-          request_options: FinchAPI::RequestOpts
-        )
-          .returns(FinchAPI::Models::RequestForwardingForwardResponse)
+          request_options: FinchAPI::RequestOptions::OrHash
+        ).returns(FinchAPI::Models::RequestForwardingForwardResponse)
       end
       def forward(
         # The HTTP method for the forwarded request. Valid values include: `GET` , `POST`
@@ -37,10 +36,13 @@ module FinchAPI
         # a valid JSON object rather than a query string.
         params: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       # @api private
       sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-      def self.new(client:); end
+      def self.new(client:)
+      end
     end
   end
 end

data/rbi/finch_api/resources/sandbox/company.rbi

@@ -7,21 +7,30 @@ module FinchAPI
         # Update a sandbox company's data
         sig do
           params(
-            accounts: T.nilable(
-              T::Array[T.any(FinchAPI::Models::Sandbox::CompanyUpdateParams::Account, FinchAPI::Internal::AnyHash)]
-            ),
-            departments: T.nilable(
-              T::Array[T.nilable(T.any(FinchAPI::Models::Sandbox::CompanyUpdateParams::Department, FinchAPI::Internal::AnyHash))]
-            ),
+            accounts:
+              T.nilable(
+                T::Array[
+                  FinchAPI::Sandbox::CompanyUpdateParams::Account::OrHash
+                ]
+              ),
+            departments:
+              T.nilable(
+                T::Array[
+                  T.nilable(
+                    FinchAPI::Sandbox::CompanyUpdateParams::Department::OrHash
+                  )
+                ]
+              ),
             ein: T.nilable(String),
-            entity: T.nilable(T.any(FinchAPI::Models::Sandbox::CompanyUpdateParams::Entity, FinchAPI::Internal::AnyHash)),
+            entity:
+              T.nilable(FinchAPI::Sandbox::CompanyUpdateParams::Entity::OrHash),
             legal_name: T.nilable(String),
-            locations: T.nilable(T::Array[T.nilable(T.any(FinchAPI::Models::Location, FinchAPI::Internal::AnyHash))]),
+            locations:
+              T.nilable(T::Array[T.nilable(FinchAPI::Location::OrHash)]),
             primary_email: T.nilable(String),
             primary_phone_number: T.nilable(String),
-            request_options: FinchAPI::RequestOpts
-          )
-            .returns(FinchAPI::Models::Sandbox::CompanyUpdateResponse)
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(FinchAPI::Models::Sandbox::CompanyUpdateResponse)
         end
         def update(
           # An array of bank account objects associated with the payroll/HRIS system.
@@ -41,10 +50,13 @@ module FinchAPI
           # extension where applicable, e.g. `+NNNNNNNNNNN xExtension`
           primary_phone_number:,
           request_options: {}
-        ); end
+        )
+        end
+
         # @api private
         sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-        def self.new(client:); end
+        def self.new(client:)
+        end
       end
     end
   end

data/rbi/finch_api/resources/sandbox/connections/accounts.rbi

@@ -10,11 +10,13 @@ module FinchAPI
             params(
               company_id: String,
               provider_id: String,
-              authentication_type: FinchAPI::Models::Sandbox::Connections::AccountCreateParams::AuthenticationType::OrSymbol,
+              authentication_type:
+                FinchAPI::Sandbox::Connections::AccountCreateParams::AuthenticationType::OrSymbol,
               products: T::Array[String],
-              request_options: FinchAPI::RequestOpts
+              request_options: FinchAPI::RequestOptions::OrHash
+            ).returns(
+              FinchAPI::Models::Sandbox::Connections::AccountCreateResponse
             )
-              .returns(FinchAPI::Models::Sandbox::Connections::AccountCreateResponse)
           end
           def create(
             company_id:,
@@ -25,21 +27,26 @@ module FinchAPI
             # `employment`, `individual`)
             products: nil,
             request_options: {}
-          ); end
+          )
+          end
+
           # Update an existing sandbox account. Change the connection status to understand
           # how the Finch API responds.
           sig do
             params(
-              connection_status: FinchAPI::Models::ConnectionStatusType::OrSymbol,
-              request_options: FinchAPI::RequestOpts
+              connection_status: FinchAPI::ConnectionStatusType::OrSymbol,
+              request_options: FinchAPI::RequestOptions::OrHash
+            ).returns(
+              FinchAPI::Models::Sandbox::Connections::AccountUpdateResponse
             )
-              .returns(FinchAPI::Models::Sandbox::Connections::AccountUpdateResponse)
           end
-          def update(connection_status: nil, request_options: {}); end
+          def update(connection_status: nil, request_options: {})
+          end
 
           # @api private
           sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-          def self.new(client:); end
+          def self.new(client:)
+          end
         end
       end
     end

data/rbi/finch_api/resources/sandbox/connections.rbi

@@ -11,12 +11,12 @@ module FinchAPI
         sig do
           params(
             provider_id: String,
-            authentication_type: FinchAPI::Models::Sandbox::ConnectionCreateParams::AuthenticationType::OrSymbol,
+            authentication_type:
+              FinchAPI::Sandbox::ConnectionCreateParams::AuthenticationType::OrSymbol,
             employee_size: Integer,
             products: T::Array[String],
-            request_options: FinchAPI::RequestOpts
-          )
-            .returns(FinchAPI::Models::Sandbox::ConnectionCreateResponse)
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(FinchAPI::Models::Sandbox::ConnectionCreateResponse)
         end
         def create(
           # The provider associated with the connection
@@ -28,10 +28,13 @@ module FinchAPI
           employee_size: nil,
           products: nil,
           request_options: {}
-        ); end
+        )
+        end
+
         # @api private
         sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-        def self.new(client:); end
+        def self.new(client:)
+        end
       end
     end
   end

data/rbi/finch_api/resources/sandbox/directory.rbi

@@ -7,20 +7,23 @@ module FinchAPI
         # Add new individuals to a sandbox company
         sig do
           params(
-            body: T::Array[T.any(FinchAPI::Models::Sandbox::DirectoryCreateParams::Body, FinchAPI::Internal::AnyHash)],
-            request_options: FinchAPI::RequestOpts
-          )
-            .returns(T::Array[T.anything])
+            body:
+              T::Array[FinchAPI::Sandbox::DirectoryCreateParams::Body::OrHash],
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(T::Array[T.anything])
         end
         def create(
           # Array of individuals to create. Takes all combined fields from `/individual` and
           # `/employment` endpoints. All fields are optional.
           body: nil,
           request_options: {}
-        ); end
+        )
+        end
+
         # @api private
         sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-        def self.new(client:); end
+        def self.new(client:)
+        end
       end
     end
   end