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

data/rbi/finch_api/models/sandbox/payment_create_response.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module Sandbox
+      class PaymentCreateResponse < FinchAPI::Internal::Type::BaseModel
+        # The date of the payment.
+        sig { returns(String) }
+        attr_accessor :pay_date
+
+        # The ID of the payment.
+        sig { returns(String) }
+        attr_accessor :payment_id
+
+        sig { params(pay_date: String, payment_id: String).returns(T.attached_class) }
+        def self.new(
+          # The date of the payment.
+          pay_date:,
+          # The ID of the payment.
+          payment_id:
+        ); end
+        sig { override.returns({pay_date: String, payment_id: String}) }
+        def to_hash; end
+      end
+    end
+  end
+end

data/rbi/finch_api/models/webhook_event.rbi

@@ -0,0 +1,17 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module WebhookEvent
+      extend FinchAPI::Internal::Type::Union
+
+      sig do
+        override
+          .returns(
+            [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
+      def self.variants; end
+    end
+  end
+end

data/rbi/finch_api/request_options.rbi

@@ -0,0 +1,48 @@
+# typed: strong
+
+module FinchAPI
+  RequestOpts = T.type_alias { T.any(FinchAPI::RequestOptions, FinchAPI::Internal::AnyHash) }
+
+  # 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::Internal::Type::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)) }
+    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))])) }
+    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)])) }
+    attr_accessor :extra_headers
+
+    # 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)) }
+    attr_accessor :max_retries
+
+    # Request timeout in seconds.
+    sig { returns(T.nilable(Float)) }
+    attr_accessor :timeout
+
+    # Returns a new instance of RequestOptions.
+    sig { params(values: FinchAPI::Internal::AnyHash).returns(T.attached_class) }
+    def self.new(values = {}); end
+  end
+end

data/rbi/finch_api/resources/access_tokens.rbi

@@ -0,0 +1,24 @@
+# typed: strong
+
+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: FinchAPI::RequestOpts
+        )
+          .returns(FinchAPI::Models::CreateAccessTokenResponse)
+      end
+      def create(code:, client_id: nil, client_secret: nil, redirect_uri: nil, request_options: {}); end
+
+      # @api private
+      sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+      def self.new(client:); end
+    end
+  end
+end

data/rbi/finch_api/resources/account.rbi

@@ -0,0 +1,19 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class Account
+      # Disconnect one or more `access_token`s from your application.
+      sig { params(request_options: FinchAPI::RequestOpts).returns(FinchAPI::Models::DisconnectResponse) }
+      def disconnect(request_options: {}); end
+
+      # Read account information associated with an `access_token`
+      sig { params(request_options: FinchAPI::RequestOpts).returns(FinchAPI::Models::Introspection) }
+      def introspect(request_options: {}); end
+
+      # @api private
+      sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+      def self.new(client:); end
+    end
+  end
+end

data/rbi/finch_api/resources/connect/sessions.rbi

@@ -0,0 +1,66 @@
+# typed: strong
+
+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[FinchAPI::Models::Connect::SessionNewParams::Product::OrSymbol],
+            customer_email: T.nilable(String),
+            integration: T.nilable(T.any(FinchAPI::Models::Connect::SessionNewParams::Integration, FinchAPI::Internal::AnyHash)),
+            manual: T.nilable(T::Boolean),
+            minutes_to_expire: T.nilable(Float),
+            redirect_uri: T.nilable(String),
+            sandbox: T.nilable(FinchAPI::Models::Connect::SessionNewParams::Sandbox::OrSymbol),
+            request_options: FinchAPI::RequestOpts
+          )
+            .returns(FinchAPI::Models::Connect::SessionNewResponse)
+        end
+        def new(
+          customer_id:,
+          customer_name:,
+          products:,
+          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,
+          request_options: {}
+        ); 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[FinchAPI::Models::Connect::SessionReauthenticateParams::Product::OrSymbol]),
+            redirect_uri: T.nilable(String),
+            request_options: FinchAPI::RequestOpts
+          )
+            .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
+        # @api private
+        sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+        def self.new(client:); end
+      end
+    end
+  end
+end

data/rbi/finch_api/resources/connect.rbi

