finch-api 0.1.0.pre.alpha.1

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

@@ -0,0 +1,43 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class HRIS
+      sig { returns(FinchAPI::Resources::HRIS::Company) }
+      def company
+      end
+
+      sig { returns(FinchAPI::Resources::HRIS::Directory) }
+      def directory
+      end
+
+      sig { returns(FinchAPI::Resources::HRIS::Individuals) }
+      def individuals
+      end
+
+      sig { returns(FinchAPI::Resources::HRIS::Employments) }
+      def employments
+      end
+
+      sig { returns(FinchAPI::Resources::HRIS::Payments) }
+      def payments
+      end
+
+      sig { returns(FinchAPI::Resources::HRIS::PayStatements) }
+      def pay_statements
+      end
+
+      sig { returns(FinchAPI::Resources::HRIS::Documents) }
+      def documents
+      end
+
+      sig { returns(FinchAPI::Resources::HRIS::Benefits) }
+      def benefits
+      end
+
+      sig { params(client: FinchAPI::Client).void }
+      def initialize(client:)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class Jobs
+      class Automated
+        sig do
+          params(
+            type: Symbol,
+            params: FinchAPI::Models::Jobs::AutomatedCreateParams::Params,
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+          )
+            .returns(FinchAPI::Models::Jobs::AutomatedCreateResponse)
+        end
+        def create(type:, params:, request_options: {})
+        end
+
+        sig do
+          params(
+            job_id: String,
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+          )
+            .returns(FinchAPI::Models::Jobs::AutomatedAsyncJob)
+        end
+        def retrieve(job_id, 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::Page[FinchAPI::Models::Jobs::AutomatedAsyncJob])
+        end
+        def list(limit: nil, offset: nil, request_options: {})
+        end
+
+        sig { params(client: FinchAPI::Client).void }
+        def initialize(client:)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class Jobs
+      class Manual
+        sig do
+          params(
+            job_id: String,
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+          )
+            .returns(FinchAPI::Models::Jobs::ManualAsyncJob)
+        end
+        def retrieve(job_id, request_options: {})
+        end
+
+        sig { params(client: FinchAPI::Client).void }
+        def initialize(client:)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class Jobs
+      sig { returns(FinchAPI::Resources::Jobs::Automated) }
+      def automated
+      end
+
+      sig { returns(FinchAPI::Resources::Jobs::Manual) }
+      def manual
+      end
+
+      sig { params(client: FinchAPI::Client).void }
+      def initialize(client:)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class Payroll
+      class PayGroups
+        sig do
+          params(
+            pay_group_id: String,
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+          )
+            .returns(FinchAPI::Models::Payroll::PayGroupRetrieveResponse)
+        end
+        def retrieve(pay_group_id, request_options: {})
+        end
+
+        sig do
+          params(
+            individual_id: String,
+            pay_frequencies: T::Array[String],
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+          )
+            .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:)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class Payroll
+      sig { returns(FinchAPI::Resources::Payroll::PayGroups) }
+      def pay_groups
+      end
+
+      sig { params(client: FinchAPI::Client).void }
+      def initialize(client:)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class Providers
+      sig do
+        params(request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])))
+          .returns(FinchAPI::SinglePage[FinchAPI::Models::Provider])
+      end
+      def list(request_options: {})
+      end
+
+      sig { params(client: FinchAPI::Client).void }
+      def initialize(client:)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class RequestForwarding
+      sig do
+        params(
+          method_: String,
+          route: String,
+          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]))
+        )
+          .returns(FinchAPI::Models::RequestForwardingForwardResponse)
+      end
+      def forward(method_:, route:, data: nil, headers: nil, params: nil, request_options: {})
+      end
+
+      sig { params(client: FinchAPI::Client).void }
+      def initialize(client:)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class Sandbox
+      class Company
+        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)]),
+            ein: T.nilable(String),
+            entity: T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateParams::Entity),
+            legal_name: T.nilable(String),
+            locations: T.nilable(T::Array[T.nilable(FinchAPI::Models::Location)]),
+            primary_email: T.nilable(String),
+            primary_phone_number: T.nilable(String),
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+          )
+            .returns(FinchAPI::Models::Sandbox::CompanyUpdateResponse)
+        end
+        def update(
+          accounts:,
+          departments:,
+          ein:,
+          entity:,
+          legal_name:,
+          locations:,
+          primary_email:,
+          primary_phone_number:,
+          request_options: {}
+        )
+        end
+
+        sig { params(client: FinchAPI::Client).void }
+        def initialize(client:)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class Sandbox
+      class Connections
+        class Accounts
+          sig do
+            params(
+              company_id: String,
+              provider_id: String,
+              authentication_type: Symbol,
+              products: T::Array[String],
+              request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+            )
+              .returns(FinchAPI::Models::Sandbox::Connections::AccountCreateResponse)
+          end
+          def create(company_id:, provider_id:, authentication_type: nil, products: nil, request_options: {})
+          end
+
+          sig do
+            params(
+              connection_status: Symbol,
+              request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+            )
+              .returns(FinchAPI::Models::Sandbox::Connections::AccountUpdateResponse)
+          end
+          def update(connection_status: nil, request_options: {})
+          end
+
+          sig { params(client: FinchAPI::Client).void }
+          def initialize(client:)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class Sandbox
+      class Connections
+        sig { returns(FinchAPI::Resources::Sandbox::Connections::Accounts) }
+        def accounts
+        end
+
+        sig do
+          params(
+            provider_id: String,
+            authentication_type: Symbol,
+            employee_size: Integer,
+            products: T::Array[String],
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+          )
+            .returns(FinchAPI::Models::Sandbox::ConnectionCreateResponse)
+        end
+        def create(
+          provider_id:,
+          authentication_type: nil,
+          employee_size: nil,
+          products: nil,
+          request_options: {}
+        )
+        end
+
+        sig { params(client: FinchAPI::Client).void }
+        def initialize(client:)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class Sandbox
+      class Directory
+        sig do
+          params(
+            body: T::Array[FinchAPI::Models::Sandbox::DirectoryCreateParams::Body],
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+          )
+            .returns(FinchAPI::Models::Sandbox::DirectoryCreateResponse)
+        end
+        def create(body: nil, request_options: {})
+        end
+
+        sig { params(client: FinchAPI::Client).void }
+        def initialize(client:)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class Sandbox
+      class Employment
+        sig do
+          params(
+            individual_id: String,
+            class_code: T.nilable(String),
+            custom_fields: T::Array[FinchAPI::Models::Sandbox::EmploymentUpdateParams::CustomField],
+            department: T.nilable(FinchAPI::Models::Sandbox::EmploymentUpdateParams::Department),
+            employment: T.nilable(FinchAPI::Models::Sandbox::EmploymentUpdateParams::Employment),
+            employment_status: T.nilable(Symbol),
+            end_date: T.nilable(String),
+            first_name: T.nilable(String),
+            income: T.nilable(FinchAPI::Models::Income),
+            income_history: T.nilable(T::Array[T.nilable(FinchAPI::Models::Income)]),
+            is_active: T.nilable(T::Boolean),
+            last_name: T.nilable(String),
+            latest_rehire_date: T.nilable(String),
+            location: T.nilable(FinchAPI::Models::Location),
+            manager: T.nilable(FinchAPI::Models::Sandbox::EmploymentUpdateParams::Manager),
+            middle_name: T.nilable(String),
+            source_id: String,
+            start_date: T.nilable(String),
+            title: T.nilable(String),
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+          )
+            .returns(FinchAPI::Models::Sandbox::EmploymentUpdateResponse)
+        end
+        def update(
+          individual_id,
+          class_code: nil,
+          custom_fields: nil,
+          department: nil,
+          employment: nil,
+          employment_status: nil,
+          end_date: nil,
+          first_name: nil,
+          income: nil,
+          income_history: nil,
+          is_active: nil,
+          last_name: nil,
+          latest_rehire_date: nil,
+          location: nil,
+          manager: nil,
+          middle_name: nil,
+          source_id: nil,
+          start_date: nil,
+          title: nil,
+          request_options: {}
+        )
+        end
+
+        sig { params(client: FinchAPI::Client).void }
+        def initialize(client:)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class Sandbox
+      class Individual
+        sig do
+          params(
+            individual_id: String,
+            dob: T.nilable(String),
+            emails: T.nilable(T::Array[FinchAPI::Models::Sandbox::IndividualUpdateParams::Email]),
+            encrypted_ssn: T.nilable(String),
+            ethnicity: T.nilable(Symbol),
+            first_name: T.nilable(String),
+            gender: T.nilable(Symbol),
+            last_name: T.nilable(String),
+            middle_name: T.nilable(String),
+            phone_numbers: T.nilable(T::Array[T.nilable(FinchAPI::Models::Sandbox::IndividualUpdateParams::PhoneNumber)]),
+            preferred_name: T.nilable(String),
+            residence: T.nilable(FinchAPI::Models::Location),
+            ssn: T.nilable(String),
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+          )
+            .returns(FinchAPI::Models::Sandbox::IndividualUpdateResponse)
+        end
+        def update(
+          individual_id,
+          dob: nil,
+          emails: nil,
+          encrypted_ssn: nil,
+          ethnicity: nil,
+          first_name: nil,
+          gender: nil,
+          last_name: nil,
+          middle_name: nil,
+          phone_numbers: nil,
+          preferred_name: nil,
+          residence: nil,
+          ssn: nil,
+          request_options: {}
+        )
+        end
+
+        sig { params(client: FinchAPI::Client).void }
+        def initialize(client:)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class Sandbox
+      class Jobs
+        class Configuration
+          sig do
+            params(request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])))
+              .returns(FinchAPI::Models::Sandbox::Jobs::ConfigurationRetrieveResponse)
+          end
+          def retrieve(request_options: {})
+          end
+
+          sig do
+            params(
+              completion_status: Symbol,
+              type: Symbol,
+              request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+            )
+              .returns(FinchAPI::Models::Sandbox::Jobs::SandboxJobConfiguration)
+          end
+          def update(completion_status:, type:, request_options: {})
+          end
+
+          sig { params(client: FinchAPI::Client).void }
+          def initialize(client:)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class Sandbox
+      class Jobs
+        sig { returns(FinchAPI::Resources::Sandbox::Jobs::Configuration) }
+        def configuration
+        end
+
+        sig do
+          params(
+            type: Symbol,
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+          )
+            .returns(FinchAPI::Models::Sandbox::JobCreateResponse)
+        end
+        def create(type:, request_options: {})
+        end
+
+        sig { params(client: FinchAPI::Client).void }
+        def initialize(client:)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class Sandbox
+      class Payment
+        sig do
+          params(
+            end_date: String,
+            pay_statements: T::Array[FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement],
+            start_date: String,
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+          )
+            .returns(FinchAPI::Models::Sandbox::PaymentCreateResponse)
+        end
+        def create(end_date: nil, pay_statements: nil, start_date: nil, request_options: {})
+        end
+
+        sig { params(client: FinchAPI::Client).void }
+        def initialize(client:)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class Sandbox
+      sig { returns(FinchAPI::Resources::Sandbox::Connections) }
+      def connections
+      end
+
+      sig { returns(FinchAPI::Resources::Sandbox::Company) }
+      def company
+      end
+
+      sig { returns(FinchAPI::Resources::Sandbox::Directory) }
+      def directory
+      end
+
+      sig { returns(FinchAPI::Resources::Sandbox::Individual) }
+      def individual
+      end
+
+      sig { returns(FinchAPI::Resources::Sandbox::Employment) }
+      def employment
+      end
+
+      sig { returns(FinchAPI::Resources::Sandbox::Payment) }
+      def payment
+      end
+
+      sig { returns(FinchAPI::Resources::Sandbox::Jobs) }
+      def jobs
+      end
+
+      sig { params(client: FinchAPI::Client).void }
+      def initialize(client:)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class Webhooks
+      sig { params(client: FinchAPI::Client).void }
+      def initialize(client:)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# typed: strong
+
+module FinchAPI
+  class ResponsesPage
+    include FinchAPI::BasePage
+
+    Elem = type_member
+
+    sig { returns(T::Array[Elem]) }
+    def responses
+    end
+
+    sig { params(_: T::Array[Elem]).returns(T::Array[Elem]) }
+    def responses=(_)
+    end
+
+    sig do
+      params(
+        client: FinchAPI::BaseClient,
+        req: FinchAPI::BaseClient::RequestComponentsShape,
+        headers: T.any(T::Hash[String, String], Net::HTTPHeader),
+        unwrapped: T::Array[T.anything]
+      )
+        .void
+    end
+    def initialize(client:, req:, headers:, unwrapped:)
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# typed: strong
+
+module FinchAPI
+  class SinglePage < ::Array
+    include FinchAPI::BasePage
+
+    Elem = type_member
+
+    sig do
+      params(
+        client: FinchAPI::BaseClient,
+        req: FinchAPI::BaseClient::RequestComponentsShape,
+        headers: T.any(T::Hash[String, String], Net::HTTPHeader),
+        unwrapped: T::Array[T.anything]
+      )
+        .void
+    end
+    def initialize(client:, req:, headers:, unwrapped:)
+    end
+
+    sig { override.returns(T::Boolean) }
+    def next_page?
+    end
+
+    sig { override.returns(T.self_type) }
+    def next_page
+    end
+
+    sig { override.params(blk: T.proc.params(arg0: Elem).void).void }
+    def auto_paging_each(&blk)
+    end
+  end
+end