finch-api 0.1.0.pre.alpha.1

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

@@ -0,0 +1,33 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module Sandbox
+      class PaymentCreateResponse < FinchAPI::BaseModel
+        sig { returns(String) }
+        def pay_date
+        end
+
+        sig { params(_: String).returns(String) }
+        def pay_date=(_)
+        end
+
+        sig { returns(String) }
+        def payment_id
+        end
+
+        sig { params(_: String).returns(String) }
+        def payment_id=(_)
+        end
+
+        sig { params(pay_date: String, payment_id: String).void }
+        def initialize(pay_date:, payment_id:)
+        end
+
+        sig { override.returns({pay_date: String, payment_id: String}) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    class WebhookEvent < FinchAPI::Union
+      abstract!
+
+      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]]
+          )
+      end
+      private_class_method def self.variants
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# typed: strong
+
+module FinchAPI
+  class Page
+    include FinchAPI::BasePage
+
+    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(FinchAPI::Models::Paging) }
+    def paging
+    end
+
+    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:)
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# typed: strong
+
+module FinchAPI
+  class PooledNetRequester
+    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
+
+    sig { params(conn: Net::HTTP, deadline: Float).void }
+    def self.calibrate_socket_timeout(conn, deadline)
+    end
+
+    sig { params(request: FinchAPI::PooledNetRequester::RequestShape).returns(Net::HTTPGenericRequest) }
+    def self.build_request(request)
+    end
+
+    sig { params(url: URI::Generic, blk: T.proc.params(arg0: Net::HTTP).void).void }
+    private def with_pool(url, &blk)
+    end
+
+    sig do
+      params(request: FinchAPI::PooledNetRequester::RequestShape)
+        .returns([Net::HTTPResponse, T::Enumerable[String]])
+    end
+    def execute(request)
+    end
+
+    sig { void }
+    def initialize
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# typed: strong
+
+module FinchAPI
+  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
+
+    module Converter
+      sig { params(params: T.anything).returns([T.anything, T::Hash[Symbol, T.anything]]) }
+      def dump_request(params)
+      end
+    end
+  end
+
+  class RequestOptions < FinchAPI::BaseModel
+    sig { params(opts: T.any(T.self_type, T::Hash[Symbol, T.anything])).void }
+    def self.validate!(opts)
+    end
+
+    sig { returns(T.nilable(String)) }
+    def idempotency_key
+    end
+
+    sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
+    def idempotency_key=(_)
+    end
+
+    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
+
+    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
+
+    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
+
+    sig { returns(T.nilable(Integer)) }
+    def max_retries
+    end
+
+    sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
+    def max_retries=(_)
+    end
+
+    sig { returns(T.nilable(Float)) }
+    def timeout
+    end
+
+    sig { params(_: T.nilable(Float)).returns(T.nilable(Float)) }
+    def timeout=(_)
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class AccessTokens
+      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]))
+        )
+          .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:)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class Account
+      sig do
+        params(request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])))
+          .returns(FinchAPI::Models::DisconnectResponse)
+      end
+      def disconnect(request_options: {})
+      end
+
+      sig do
+        params(request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])))
+          .returns(FinchAPI::Models::Introspection)
+      end
+      def introspect(request_options: {})
+      end
+
+      sig { params(client: FinchAPI::Client).void }
+      def initialize(client:)
+      end
+    end
+  end
+end

data/rbi/lib/finch-api/resources/connect/sessions.rbi

