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

data/rbi/lib/finch-api/models/sandbox/payment_create_response.rbi

@@ -4,24 +4,16 @@ module FinchAPI
   module Models
     module Sandbox
       class PaymentCreateResponse < FinchAPI::BaseModel
+        # The date of the payment.
         sig { returns(String) }
-        def pay_date
-        end
-
-        sig { params(_: String).returns(String) }
-        def pay_date=(_)
-        end
+        attr_accessor :pay_date
 
+        # The ID of the payment.
         sig { returns(String) }
-        def payment_id
-        end
-
-        sig { params(_: String).returns(String) }
-        def payment_id=(_)
-        end
+        attr_accessor :payment_id
 
-        sig { params(pay_date: String, payment_id: String).void }
-        def initialize(pay_date:, payment_id:)
+        sig { params(pay_date: String, payment_id: String).returns(T.attached_class) }
+        def self.new(pay_date:, payment_id:)
         end
 
         sig { override.returns({pay_date: String, payment_id: String}) }

data/rbi/lib/finch-api/models/webhook_event.rbi

@@ -2,16 +2,16 @@
 
 module FinchAPI
   module Models
-    class WebhookEvent < FinchAPI::Union
-      abstract!
+    module WebhookEvent
+      extend FinchAPI::Union
 
       sig do
         override
           .returns(
-            [[NilClass, FinchAPI::Models::AccountUpdateEvent], [NilClass, FinchAPI::Models::JobCompletionEvent], [NilClass, FinchAPI::Models::CompanyEvent], [NilClass, FinchAPI::Models::DirectoryEvent], [NilClass, FinchAPI::Models::EmploymentEvent], [NilClass, FinchAPI::Models::IndividualEvent], [NilClass, FinchAPI::Models::PaymentEvent], [NilClass, FinchAPI::Models::PayStatementEvent]]
+            [FinchAPI::Models::AccountUpdateEvent, FinchAPI::Models::CompanyEvent, FinchAPI::Models::JobCompletionEvent, FinchAPI::Models::DirectoryEvent, FinchAPI::Models::EmploymentEvent, FinchAPI::Models::IndividualEvent, FinchAPI::Models::PaymentEvent, FinchAPI::Models::PayStatementEvent]
           )
       end
-      private_class_method def self.variants
+      def self.variants
       end
     end
   end

data/rbi/lib/finch-api/page.rbi

@@ -6,32 +6,14 @@ module FinchAPI
 
     Elem = type_member
 
-    sig { returns(T::Array[Elem]) }
-    def data
-    end
-
-    sig { params(_: T::Array[Elem]).returns(T::Array[Elem]) }
-    def data=(_)
-    end
+    sig { returns(T.nilable(T::Array[Elem])) }
+    attr_accessor :data
 
     sig { returns(FinchAPI::Models::Paging) }
-    def paging
-    end
+    attr_accessor :paging
 
-    sig { params(_: FinchAPI::Models::Paging).returns(FinchAPI::Models::Paging) }
-    def paging=(_)
-    end
-
-    sig do
-      params(
-        client: FinchAPI::BaseClient,
-        req: FinchAPI::BaseClient::RequestComponentsShape,
-        headers: T.any(T::Hash[String, String], Net::HTTPHeader),
-        unwrapped: T::Hash[Symbol, T.anything]
-      )
-        .void
-    end
-    def initialize(client:, req:, headers:, unwrapped:)
+    sig { returns(String) }
+    def inspect
     end
   end
 end

data/rbi/lib/finch-api/pooled_net_requester.rbi

@@ -1,36 +1,59 @@
 # typed: strong
 
 module FinchAPI
+  # @api private
   class PooledNetRequester
-    RequestShape = T.type_alias do
-      {method: Symbol, url: URI::Generic, headers: T::Hash[String, String], body: T.anything, deadline: Float}
-    end
+    RequestShape =
+      T.type_alias do
+        {
+          method: Symbol,
+          url: URI::Generic,
+          headers: T::Hash[String, String],
+          body: T.anything,
+          deadline: Float
+        }
+      end
 
-    sig { params(url: URI::Generic).returns(Net::HTTP) }
-    def self.connect(url)
-    end
+    # from the golang stdlib
+    #   https://github.com/golang/go/blob/c8eced8580028328fde7c03cbfcb720ce15b2358/src/net/http/transport.go#L49
+    KEEP_ALIVE_TIMEOUT = 30
 
