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

data/lib/finch_api/resources/access_tokens.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Resources
+    class AccessTokens
+      # Exchange the authorization code for an access token
+      #
+      # @overload create(code:, client_id: nil, client_secret: nil, redirect_uri: nil, request_options: {})
+      #
+      # @param code [String]
+      # @param client_id [String]
+      # @param client_secret [String]
+      # @param redirect_uri [String]
+      # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [FinchAPI::Models::CreateAccessTokenResponse]
+      #
+      # @see FinchAPI::Models::AccessTokenCreateParams
+      def create(params)
+        parsed, options = FinchAPI::Models::AccessTokenCreateParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "auth/token",
+          body: parsed,
+          model: FinchAPI::Models::CreateAccessTokenResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [FinchAPI::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/finch_api/resources/account.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Resources
+    class Account
+      # Disconnect one or more `access_token`s from your application.
+      #
+      # @overload disconnect(request_options: {})
+      #
+      # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [FinchAPI::Models::DisconnectResponse]
+      #
+      # @see FinchAPI::Models::AccountDisconnectParams
+      def disconnect(params = {})
+        @client.request(
+          method: :post,
+          path: "disconnect",
+          model: FinchAPI::Models::DisconnectResponse,
+          options: params[:request_options]
+        )
+      end
+
+      # Read account information associated with an `access_token`
+      #
+      # @overload introspect(request_options: {})
+      #
+      # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [FinchAPI::Models::Introspection]
+      #
+      # @see FinchAPI::Models::AccountIntrospectParams
+      def introspect(params = {})
+        @client.request(
+          method: :get,
+          path: "introspect",
+          model: FinchAPI::Models::Introspection,
+          options: params[:request_options]
+        )
+      end
+
+      # @api private
+      #
+      # @param client [FinchAPI::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/finch_api/resources/connect/sessions.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Resources
+    class Connect
+      class Sessions
+        # Some parameter documentations has been truncated, see
+        # {FinchAPI::Models::Connect::SessionNewParams} for more details.
+        #
+        # Create a new connect session for an employer
+        #
+        # @overload new(customer_id:, customer_name:, products:, customer_email: nil, integration: nil, manual: nil, minutes_to_expire: nil, redirect_uri: nil, sandbox: nil, request_options: {})
+        #
+        # @param customer_id [String]
+        #
+        # @param customer_name [String]
+        #
+        # @param products [Array<Symbol, FinchAPI::Models::Connect::SessionNewParams::Product>]
+        #
+        # @param customer_email [String, nil]
+        #
+        # @param integration [FinchAPI::Models::Connect::SessionNewParams::Integration, nil]
+        #
+        # @param manual [Boolean, nil]
+        #
+        # @param minutes_to_expire [Float, nil] The number of minutes until the session expires (defaults to 43,200, which is 30
+        # ...
+        #
+        # @param redirect_uri [String, nil]
+        #
+        # @param sandbox [Symbol, FinchAPI::Models::Connect::SessionNewParams::Sandbox, nil]
+        #
+        # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [FinchAPI::Models::Connect::SessionNewResponse]
+        #
+        # @see FinchAPI::Models::Connect::SessionNewParams
+        def new(params)
+          parsed, options = FinchAPI::Models::Connect::SessionNewParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: "connect/sessions",
+            body: parsed,
+            model: FinchAPI::Models::Connect::SessionNewResponse,
+            options: options
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {FinchAPI::Models::Connect::SessionReauthenticateParams} for more details.
+        #
+        # Create a new Connect session for reauthenticating an existing connection
+        #
+        # @overload reauthenticate(connection_id:, minutes_to_expire: nil, products: nil, redirect_uri: nil, request_options: {})
+        #
+        # @param connection_id [String] The ID of the existing connection to reauthenticate
+        #
+        # @param minutes_to_expire [Integer, nil] The number of minutes until the session expires (defaults to 43,200, which is 30
+        # ...
+        #
+        # @param products [Array<Symbol, FinchAPI::Models::Connect::SessionReauthenticateParams::Product>, nil] The products to request access to (optional for reauthentication)
+        #
+        # @param redirect_uri [String, nil] The URI to redirect to after the Connect flow is completed
+        #
+        # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [FinchAPI::Models::Connect::SessionReauthenticateResponse]
+        #
+        # @see FinchAPI::Models::Connect::SessionReauthenticateParams
+        def reauthenticate(params)
+          parsed, options = FinchAPI::Models::Connect::SessionReauthenticateParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: "connect/sessions/reauthenticate",
+            body: parsed,
+            model: FinchAPI::Models::Connect::SessionReauthenticateResponse,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [FinchAPI::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/finch_api/resources/connect.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Resources
+    class Connect
+      # @return [FinchAPI::Resources::Connect::Sessions]
+      attr_reader :sessions
+
+      # @api private
+      #
+      # @param client [FinchAPI::Client]
+      def initialize(client:)
+        @client = client
+        @sessions = FinchAPI::Resources::Connect::Sessions.new(client: client)
+      end
+    end
+  end
+end

data/lib/finch_api/resources/hris/benefits/individuals.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+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.
+          #
+          # @overload enroll_many(benefit_id, individuals: nil, request_options: {})
+          #
+          # @param benefit_id [String]
+          #
+          # @param individuals [Array<FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual>] Array of the individual_id to enroll and a configuration object.
+          #
+          # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [FinchAPI::Models::HRIS::Benefits::EnrolledIndividualBenefitResponse]
+          #
+          # @see FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams
+          def enroll_many(benefit_id, params = {})
+            parsed, options = FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams.dump_request(params)
+            @client.request(
+              method: :post,
+              path: ["employer/benefits/%1$s/individuals", benefit_id],
+              body: parsed[:individuals],
+              model: FinchAPI::Models::HRIS::Benefits::EnrolledIndividualBenefitResponse,
+              options: options
+            )
+          end
+
+          # Lists individuals currently enrolled in a given deduction.
+          #
+          # @overload enrolled_ids(benefit_id, request_options: {})
+          #
+          # @param benefit_id [String]
+          # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [FinchAPI::Models::HRIS::Benefits::IndividualEnrolledIDsResponse]
+          #
+          # @see FinchAPI::Models::HRIS::Benefits::IndividualEnrolledIDsParams
+          def enrolled_ids(benefit_id, params = {})
+            @client.request(
+              method: :get,
+              path: ["employer/benefits/%1$s/enrolled", benefit_id],
+              model: FinchAPI::Models::HRIS::Benefits::IndividualEnrolledIDsResponse,
+              options: params[:request_options]
+            )
+          end
+
+          # Some parameter documentations has been truncated, see
+          # {FinchAPI::Models::HRIS::Benefits::IndividualRetrieveManyBenefitsParams} for
+          # more details.
+          #
+          # Get enrollment information for the given individuals.
+          #
+          # @overload retrieve_many_benefits(benefit_id, individual_ids: nil, request_options: {})
+          #
+          # @param benefit_id [String]
+          #
+          # @param individual_ids [String] comma-delimited list of stable Finch uuids for each individual. If empty, defaul
+          # ...
+          #
+          # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [FinchAPI::Internal::SinglePage<FinchAPI::Models::HRIS::Benefits::IndividualBenefit>]
+          #
+          # @see FinchAPI::Models::HRIS::Benefits::IndividualRetrieveManyBenefitsParams
+          def retrieve_many_benefits(benefit_id, params = {})
+            parsed, options =
+              FinchAPI::Models::HRIS::Benefits::IndividualRetrieveManyBenefitsParams.dump_request(params)
+            @client.request(
+              method: :get,
+              path: ["employer/benefits/%1$s/individuals", benefit_id],
+              query: parsed,
+              page: FinchAPI::Internal::SinglePage,
+              model: FinchAPI::Models::HRIS::Benefits::IndividualBenefit,
+              options: options
+            )
+          end
+
+          # Unenroll individuals from a deduction or contribution
+          #
+          # @overload unenroll_many(benefit_id, individual_ids: nil, request_options: {})
+          #
+          # @param benefit_id [String]
+          #
+          # @param individual_ids [Array<String>] Array of individual_ids to unenroll.
+          #
+          # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [FinchAPI::Models::HRIS::Benefits::UnenrolledIndividualBenefitResponse]
+          #
+          # @see FinchAPI::Models::HRIS::Benefits::IndividualUnenrollManyParams
+          def unenroll_many(benefit_id, params = {})
+            parsed, options = FinchAPI::Models::HRIS::Benefits::IndividualUnenrollManyParams.dump_request(params)
+            @client.request(
+              method: :delete,
+              path: ["employer/benefits/%1$s/individuals", benefit_id],
+              body: parsed,
+              model: FinchAPI::Models::HRIS::Benefits::UnenrolledIndividualBenefitResponse,
+              options: options
+            )
+          end
+
+          # @api private
+          #
+          # @param client [FinchAPI::Client]
+          def initialize(client:)
+            @client = client
+          end
+        end
+      end
+    end
+  end
+end

data/lib/finch_api/resources/hris/benefits.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class Benefits
+        # @return [FinchAPI::Resources::HRIS::Benefits::Individuals]
+        attr_reader :individuals
+
+        # Some parameter documentations has been truncated, see
+        # {FinchAPI::Models::HRIS::BenefitCreateParams} for more details.
+        #
+        # Creates a new company-wide deduction or contribution. Please use the
+        # `/providers` endpoint to view available types for each provider.
+        #
+        # @overload create(company_contribution: nil, description: nil, frequency: nil, type: nil, request_options: {})
+        #
+        # @param company_contribution [FinchAPI::Models::HRIS::BenefitCreateParams::CompanyContribution, nil] The company match for this benefit.
+        #
+        # @param description [String] Name of the benefit as it appears in the provider and pay statements. Recommend
+        # ...
+        #
+        # @param frequency [Symbol, FinchAPI::Models::HRIS::BenefitFrequency, nil] The frequency of the benefit deduction/contribution.
+        #
+        # @param type [Symbol, FinchAPI::Models::HRIS::BenefitType, nil] Type of benefit.
+        #
+        # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [FinchAPI::Models::HRIS::CreateCompanyBenefitsResponse]
+        #
+        # @see FinchAPI::Models::HRIS::BenefitCreateParams
+        def create(params = {})
+          parsed, options = FinchAPI::Models::HRIS::BenefitCreateParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: "employer/benefits",
+            body: parsed,
+            model: FinchAPI::Models::HRIS::CreateCompanyBenefitsResponse,
+            options: options
+          )
+        end
+
+        # Lists deductions and contributions information for a given item
+        #
+        # @overload retrieve(benefit_id, request_options: {})
+        #
+        # @param benefit_id [String]
+        # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [FinchAPI::Models::HRIS::CompanyBenefit]
+        #
+        # @see FinchAPI::Models::HRIS::BenefitRetrieveParams
+        def retrieve(benefit_id, params = {})
+          @client.request(
+            method: :get,
+            path: ["employer/benefits/%1$s", benefit_id],
+            model: FinchAPI::Models::HRIS::CompanyBenefit,
+            options: params[:request_options]
+          )
+        end
+
+        # Updates an existing company-wide deduction or contribution
+        #
+        # @overload update(benefit_id, description: nil, request_options: {})
+        #
+        # @param benefit_id [String]
+        #
+        # @param description [String] Updated name or description.
+        #
+        # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [FinchAPI::Models::HRIS::UpdateCompanyBenefitResponse]
+        #
+        # @see FinchAPI::Models::HRIS::BenefitUpdateParams
+        def update(benefit_id, params = {})
+          parsed, options = FinchAPI::Models::HRIS::BenefitUpdateParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: ["employer/benefits/%1$s", benefit_id],
+            body: parsed,
+            model: FinchAPI::Models::HRIS::UpdateCompanyBenefitResponse,
+            options: options
+          )
+        end
+
+        # List all company-wide deductions and contributions.
+        #
+        # @overload list(request_options: {})
+        #
+        # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [FinchAPI::Internal::SinglePage<FinchAPI::Models::HRIS::CompanyBenefit>]
+        #
+        # @see FinchAPI::Models::HRIS::BenefitListParams
+        def list(params = {})
+          @client.request(
+            method: :get,
+            path: "employer/benefits",
+            page: FinchAPI::Internal::SinglePage,
+            model: FinchAPI::Models::HRIS::CompanyBenefit,
+            options: params[:request_options]
+          )
+        end
+
+        # Get deductions metadata
+        #
+        # @overload list_supported_benefits(request_options: {})
+        #
+        # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [FinchAPI::Internal::SinglePage<FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse>]
+        #
+        # @see FinchAPI::Models::HRIS::BenefitListSupportedBenefitsParams
+        def list_supported_benefits(params = {})
+          @client.request(
+            method: :get,
+            path: "employer/benefits/meta",
+            page: FinchAPI::Internal::SinglePage,
+            model: FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse,
+            options: params[:request_options]
+          )
+        end
+
+        # @api private
+        #
+        # @param client [FinchAPI::Client]
+        def initialize(client:)
+          @client = client
+          @individuals = FinchAPI::Resources::HRIS::Benefits::Individuals.new(client: client)
+        end
+      end
+    end
+  end
+end

