finch-api 0.1.0.pre.alpha.1 → 0.1.0.pre.alpha.2

data/rbi/lib/finch-api/resources/hris/documents.rbi

@@ -4,31 +4,51 @@ module FinchAPI
   module Resources
     class HRIS
       class Documents
+        # **Beta:** This endpoint is in beta and may change. Retrieve a list of
+        #   company-wide documents.
         sig do
           params(
             individual_ids: T::Array[String],
             limit: Integer,
             offset: Integer,
-            types: T::Array[Symbol],
-            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+            types: T::Array[FinchAPI::Models::HRIS::DocumentListParams::Type::OrSymbol],
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash))
           )
             .returns(FinchAPI::Models::HRIS::DocumentListResponse)
         end
-        def list(individual_ids: nil, limit: nil, offset: nil, types: nil, request_options: {})
+        def list(
+          # Comma-delimited list of stable Finch uuids for each individual. If empty,
+          #   defaults to all individuals
+          individual_ids: nil,
+          # Number of documents to return (defaults to all)
+          limit: nil,
+          # Index to start from (defaults to 0)
+          offset: nil,
+          # Comma-delimited list of document types to filter on. If empty, defaults to all
+          #   types
+          types: nil,
+          request_options: {}
+        )
         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: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash))
           )
             .returns(T.any(FinchAPI::Models::HRIS::W42020, FinchAPI::Models::HRIS::W42005))
         end
-        def retreive(document_id, request_options: {})
+        def retreive(
+          # The unique identifier of the document.
+          document_id,
+          request_options: {}
+        )
         end
 
-        sig { params(client: FinchAPI::Client).void }
-        def initialize(client:)
+        sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+        def self.new(client:)
         end
       end
     end

data/rbi/lib/finch-api/resources/hris/employments.rbi

@@ -4,18 +4,23 @@ module FinchAPI
   module Resources
     class HRIS
       class Employments
+        # Read individual employment and income data
         sig do
           params(
-            requests: T::Array[FinchAPI::Models::HRIS::EmploymentRetrieveManyParams::Request],
-            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+            requests: T::Array[T.any(FinchAPI::Models::HRIS::EmploymentRetrieveManyParams::Request, FinchAPI::Util::AnyHash)],
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash))
           )
             .returns(FinchAPI::ResponsesPage[FinchAPI::Models::HRIS::EmploymentDataResponse])
         end
-        def retrieve_many(requests:, request_options: {})
+        def retrieve_many(
+          # The array of batch requests.
+          requests:,
+          request_options: {}
+        )
         end
 
-        sig { params(client: FinchAPI::Client).void }
-        def initialize(client:)
+        sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+        def self.new(client:)
         end
       end
     end

data/rbi/lib/finch-api/resources/hris/individuals.rbi

@@ -4,19 +4,20 @@ module FinchAPI
   module Resources
     class HRIS
       class Individuals
+        # Read individual data, excluding income and employment data
         sig do
           params(
-            options: T.nilable(FinchAPI::Models::HRIS::IndividualRetrieveManyParams::Options),
-            requests: T::Array[FinchAPI::Models::HRIS::IndividualRetrieveManyParams::Request],
-            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+            options: T.nilable(T.any(FinchAPI::Models::HRIS::IndividualRetrieveManyParams::Options, FinchAPI::Util::AnyHash)),
+            requests: T::Array[T.any(FinchAPI::Models::HRIS::IndividualRetrieveManyParams::Request, FinchAPI::Util::AnyHash)],
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash))
           )
             .returns(FinchAPI::ResponsesPage[FinchAPI::Models::HRIS::IndividualResponse])
         end
         def retrieve_many(options: nil, requests: nil, request_options: {})
         end
 
-        sig { params(client: FinchAPI::Client).void }
-        def initialize(client:)
+        sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+        def self.new(client:)
         end
       end
     end

data/rbi/lib/finch-api/resources/hris/pay_statements.rbi

@@ -4,18 +4,26 @@ module FinchAPI
   module Resources
     class HRIS
       class PayStatements