-    sig { params(conn: Net::HTTP, deadline: Float).void }
-    def self.calibrate_socket_timeout(conn, deadline)
-    end
+    class << self
+      # @api private
+      sig { params(url: URI::Generic).returns(Net::HTTP) }
+      def connect(url)
+      end
+
+      # @api private
+      sig { params(conn: Net::HTTP, deadline: Float).void }
+      def calibrate_socket_timeout(conn, deadline)
+      end
 
-    sig { params(request: FinchAPI::PooledNetRequester::RequestShape).returns(Net::HTTPGenericRequest) }
-    def self.build_request(request)
+      # @api private
+      sig do
+        params(request: FinchAPI::PooledNetRequester::RequestShape, blk: T.proc.params(arg0: String).void)
+          .returns(Net::HTTPGenericRequest)
+      end
+      def build_request(request, &blk)
+      end
     end
 
-    sig { params(url: URI::Generic, blk: T.proc.params(arg0: Net::HTTP).void).void }
-    private def with_pool(url, &blk)
+    # @api private
+    sig { params(url: URI::Generic, deadline: Float, blk: T.proc.params(arg0: Net::HTTP).void).void }
+    private def with_pool(url, deadline:, &blk)
     end
 
+    # @api private
     sig do
       params(request: FinchAPI::PooledNetRequester::RequestShape)
-        .returns([Net::HTTPResponse, T::Enumerable[String]])
+        .returns([Integer, Net::HTTPResponse, T::Enumerable[String]])
     end
     def execute(request)
     end
 
-    sig { void }
-    def initialize
+    # @api private
+    sig { params(size: Integer).returns(T.attached_class) }
+    def self.new(size: Etc.nprocessors)
     end
   end
 end

data/rbi/lib/finch-api/request_options.rbi

@@ -1,84 +1,63 @@
 # typed: strong
 
 module FinchAPI
+  # @api private
   module RequestParameters
-    abstract!
-
-    sig { returns(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])) }
-    def request_options
-    end
-
-    sig do
-      params(_: T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
-        .returns(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
-    end
-    def request_options=(_)
-    end
+    # Options to specify HTTP behaviour for this request.
+    sig { returns(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash)) }
+    attr_accessor :request_options
 
+    # @api private
     module Converter
-      sig { params(params: T.anything).returns([T.anything, T::Hash[Symbol, T.anything]]) }
+      # @api private
+      sig { params(params: T.anything).returns([T.anything, FinchAPI::Util::AnyHash]) }
       def dump_request(params)
       end
     end
   end
 
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  #   or override those provided at the client level.
+  #
+  #   When making a request, you can pass an actual {RequestOptions} instance, or
+  #   simply pass a Hash with symbol keys matching the attributes on this class.
   class RequestOptions < FinchAPI::BaseModel
+    # @api private
     sig { params(opts: T.any(T.self_type, T::Hash[Symbol, T.anything])).void }
     def self.validate!(opts)
     end
 
+    # Idempotency key to send with request and all associated retries. Will only be
+    #   sent for write requests.
     sig { returns(T.nilable(String)) }
-    def idempotency_key
-    end
-
-    sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-    def idempotency_key=(_)
-    end
+    attr_accessor :idempotency_key
 
+    # Extra query params to send with the request. These are `.merge`’d into any
+    #   `query` given at the client level.
     sig { returns(T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])) }
-    def extra_query
-    end
-
-    sig do
-      params(_: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]))
-        .returns(T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]))
-    end
-    def extra_query=(_)
-    end
+    attr_accessor :extra_query
 
+    # Extra headers to send with the request. These are `.merged`’d into any
+    #   `extra_headers` given at the client level.
     sig { returns(T.nilable(T::Hash[String, T.nilable(String)])) }
-    def extra_headers
-    end
-
-    sig do
-      params(_: T.nilable(T::Hash[String, T.nilable(String)]))
-        .returns(T.nilable(T::Hash[String, T.nilable(String)]))
-    end
-    def extra_headers=(_)
-    end
+    attr_accessor :extra_headers
 
-    sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
-    def extra_body
-    end
-
-    sig { params(_: T.nilable(T::Hash[Symbol, T.anything])).returns(T.nilable(T::Hash[Symbol, T.anything])) }
-    def extra_body=(_)
-    end
+    # Extra data to send with the request. These are deep merged into any data
+    #   generated as part of the normal request.
+    sig { returns(T.nilable(T.anything)) }
+    attr_accessor :extra_body
 
+    # Maximum number of retries to attempt after a failed initial request.
     sig { returns(T.nilable(Integer)) }