data/lib/finch_api/resources/hris/company/pay_statement_item/rules.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+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.
+            #
+            # @overload create(attributes: nil, conditions: nil, effective_end_date: nil, effective_start_date: nil, entity_type: nil, request_options: {})
+            #
+            # @param attributes [FinchAPI::Models::HRIS::Company::PayStatementItem::RuleCreateParams::Attributes] Specifies the fields to be applied when the condition is met.
+            #
+            # @param conditions [Array<FinchAPI::Models::HRIS::Company::PayStatementItem::RuleCreateParams::Condition>]
+            #
+            # @param effective_end_date [String, nil] Specifies when the rules should stop applying rules based on the date.
+            #
+            # @param effective_start_date [String, nil] Specifies when the rule should begin applying based on the date.
+            #
+            # @param entity_type [Symbol, FinchAPI::Models::HRIS::Company::PayStatementItem::RuleCreateParams::EntityType] The entity type to which the rule is applied.
+            #
+            # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+            #
+            # @return [FinchAPI::Models::HRIS::Company::PayStatementItem::RuleCreateResponse]
+            #
+            # @see FinchAPI::Models::HRIS::Company::PayStatementItem::RuleCreateParams
+            def create(params = {})
+              parsed, options =
+                FinchAPI::Models::HRIS::Company::PayStatementItem::RuleCreateParams.dump_request(params)
+              @client.request(
+                method: :post,
+                path: "employer/pay-statement-item/rule",
+                body: parsed,
+                model: FinchAPI::Models::HRIS::Company::PayStatementItem::RuleCreateResponse,
+                options: 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.
+            #
+            # @overload update(rule_id, optional_property: nil, request_options: {})
+            #
+            # @param rule_id [String]
+            # @param optional_property [Object]
+            # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+            #
+            # @return [FinchAPI::Models::HRIS::Company::PayStatementItem::RuleUpdateResponse]
+            #
+            # @see FinchAPI::Models::HRIS::Company::PayStatementItem::RuleUpdateParams
+            def update(rule_id, params = {})
+              parsed, options =
+                FinchAPI::Models::HRIS::Company::PayStatementItem::RuleUpdateParams.dump_request(params)
+              @client.request(
+                method: :put,
+                path: ["employer/pay-statement-item/rule/%1$s", rule_id],
+                body: parsed,
+                model: FinchAPI::Models::HRIS::Company::PayStatementItem::RuleUpdateResponse,
+                options: 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.
+            #
+            # @overload list(request_options: {})
+            #
+            # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+            #
+            # @return [FinchAPI::Internal::ResponsesPage<FinchAPI::Models::HRIS::Company::PayStatementItem::RuleListResponse>]
+            #
+            # @see FinchAPI::Models::HRIS::Company::PayStatementItem::RuleListParams
+            def list(params = {})
+              @client.request(
+                method: :get,
+                path: "employer/pay-statement-item/rule",
+                page: FinchAPI::Internal::ResponsesPage,
+                model: FinchAPI::Models::HRIS::Company::PayStatementItem::RuleListResponse,
+                options: params[: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.
+            #
+            # @overload delete(rule_id, request_options: {})
+            #
+            # @param rule_id [String]
+            # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+            #
+            # @return [FinchAPI::Models::HRIS::Company::PayStatementItem::RuleDeleteResponse]
+            #
+            # @see FinchAPI::Models::HRIS::Company::PayStatementItem::RuleDeleteParams
+            def delete(rule_id, params = {})
+              @client.request(
+                method: :delete,
+                path: ["employer/pay-statement-item/rule/%1$s", rule_id],
+                model: FinchAPI::Models::HRIS::Company::PayStatementItem::RuleDeleteResponse,
+                options: params[:request_options]
+              )
+            end
+
+            # @api private
+            #
+            # @param client [FinchAPI::Client]
+            def initialize(client:)
+              @client = client
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/finch_api/resources/hris/company/pay_statement_item.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class Company
+        class PayStatementItem
+          # @return [FinchAPI::Resources::HRIS::Company::PayStatementItem::Rules]
+          attr_reader :rules
+
+          # Some parameter documentations has been truncated, see
+          # {FinchAPI::Models::HRIS::Company::PayStatementItemListParams} for more details.
+          #
+          # **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.
+          #
+          # @overload list(categories: nil, end_date: nil, name: nil, start_date: nil, type: nil, request_options: {})
+          #
+          # @param categories [Array<Symbol, FinchAPI::Models::HRIS::Company::PayStatementItemListParams::Category>] Comma-delimited list of pay statement item categories to filter on. If empty, de
+          # ...
+          #
+          # @param end_date [Date] The end date to retrieve pay statement items by via their last seen pay date in
+          # ...
+          #
+          # @param name [String] Case-insensitive partial match search by pay statement item name.
+          #
+          # @param start_date [Date] The start date to retrieve pay statement items by via their last seen pay date (
+          # ...
+          #
+          # @param type [String] String search by pay statement item type.
+          #
+          # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [FinchAPI::Internal::ResponsesPage<FinchAPI::Models::HRIS::Company::PayStatementItemListResponse>]
+          #
+          # @see FinchAPI::Models::HRIS::Company::PayStatementItemListParams
+          def list(params = {})
+            parsed, options = FinchAPI::Models::HRIS::Company::PayStatementItemListParams.dump_request(params)
+            @client.request(
+              method: :get,
+              path: "employer/pay-statement-item",
+              query: parsed,
+              page: FinchAPI::Internal::ResponsesPage,
+              model: FinchAPI::Models::HRIS::Company::PayStatementItemListResponse,
+              options: options
+            )
+          end
+
+          # @api private
+          #
+          # @param client [FinchAPI::Client]
+          def initialize(client:)
+            @client = client
+            @rules = FinchAPI::Resources::HRIS::Company::PayStatementItem::Rules.new(client: client)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/finch_api/resources/hris/company.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class Company
+        # @return [FinchAPI::Resources::HRIS::Company::PayStatementItem]
+        attr_reader :pay_statement_item
+
+        # Read basic company data
+        #
+        # @overload retrieve(request_options: {})
+        #
+        # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [FinchAPI::Models::HRIS::HRISCompany]
+        #
+        # @see FinchAPI::Models::HRIS::CompanyRetrieveParams
+        def retrieve(params = {})
+          @client.request(
+            method: :get,
+            path: "employer/company",
+            model: FinchAPI::Models::HRIS::HRISCompany,
+            options: params[:request_options]
+          )
+        end
+
+        # @api private
+        #
+        # @param client [FinchAPI::Client]
+        def initialize(client:)
+          @client = client
+          @pay_statement_item = FinchAPI::Resources::HRIS::Company::PayStatementItem.new(client: client)
+        end
+      end
+    end
+  end
+end