+        # Read detailed pay statements for each individual.
+        #
+        #   Deduction and contribution types are supported by the payroll systems that
+        #   supports Benefits.
         sig do
           params(
-            requests: T::Array[FinchAPI::Models::HRIS::PayStatementRetrieveManyParams::Request],
-            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+            requests: T::Array[T.any(FinchAPI::Models::HRIS::PayStatementRetrieveManyParams::Request, FinchAPI::Util::AnyHash)],
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash))
           )
             .returns(FinchAPI::ResponsesPage[FinchAPI::Models::HRIS::PayStatementResponse])
         end
-        def retrieve_many(requests:, request_options: {})
+        def retrieve_many(
+          # The array of batch requests.
+          requests:,
+          request_options: {}
+        )
         end
 
-        sig { params(client: FinchAPI::Client).void }
-        def initialize(client:)
+        sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+        def self.new(client:)
         end
       end
     end

data/rbi/lib/finch-api/resources/hris/payments.rbi

@@ -4,19 +4,28 @@ module FinchAPI
   module Resources
     class HRIS
       class Payments
+        # Read payroll and contractor related payments by the company.
         sig do
           params(
             end_date: Date,
             start_date: Date,
-            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash))
           )
             .returns(FinchAPI::SinglePage[FinchAPI::Models::HRIS::Payment])
         end
-        def list(end_date:, start_date:, request_options: {})
+        def list(
+          # The end date to retrieve payments by a company (inclusive) in `YYYY-MM-DD`
+          #   format.
+          end_date:,
+          # The start date to retrieve payments by a company (inclusive) in `YYYY-MM-DD`
+          #   format.
+          start_date:,
+          request_options: {}
+        )
         end
 
-        sig { params(client: FinchAPI::Client).void }
-        def initialize(client:)
+        sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+        def self.new(client:)
         end
       end
     end

data/rbi/lib/finch-api/resources/hris.rbi

@@ -4,39 +4,31 @@ module FinchAPI
   module Resources
     class HRIS
       sig { returns(FinchAPI::Resources::HRIS::Company) }
-      def company
-      end
+      attr_reader :company
 
       sig { returns(FinchAPI::Resources::HRIS::Directory) }
-      def directory
-      end
+      attr_reader :directory
 
       sig { returns(FinchAPI::Resources::HRIS::Individuals) }
-      def individuals
-      end
+      attr_reader :individuals
 
       sig { returns(FinchAPI::Resources::HRIS::Employments) }
-      def employments
-      end
+      attr_reader :employments
 
       sig { returns(FinchAPI::Resources::HRIS::Payments) }
-      def payments
-      end
+      attr_reader :payments
 
       sig { returns(FinchAPI::Resources::HRIS::PayStatements) }
-      def pay_statements
-      end
+      attr_reader :pay_statements
 
       sig { returns(FinchAPI::Resources::HRIS::Documents) }
-      def documents
-      end
+      attr_reader :documents
 
       sig { returns(FinchAPI::Resources::HRIS::Benefits) }
-      def benefits
-      end
+      attr_reader :benefits
 
-      sig { params(client: FinchAPI::Client).void }
-      def initialize(client:)
+      sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+      def self.new(client:)
       end
     end
   end

data/rbi/lib/finch-api/resources/jobs/automated.rbi

@@ -4,40 +4,69 @@ module FinchAPI
   module Resources
     class Jobs
       class Automated
+        # Enqueue an automated job.
+        #
+        #   `data_sync_all`: Enqueue a job to re-sync all data for a connection.
+        #   `data_sync_all` has a concurrency limit of 1 job at a time per connection. This
+        #   means that if this endpoint is called while a job is already in progress for
+        #   this connection, Finch will return the `job_id` of the job that is currently in
+        #   progress. Finch allows a fixed window rate limit of 1 forced refresh per hour
+        #   per connection.
+        #
+        #   `w4_form_employee_sync`: Enqueues a job for sync W-4 data for a particular
+        #   individual, identified by `individual_id`. This feature is currently in beta.
+        #
+        #   This endpoint is available for _Scale_ tier customers as an add-on. To request
+        #   access to this endpoint, please contact your Finch account manager.
         sig do
           params(
-            type: Symbol,
-            params: FinchAPI::Models::Jobs::AutomatedCreateParams::Params,
-            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+            type: FinchAPI::Models::Jobs::AutomatedCreateParams::Type::OrSymbol,
+            params: T.any(FinchAPI::Models::Jobs::AutomatedCreateParams::Params, FinchAPI::Util::AnyHash),
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash))
           )
             .returns(FinchAPI::Models::Jobs::AutomatedCreateResponse)
         end