-    def max_retries
-    end
-
-    sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-    def max_retries=(_)
-    end
+    attr_accessor :max_retries
 
+    # Request timeout in seconds.
     sig { returns(T.nilable(Float)) }
-    def timeout
-    end
+    attr_accessor :timeout
 
-    sig { params(_: T.nilable(Float)).returns(T.nilable(Float)) }
-    def timeout=(_)
+    # Returns a new instance of RequestOptions.
+    sig { params(values: FinchAPI::Util::AnyHash).returns(T.attached_class) }
+    def self.new(values = {})
     end
   end
 end

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

@@ -3,21 +3,22 @@
 module FinchAPI
   module Resources
     class AccessTokens
+      # Exchange the authorization code for an access token
       sig do
         params(
           code: String,
           client_id: String,
           client_secret: String,
           redirect_uri: 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::CreateAccessTokenResponse)
       end
       def create(code:, client_id: nil, client_secret: nil, redirect_uri: 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/account.rbi

@@ -3,22 +3,24 @@
 module FinchAPI
   module Resources
     class Account
+      # Disconnect one or more `access_token`s from your application.
       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::Models::DisconnectResponse)
       end
       def disconnect(request_options: {})
       end
 
+      # Read account information associated with an `access_token`
       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::Models::Introspection)
       end
       def introspect(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/connect/sessions.rbi

@@ -4,18 +4,19 @@ module FinchAPI
   module Resources
     class Connect
       class Sessions
+        # Create a new connect session for an employer
         sig do
           params(
             customer_id: String,
             customer_name: String,
-            products: T::Array[Symbol],
+            products: T::Array[FinchAPI::Models::Connect::SessionNewParams::Product::OrSymbol],
             customer_email: T.nilable(String),
-            integration: T.nilable(FinchAPI::Models::Connect::SessionNewParams::Integration),
+            integration: T.nilable(T.any(FinchAPI::Models::Connect::SessionNewParams::Integration, FinchAPI::Util::AnyHash)),
             manual: T.nilable(T::Boolean),
             minutes_to_expire: T.nilable(Float),
             redirect_uri: T.nilable(String),
-            sandbox: T.nilable(Symbol),
-            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+            sandbox: T.nilable(FinchAPI::Models::Connect::SessionNewParams::Sandbox::OrSymbol),
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash))
           )
             .returns(FinchAPI::Models::Connect::SessionNewResponse)
         end
@@ -26,6 +27,8 @@ module FinchAPI
           customer_email: nil,
           integration: nil,
           manual: nil,
+          # The number of minutes until the session expires (defaults to 43,200, which is 30
+          #   days)
           minutes_to_expire: nil,
           redirect_uri: nil,
           sandbox: nil,
@@ -33,27 +36,33 @@ module FinchAPI
         )
         end
 
+        # Create a new Connect session for reauthenticating an existing connection
         sig do
           params(
             connection_id: String,
             minutes_to_expire: T.nilable(Integer),
-            products: T.nilable(T::Array[Symbol]),
+            products: T.nilable(T::Array[FinchAPI::Models::Connect::SessionReauthenticateParams::Product::OrSymbol]),
             redirect_uri: 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::Connect::SessionReauthenticateResponse)
         end
         def reauthenticate(
+          # The ID of the existing connection to reauthenticate
           connection_id:,
+          # The number of minutes until the session expires (defaults to 43,200, which is 30
+          #   days)
           minutes_to_expire: nil,
+          # The products to request access to (optional for reauthentication)
           products: nil,
+          # The URI to redirect to after the Connect flow is completed
           redirect_uri: 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/connect.rbi

@@ -4,11 +4,10 @@ module FinchAPI
   module Resources
     class Connect
       sig { returns(FinchAPI::Resources::Connect::Sessions) }
-      def sessions
-      end
+      attr_reader :sessions
 
-      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/benefits/individuals.rbi

@@ -5,51 +5,74 @@ module FinchAPI
     class HRIS
       class Benefits
         class Individuals
+          # Enroll an individual into a deduction or contribution. This is an overwrite
+          #   operation. If the employee is already enrolled, the enrollment amounts will be
+          #   adjusted. Making the same request multiple times will not create new
+          #   enrollments, but will continue to set the state of the existing enrollment.
           sig do
             params(
               benefit_id: String,
-              individuals: T::Array[FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual],
-              request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+              individuals: T::Array[T.any(FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual, FinchAPI::Util::AnyHash)],
+              request_options: T.nilable(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash))
             )
               .returns(FinchAPI::SinglePage[FinchAPI::Models::HRIS::Benefits::EnrolledIndividual])
           end