@@ -0,0 +1,14 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class Connect
+      sig { returns(FinchAPI::Resources::Connect::Sessions) }
+      attr_reader :sessions
+
+      # @api private
+      sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+      def self.new(client:); end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    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[
+                T.any(
+                  FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual,
+                  FinchAPI::Internal::AnyHash
+                )
+              ],
+              request_options: FinchAPI::RequestOpts
+            )
+              .returns(FinchAPI::Models::HRIS::Benefits::EnrolledIndividualBenefitResponse)
+          end
+          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: FinchAPI::RequestOpts)
+              .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: FinchAPI::RequestOpts)
+              .returns(FinchAPI::Internal::SinglePage[FinchAPI::Models::HRIS::Benefits::IndividualBenefit])
+          end
+          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: FinchAPI::RequestOpts
+            )
+              .returns(FinchAPI::Models::HRIS::Benefits::UnenrolledIndividualBenefitResponse)
+          end
+          def unenroll_many(
+            benefit_id,
+            # Array of individual_ids to unenroll.
+            individual_ids: nil,
+            request_options: {}
+          ); end
+          # @api private
+          sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+          def self.new(client:); end
+        end
+      end
+    end
+  end
+end

data/rbi/finch_api/resources/hris/benefits.rbi

@@ -0,0 +1,75 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class Benefits
+        sig { returns(FinchAPI::Resources::HRIS::Benefits::Individuals) }
+        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(
+            company_contribution: T.nilable(
+              T.any(FinchAPI::Models::HRIS::BenefitCreateParams::CompanyContribution, FinchAPI::Internal::AnyHash)
+            ),
+            description: String,
+            frequency: T.nilable(FinchAPI::Models::HRIS::BenefitFrequency::OrSymbol),
+            type: T.nilable(FinchAPI::Models::HRIS::BenefitType::OrSymbol),
+            request_options: FinchAPI::RequestOpts
+          )
+            .returns(FinchAPI::Models::HRIS::CreateCompanyBenefitsResponse)
+        end
+        def create(
+          # The company match for this benefit.
+          company_contribution: nil,
+          # 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,
+          # The frequency of the benefit deduction/contribution.
+          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: FinchAPI::RequestOpts)
+            .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: FinchAPI::RequestOpts)
+            .returns(FinchAPI::Models::HRIS::UpdateCompanyBenefitResponse)
+        end
+        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: FinchAPI::RequestOpts)
+            .returns(FinchAPI::Internal::SinglePage[FinchAPI::Models::HRIS::CompanyBenefit])
+        end
+        def list(request_options: {}); end
+
+        # Get deductions metadata
+        sig do
+          params(request_options: FinchAPI::RequestOpts)
+            .returns(FinchAPI::Internal::SinglePage[FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse])
+        end
+        def list_supported_benefits(request_options: {}); end
+
+        # @api private
+        sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+        def self.new(client:); end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class Company
+        class PayStatementItem
+          class Rules
+            # **Beta:** this endpoint currently serves employers onboarded after March 4th and
+            # historical support will be added soon Custom rules can be created to associate
+            # specific attributes to pay statement items depending on the use case. For
+            # example, pay statement items that meet certain conditions can be labeled as a
+            # pre-tax 401k. This metadata can be retrieved where pay statement item
+            # information is available.
+            sig do
+              params(
+                attributes: T.any(
+                  FinchAPI::Models::HRIS::Company::PayStatementItem::RuleCreateParams::Attributes,
+                  FinchAPI::Internal::AnyHash
+                ),
+                conditions: T::Array[
+                  T.any(
+                    FinchAPI::Models::HRIS::Company::PayStatementItem::RuleCreateParams::Condition,
+                    FinchAPI::Internal::AnyHash
+                  )
+                ],
+                effective_end_date: T.nilable(String),
+                effective_start_date: T.nilable(String),
+                entity_type: FinchAPI::Models::HRIS::Company::PayStatementItem::RuleCreateParams::EntityType::OrSymbol,
+                request_options: FinchAPI::RequestOpts
+              )
+                .returns(FinchAPI::Models::HRIS::Company::PayStatementItem::RuleCreateResponse)
+            end
+            def create(
+              # Specifies the fields to be applied when the condition is met.
+              attributes: nil,
+              conditions: nil,
+              # Specifies when the rules should stop applying rules based on the date.
+              effective_end_date: nil,
+              # Specifies when the rule should begin applying based on the date.
+              effective_start_date: nil,
+              # The entity type to which the rule is applied.
+              entity_type: nil,
+              request_options: {}
+            ); end
+            # **Beta:** this endpoint currently serves employers onboarded after March 4th and
+            # historical support will be added soon Update a rule for a pay statement item.
+            sig do
+              params(rule_id: String, optional_property: T.anything, request_options: FinchAPI::RequestOpts)
+                .returns(FinchAPI::Models::HRIS::Company::PayStatementItem::RuleUpdateResponse)
+            end
+            def update(rule_id, optional_property: nil, request_options: {}); end
+
+            # **Beta:** this endpoint currently serves employers onboarded after March 4th and
+            # historical support will be added soon List all rules of a connection account.
+            sig do
+              params(request_options: FinchAPI::RequestOpts)
+                .returns(
+                  FinchAPI::Internal::ResponsesPage[FinchAPI::Models::HRIS::Company::PayStatementItem::RuleListResponse]
+                )
+            end
+            def list(request_options: {}); end
+
+            # **Beta:** this endpoint currently serves employers onboarded after March 4th and
+            # historical support will be added soon Delete a rule for a pay statement item.
+            sig do
+              params(rule_id: String, request_options: FinchAPI::RequestOpts)
+                .returns(FinchAPI::Models::HRIS::Company::PayStatementItem::RuleDeleteResponse)
+            end
+            def delete(rule_id, request_options: {}); end
+
+            # @api private
+            sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+            def self.new(client:); end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class Company
+        class PayStatementItem
+          sig { returns(FinchAPI::Resources::HRIS::Company::PayStatementItem::Rules) }
+          attr_reader :rules
+
+          # **Beta:** this endpoint currently serves employers onboarded after March 4th and
+          # historical support will be added soon Retrieve a list of detailed pay statement
+          # items for the access token's connection account.
+          sig do
+            params(
+              categories: T::Array[FinchAPI::Models::HRIS::Company::PayStatementItemListParams::Category::OrSymbol],
+              end_date: Date,
+              name: String,
+              start_date: Date,
+              type: String,
+              request_options: FinchAPI::RequestOpts
+            )
+              .returns(FinchAPI::Internal::ResponsesPage[FinchAPI::Models::HRIS::Company::PayStatementItemListResponse])
+          end
+          def list(
+            # Comma-delimited list of pay statement item categories to filter on. If empty,
+            # defaults to all categories.
+            categories: nil,
+            # The end date to retrieve pay statement items by via their last seen pay date in
+            # `YYYY-MM-DD` format.
+            end_date: nil,
+            # Case-insensitive partial match search by pay statement item name.
+            name: nil,
+            # The start date to retrieve pay statement items by via their last seen pay date
+            # (inclusive) in `YYYY-MM-DD` format.
+            start_date: nil,
+            # String search by pay statement item type.
+            type: nil,
+            request_options: {}
+          ); end
+          # @api private
+          sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+          def self.new(client:); end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class Company
+        sig { returns(FinchAPI::Resources::HRIS::Company::PayStatementItem) }
+        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
+
+        # @api private
+        sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+        def self.new(client:); end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class HRIS
+      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])
+        end
+        def list(
+          # Number of employees to return (defaults to all)
+          limit: nil,
+          # Index to start from (defaults to 0)
+          offset: nil,
+          request_options: {}
+        ); end
+        # @api private
+        sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+        def self.new(client:); end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# typed: strong
+
+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[FinchAPI::Models::HRIS::DocumentListParams::Type::OrSymbol],
+            request_options: FinchAPI::RequestOpts
+          )
+            .returns(FinchAPI::Models::HRIS::DocumentListResponse)
+        end
+        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: FinchAPI::RequestOpts)
+            .returns(T.any(FinchAPI::Models::HRIS::W42020, FinchAPI::Models::HRIS::W42005))
+        end
+        def retreive(
+          # The unique identifier of the document.
+          document_id,
+          request_options: {}
+        ); end
+        # @api private
+        sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+        def self.new(client:); end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class Employments
+        # 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
+          )
+            .returns(FinchAPI::Internal::ResponsesPage[FinchAPI::Models::HRIS::EmploymentDataResponse])
+        end
+        def retrieve_many(
+          # The array of batch requests.
+          requests:,
+          request_options: {}
+        ); end
+        # @api private
+        sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+        def self.new(client:); end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class Individuals
+        # 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
+          )
+            .returns(FinchAPI::Internal::ResponsesPage[FinchAPI::Models::HRIS::IndividualResponse])
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# typed: strong
+
+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[T.any(FinchAPI::Models::HRIS::PayStatementRetrieveManyParams::Request, FinchAPI::Internal::AnyHash)],
+            request_options: FinchAPI::RequestOpts
+          )
+            .returns(FinchAPI::Internal::ResponsesPage[FinchAPI::Models::HRIS::PayStatementResponse])
+        end
+        def retrieve_many(
+          # The array of batch requests.
+          requests:,
+          request_options: {}
+        ); end
+        # @api private
+        sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+        def self.new(client:); end
+      end
+    end
+  end
+end