-        def create(type:, params:, request_options: {})
+        def create(
+          # The type of job to start.
+          type:,
+          params:,
+          request_options: {}
+        )
         end
 
+        # Get an automated job by `job_id`.
         sig do
           params(
             job_id: String,
-            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash))
           )
             .returns(FinchAPI::Models::Jobs::AutomatedAsyncJob)
         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: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash))
           )
-            .returns(FinchAPI::Page[FinchAPI::Models::Jobs::AutomatedAsyncJob])
+            .returns(FinchAPI::Models::Jobs::AutomatedListResponse)
         end
-        def list(limit: nil, offset: nil, request_options: {})
+        def list(
+          # Number of items to return
+          limit: nil,
+          # Index to start from (defaults to 0)
+          offset: nil,
+          request_options: {}
+        )
         end
 
-        sig { params(client: FinchAPI::Client).void }
-        def initialize(client:)
+        sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+        def self.new(client:)
         end
       end
     end

data/rbi/lib/finch-api/resources/jobs/manual.rbi

@@ -4,18 +4,20 @@ module FinchAPI
   module Resources
     class Jobs
       class Manual
+        # 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: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash))
           )
             .returns(FinchAPI::Models::Jobs::ManualAsyncJob)
         end
         def retrieve(job_id, request_options: {})
         end
 
-        sig { params(client: FinchAPI::Client).void }
-        def initialize(client:)
+        sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+        def self.new(client:)
         end
       end
     end

data/rbi/lib/finch-api/resources/jobs.rbi

@@ -4,15 +4,13 @@ module FinchAPI
   module Resources
     class Jobs
       sig { returns(FinchAPI::Resources::Jobs::Automated) }
-      def automated
-      end
+      attr_reader :automated
 
       sig { returns(FinchAPI::Resources::Jobs::Manual) }
-      def manual
-      end
+      attr_reader :manual
 
-      sig { params(client: FinchAPI::Client).void }
-      def initialize(client:)
+      sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+      def self.new(client:)
       end
     end
   end

data/rbi/lib/finch-api/resources/payroll/pay_groups.rbi

@@ -4,29 +4,31 @@ module FinchAPI
   module Resources
     class Payroll
       class PayGroups
+        # Read information from a single pay group
         sig do
           params(
             pay_group_id: String,
-            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash))
           )
             .returns(FinchAPI::Models::Payroll::PayGroupRetrieveResponse)
         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: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash))
           )
             .returns(FinchAPI::SinglePage[FinchAPI::Models::Payroll::PayGroupListResponse])
         end
         def list(individual_id: nil, pay_frequencies: nil, request_options: {})
         end
 
-        sig { params(client: FinchAPI::Client).void }
-        def initialize(client:)
+        sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+        def self.new(client:)
         end
       end
     end

data/rbi/lib/finch-api/resources/payroll.rbi

@@ -4,11 +4,10 @@ module FinchAPI
   module Resources
     class Payroll
       sig { returns(FinchAPI::Resources::Payroll::PayGroups) }
-      def pay_groups
-      end
+      attr_reader :pay_groups
 
-      sig { params(client: FinchAPI::Client).void }
-      def initialize(client:)
+      sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+      def self.new(client:)
       end
     end
   end

data/rbi/lib/finch-api/resources/providers.rbi

@@ -3,15 +3,16 @@
 module FinchAPI
   module Resources
     class Providers
+      # Return details on all available payroll and HR systems.
       sig do