@@ -0,0 +1,61 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class Connect
+      class Sessions
+        sig do
+          params(
+            customer_id: String,
+            customer_name: String,
+            products: T::Array[Symbol],
+            customer_email: T.nilable(String),
+            integration: T.nilable(FinchAPI::Models::Connect::SessionNewParams::Integration),
+            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]))
+          )
+            .returns(FinchAPI::Models::Connect::SessionNewResponse)
+        end
+        def new(
+          customer_id:,
+          customer_name:,
+          products:,
+          customer_email: nil,
+          integration: nil,
+          manual: nil,
+          minutes_to_expire: nil,
+          redirect_uri: nil,
+          sandbox: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          params(
+            connection_id: String,
+            minutes_to_expire: T.nilable(Integer),
+            products: T.nilable(T::Array[Symbol]),
+            redirect_uri: T.nilable(String),
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+          )
+            .returns(FinchAPI::Models::Connect::SessionReauthenticateResponse)
+        end
+        def reauthenticate(
+          connection_id:,
+          minutes_to_expire: nil,
+          products: nil,
+          redirect_uri: nil,
+          request_options: {}
+        )
+        end
+
+        sig { params(client: FinchAPI::Client).void }
+        def initialize(client:)
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,58 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class Benefits
+        class Individuals
+          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]))
+            )
+              .returns(FinchAPI::SinglePage[FinchAPI::Models::HRIS::Benefits::EnrolledIndividual])
+          end
+          def enroll_many(benefit_id, individuals: nil, request_options: {})
+          end
+
+          sig do
+            params(
+              benefit_id: String,
+              request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+            )
+              .returns(FinchAPI::Models::HRIS::Benefits::IndividualEnrolledIDsResponse)
+          end
+          def enrolled_ids(benefit_id, request_options: {})
+          end
+
+          sig do
+            params(
+              benefit_id: String,
+              individual_ids: String,
+              request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+            )
+              .returns(FinchAPI::SinglePage[FinchAPI::Models::HRIS::Benefits::IndividualBenefit])
+          end
+          def retrieve_many_benefits(benefit_id, individual_ids: nil, request_options: {})
+          end
+
+          sig do
+            params(
+              benefit_id: String,
+              individual_ids: T::Array[String],
+              request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+            )
+              .returns(FinchAPI::SinglePage[FinchAPI::Models::HRIS::Benefits::UnenrolledIndividual])
+          end
+          def unenroll_many(benefit_id, individual_ids: 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/hris/benefits.rbi

@@ -0,0 +1,64 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class Benefits
+        sig { returns(FinchAPI::Resources::HRIS::Benefits::Individuals) }
+        def individuals
+        end
+
+        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]))
+          )
+            .returns(FinchAPI::Models::HRIS::CreateCompanyBenefitsResponse)
+        end
+        def create(description: nil, frequency: nil, type: nil, request_options: {})
+        end
+
+        sig do
+          params(
+            benefit_id: String,
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+          )
+            .returns(FinchAPI::Models::HRIS::CompanyBenefit)
+        end
+        def retrieve(benefit_id, request_options: {})
+        end
+
+        sig do
+          params(
+            benefit_id: String,
+            description: String,
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+          )
+            .returns(FinchAPI::Models::HRIS::UpdateCompanyBenefitResponse)
+        end
+        def update(benefit_id, description: nil, request_options: {})
+        end
+
+        sig do
+          params(request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])))
+            .returns(FinchAPI::SinglePage[FinchAPI::Models::HRIS::CompanyBenefit])
+        end
+        def list(request_options: {})
+        end
+
+        sig do
+          params(request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])))
+            .returns(FinchAPI::SinglePage[FinchAPI::Models::HRIS::SupportedBenefit])
+        end
+        def list_supported_benefits(request_options: {})
+        end
+
+        sig { params(client: FinchAPI::Client).void }
+        def initialize(client:)
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,35 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class Directory
+        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(limit: nil, 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:)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class 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]))
+          )
+            .returns(FinchAPI::Models::HRIS::DocumentListResponse)
+        end
+        def list(individual_ids: nil, limit: nil, offset: nil, types: nil, request_options: {})
+        end
+
+        sig do
+          params(
+            document_id: String,
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+          )
+            .returns(T.any(FinchAPI::Models::HRIS::W42020, FinchAPI::Models::HRIS::W42005))
+        end
+        def retreive(document_id, request_options: {})
+        end
+
+        sig { params(client: FinchAPI::Client).void }
+        def initialize(client:)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class Employments
+        sig do
+          params(
+            requests: T::Array[FinchAPI::Models::HRIS::EmploymentRetrieveManyParams::Request],
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+          )
+            .returns(FinchAPI::ResponsesPage[FinchAPI::Models::HRIS::EmploymentDataResponse])
+        end
+        def retrieve_many(requests:, request_options: {})
+        end
+
+        sig { params(client: FinchAPI::Client).void }
+        def initialize(client:)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class Individuals
+        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]))
+          )
+            .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:)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class PayStatements
+        sig do
+          params(
+            requests: T::Array[FinchAPI::Models::HRIS::PayStatementRetrieveManyParams::Request],
+            request_options: T.nilable(T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything]))
+          )
+            .returns(FinchAPI::ResponsesPage[FinchAPI::Models::HRIS::PayStatementResponse])
+        end
+        def retrieve_many(requests:, request_options: {})
+        end
+
+        sig { params(client: FinchAPI::Client).void }
+        def initialize(client:)
+        end
+      end
+    end
+  end
+end

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

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