-          def enroll_many(benefit_id, individuals: nil, request_options: {})
+          def enroll_many(
+            benefit_id,
+            # Array of the individual_id to enroll and a configuration object.
+            individuals: nil,
+            request_options: {}
+          )
           end
 
+          # Lists individuals currently enrolled in a given deduction.
           sig do
             params(
               benefit_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::HRIS::Benefits::IndividualEnrolledIDsResponse)
           end
           def enrolled_ids(benefit_id, request_options: {})
           end
 
+          # Get enrollment information for the given individuals.
           sig do
             params(
               benefit_id: String,
               individual_ids: 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::HRIS::Benefits::IndividualBenefit])
           end
-          def retrieve_many_benefits(benefit_id, individual_ids: nil, request_options: {})
+          def retrieve_many_benefits(
+            benefit_id,
+            # comma-delimited list of stable Finch uuids for each individual. If empty,
+            #   defaults to all individuals
+            individual_ids: nil,
+            request_options: {}
+          )
           end
 
+          # Unenroll individuals from a deduction or contribution
           sig do
             params(
               benefit_id: String,
               individual_ids: 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::HRIS::Benefits::UnenrolledIndividual])
           end
-          def unenroll_many(benefit_id, individual_ids: nil, request_options: {})
+          def unenroll_many(
+            benefit_id,
+            # Array of individual_ids to unenroll.
+            individual_ids: 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/benefits.rbi

@@ -5,58 +5,77 @@ module FinchAPI
     class HRIS
       class Benefits
         sig { returns(FinchAPI::Resources::HRIS::Benefits::Individuals) }
-        def individuals
-        end
+        attr_reader :individuals
 
+        # Creates a new company-wide deduction or contribution. Please use the
+        #   `/providers` endpoint to view available types for each provider.
         sig do
           params(
             description: String,
-            frequency: T.nilable(Symbol),
-            type: T.nilable(Symbol),
-            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+            frequency: T.nilable(FinchAPI::Models::HRIS::BenefitFrequency::OrSymbol),
+            type: T.nilable(FinchAPI::Models::HRIS::BenefitType::OrSymbol),
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash))
           )
             .returns(FinchAPI::Models::HRIS::CreateCompanyBenefitsResponse)
         end
-        def create(description: nil, frequency: nil, type: nil, request_options: {})
+        def create(
+          # Name of the benefit as it appears in the provider and pay statements. Recommend
+          #   limiting this to <30 characters due to limitations in specific providers (e.g.
+          #   Justworks).
+          description: nil,
+          frequency: nil,
+          # Type of benefit.
+          type: nil,
+          request_options: {}
+        )
         end
 
+        # Lists deductions and contributions information for a given item
         sig do
           params(
             benefit_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::HRIS::CompanyBenefit)
         end
         def retrieve(benefit_id, request_options: {})
         end
 
+        # Updates an existing company-wide deduction or contribution
         sig do
           params(
             benefit_id: String,
             description: 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::HRIS::UpdateCompanyBenefitResponse)
         end
-        def update(benefit_id, description: nil, request_options: {})
+        def update(
+          benefit_id,
+          # Updated name or description.
+          description: nil,
+          request_options: {}
+        )
         end
 
+        # List all company-wide deductions and contributions.
         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::HRIS::CompanyBenefit])
         end
         def list(request_options: {})
         end
 
+        # Get deductions metadata
         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::HRIS::SupportedBenefit])
         end
         def list_supported_benefits(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/company.rbi

@@ -4,15 +4,16 @@ module FinchAPI
   module Resources
     class HRIS
       class Company
+        # Read basic company data
         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::Models::HRIS::HRISCompany)
         end
         def retrieve(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/directory.rbi

@@ -4,30 +4,26 @@ module FinchAPI
   module Resources
     class HRIS
       class Directory
+        # Read company directory and organization structure
         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::IndividualsPage[FinchAPI::Models::HRIS::IndividualInDirectory])
         end
-        def list(limit: nil, offset: nil, request_options: {})
+        def list(
+          # Number of employees to return (defaults to all)
+          limit: nil,
+          # Index to start from (defaults to 0)
+          offset: nil,
+          request_options: {}
+        )
         end
 
-        sig do
-          params(
-            limit: Integer,
-            offset: Integer,
-            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
-          )
-            .returns(FinchAPI::IndividualsPage[FinchAPI::Models::HRIS::IndividualInDirectory])
-        end
-        def list_individuals(limit: nil, 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