-        params(request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])))
+        params(request_options: T.nilable(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash)))
           .returns(FinchAPI::SinglePage[FinchAPI::Models::Provider])
       end
       def list(request_options: {})
       end
 
-      sig { params(client: FinchAPI::Client).void }
-      def initialize(client:)
+      sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+      def self.new(client:)
       end
     end
   end

data/rbi/lib/finch-api/resources/request_forwarding.rbi

@@ -3,6 +3,10 @@
 module FinchAPI
   module Resources
     class RequestForwarding
+      # The Forward API allows you to make direct requests to an employment system. If
+      #   Finch’s unified API doesn’t have a data model that cleanly fits your needs, then
+      #   Forward allows you to push or pull data models directly against an integration’s
+      #   API.
       sig do
         params(
           method_: String,
@@ -10,15 +14,34 @@ module FinchAPI
           data: T.nilable(String),
           headers: T.nilable(T.anything),
           params: T.nilable(T.anything),
-          request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash))
         )
           .returns(FinchAPI::Models::RequestForwardingForwardResponse)
       end
-      def forward(method_:, route:, data: nil, headers: nil, params: nil, request_options: {})
+      def forward(
+        # The HTTP method for the forwarded request. Valid values include: `GET` , `POST`
+        #   , `PUT` , `DELETE` , and `PATCH`.
+        method_:,
+        # The URL route path for the forwarded request. This value must begin with a
+        #   forward-slash ( / ) and may only contain alphanumeric characters, hyphens, and
+        #   underscores.
+        route:,
+        # The body for the forwarded request. This value must be specified as either a
+        #   string or a valid JSON object.
+        data: nil,
+        # The HTTP headers to include on the forwarded request. This value must be
+        #   specified as an object of key-value pairs. Example:
+        #   `{"Content-Type": "application/xml", "X-API-Version": "v1" }`
+        headers: nil,
+        # The query parameters for the forwarded request. This value must be specified as
+        #   a valid JSON object rather than a query string.
+        params: nil,
+        request_options: {}
+      )
       end
 
-      sig { params(client: FinchAPI::Client).void }
-      def initialize(client:)
+      sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+      def self.new(client:)
       end
     end
   end

data/rbi/lib/finch-api/resources/sandbox/company.rbi

@@ -4,35 +4,47 @@ module FinchAPI
   module Resources
     class Sandbox
       class Company
+        # Update a sandbox company's data
         sig do
           params(
-            accounts: T.nilable(T::Array[FinchAPI::Models::Sandbox::CompanyUpdateParams::Account]),
-            departments: T.nilable(T::Array[T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateParams::Department)]),
+            accounts: T.nilable(
+              T::Array[T.any(FinchAPI::Models::Sandbox::CompanyUpdateParams::Account, FinchAPI::Util::AnyHash)]
+            ),
+            departments: T.nilable(
+              T::Array[T.nilable(T.any(FinchAPI::Models::Sandbox::CompanyUpdateParams::Department, FinchAPI::Util::AnyHash))]
+            ),
             ein: T.nilable(String),
-            entity: T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateParams::Entity),
+            entity: T.nilable(T.any(FinchAPI::Models::Sandbox::CompanyUpdateParams::Entity, FinchAPI::Util::AnyHash)),
             legal_name: T.nilable(String),
-            locations: T.nilable(T::Array[T.nilable(FinchAPI::Models::Location)]),
+            locations: T.nilable(T::Array[T.nilable(T.any(FinchAPI::Models::Location, FinchAPI::Util::AnyHash))]),
             primary_email: T.nilable(String),
             primary_phone_number: T.nilable(String),
-            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash))
           )
             .returns(FinchAPI::Models::Sandbox::CompanyUpdateResponse)
         end
         def update(
+          # An array of bank account objects associated with the payroll/HRIS system.
           accounts:,
+          # The array of company departments.
           departments:,
+          # The employer identification number.
           ein:,
+          # The entity type object.
           entity:,
+          # The legal name of the company.
           legal_name:,
           locations:,
+          # The email of the main administrator on the account.
           primary_email:,
+          # The phone number of the main administrator on the account. Format: `XXXXXXXXXX`
           primary_phone_number:,
           request_options: {}
         )
         end
 
-        sig { params(client: FinchAPI::Client).void }
-        def initialize(client:)
+        sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+        def self.new(client:)
         end
       end
     end

data/rbi/lib/finch-api/resources/sandbox/connections/accounts.rbi

@@ -5,31 +5,43 @@ module FinchAPI
     class Sandbox
       class Connections
         class Accounts
+          # Create a new account for an existing connection (company/provider pair)
           sig do
             params(
               company_id: String,
               provider_id: String,
-              authentication_type: Symbol,
+              authentication_type: FinchAPI::Models::Sandbox::Connections::AccountCreateParams::AuthenticationType::OrSymbol,
               products: T::Array[String],
-              request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+              request_options: T.nilable(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash))
             )
               .returns(FinchAPI::Models::Sandbox::Connections::AccountCreateResponse)
           end
-          def create(company_id:, provider_id:, authentication_type: nil, products: nil, request_options: {})
+          def create(
+            company_id:,
+            # The provider associated with the `access_token`
+            provider_id:,
+            authentication_type: nil,
+            # Optional, defaults to Organization products (`company`, `directory`,
+            #   `employment`, `individual`)
+            products: nil,
+            request_options: {}
+          )
           end
 
+          # Update an existing sandbox account. Change the connection status to understand
+          #   how the Finch API responds.
           sig do
             params(
-              connection_status: Symbol,
-              request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+              connection_status: FinchAPI::Models::ConnectionStatusType::OrSymbol,
+              request_options: T.nilable(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash))
             )
               .returns(FinchAPI::Models::Sandbox::Connections::AccountUpdateResponse)
           end
           def update(connection_status: nil, request_options: {})
           end
 
-          sig { params(client: FinchAPI::Client).void }
-          def initialize(client:)
+          sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+          def self.new(client:)
           end
         end
       end

data/rbi/lib/finch-api/resources/sandbox/connections.rbi

@@ -5,30 +5,34 @@ module FinchAPI
     class Sandbox
       class Connections
         sig { returns(FinchAPI::Resources::Sandbox::Connections::Accounts) }
-        def accounts
-        end
+        attr_reader :accounts
 
+        # Create a new connection (new company/provider pair) with a new account
         sig do
           params(
             provider_id: String,
-            authentication_type: Symbol,
+            authentication_type: FinchAPI::Models::Sandbox::ConnectionCreateParams::AuthenticationType::OrSymbol,
             employee_size: Integer,
             products: T::Array[String],
-            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash))
           )
             .returns(FinchAPI::Models::Sandbox::ConnectionCreateResponse)
         end
         def create(
+          # The provider associated with the connection
           provider_id:,
           authentication_type: nil,
+          # Optional: the size of the employer to be created with this connection. Defaults
+          #   to 20. Note that if this is higher than 100, historical payroll data will not be
+          #   generated, and instead only one pay period will be created.
           employee_size: nil,
           products: nil,
           request_options: {}
         )
         end
 
-        sig { params(client: FinchAPI::Client).void }
-        def initialize(client:)
+        sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+        def self.new(client:)
         end
       end
     end

data/rbi/lib/finch-api/resources/sandbox/directory.rbi

@@ -4,18 +4,24 @@ module FinchAPI
   module Resources
     class Sandbox
       class Directory
+        # Add new individuals to a sandbox company
         sig do
           params(
-            body: T::Array[FinchAPI::Models::Sandbox::DirectoryCreateParams::Body],
-            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+            body: T::Array[T.any(FinchAPI::Models::Sandbox::DirectoryCreateParams::Body, FinchAPI::Util::AnyHash)],
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash))
           )
-            .returns(FinchAPI::Models::Sandbox::DirectoryCreateResponse)
+            .returns(T::Array[T.anything])
         end
-        def create(body: nil, request_options: {})
+        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
 
-        sig { params(client: FinchAPI::Client).void }
-        def initialize(client:)
+        sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+        def self.new(client:)
         end
       end
     end