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

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

@@ -0,0 +1,58 @@
+# 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::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::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::HRIS::HRISCompany]
+        #
+        # @see FinchAPI::Models::HRIS::CompanyRetrieveParams
+        def retrieve(params = {})
+          @client.request(
+            method: :get,
+            path: "employer/company",
+            model: FinchAPI::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

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class Directory
+        # Read company directory and organization structure
+        #
+        # @overload list(limit: nil, offset: nil, request_options: {})
+        #
+        # @param limit [Integer] Number of employees to return (defaults to all)
+        #
+        # @param offset [Integer] Index to start from (defaults to 0)
+        #
+        # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [FinchAPI::Internal::IndividualsPage<FinchAPI::HRIS::IndividualInDirectory>]
+        #
+        # @see FinchAPI::Models::HRIS::DirectoryListParams
+        def list(params = {})
+          parsed, options = FinchAPI::HRIS::DirectoryListParams.dump_request(params)
+          @client.request(
+            method: :get,
+            path: "employer/directory",
+            query: parsed,
+            page: FinchAPI::Internal::IndividualsPage,
+            model: FinchAPI::HRIS::IndividualInDirectory,
+            options: options
+          )
+        end
+
+        # @deprecated use `list` instead
+        #
+        # Read company directory and organization structure
+        alias_method :list_individuals, :list
+
+        # @api private
+        #
+        # @param client [FinchAPI::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class Documents
+        # Some parameter documentations has been truncated, see
+        # {FinchAPI::Models::HRIS::DocumentListParams} for more details.
+        #
+        # **Beta:** This endpoint is in beta and may change. Retrieve a list of
+        # company-wide documents.
+        #
+        # @overload list(individual_ids: nil, limit: nil, offset: nil, types: nil, request_options: {})
+        #
+        # @param individual_ids [Array<String>] Comma-delimited list of stable Finch uuids for each individual. If empty, defaul
+        #
+        # @param limit [Integer] Number of documents to return (defaults to all)
+        #
+        # @param offset [Integer] Index to start from (defaults to 0)
+        #
+        # @param types [Array<Symbol, FinchAPI::HRIS::DocumentListParams::Type>] Comma-delimited list of document types to filter on. If empty, defaults to all t
+        #
+        # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [FinchAPI::Models::HRIS::DocumentListResponse]
+        #
+        # @see FinchAPI::Models::HRIS::DocumentListParams
+        def list(params = {})
+          parsed, options = FinchAPI::HRIS::DocumentListParams.dump_request(params)
+          @client.request(
+            method: :get,
+            path: "employer/documents",
+            query: parsed,
+            model: FinchAPI::Models::HRIS::DocumentListResponse,
+            options: options
+          )
+        end
+
+        # **Beta:** This endpoint is in beta and may change. Retrieve details of a
+        # specific document by its ID.
+        #
+        # @overload retreive(document_id, request_options: {})
+        #
+        # @param document_id [String] The unique identifier of the document.
+        #
+        # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [FinchAPI::HRIS::W42020, FinchAPI::HRIS::W42005]
+        #
+        # @see FinchAPI::Models::HRIS::DocumentRetreiveParams
+        def retreive(document_id, params = {})
+          @client.request(
+            method: :get,
+            path: ["employer/documents/%1$s", document_id],
+            model: FinchAPI::Models::HRIS::DocumentRetreiveResponse,
+            options: params[:request_options]
+          )
+        end
+
+        # @api private
+        #
+        # @param client [FinchAPI::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class Employments
+        # Read individual employment and income data
+        #
+        # @overload retrieve_many(requests:, request_options: {})
+        #
+        # @param requests [Array<FinchAPI::HRIS::EmploymentRetrieveManyParams::Request>] The array of batch requests.
+        #
+        # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [FinchAPI::Internal::ResponsesPage<FinchAPI::HRIS::EmploymentDataResponse>]
+        #
+        # @see FinchAPI::Models::HRIS::EmploymentRetrieveManyParams
+        def retrieve_many(params)
+          parsed, options = FinchAPI::HRIS::EmploymentRetrieveManyParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: "employer/employment",
+            body: parsed,
+            page: FinchAPI::Internal::ResponsesPage,
+            model: FinchAPI::HRIS::EmploymentDataResponse,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [FinchAPI::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class Individuals
+        # Read individual data, excluding income and employment data
+        #
+        # @overload retrieve_many(options: nil, requests: nil, request_options: {})
+        #
+        # @param options [FinchAPI::HRIS::IndividualRetrieveManyParams::Options, nil]
+        # @param requests [Array<FinchAPI::HRIS::IndividualRetrieveManyParams::Request>]
+        # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [FinchAPI::Internal::ResponsesPage<FinchAPI::HRIS::IndividualResponse>]
+        #
+        # @see FinchAPI::Models::HRIS::IndividualRetrieveManyParams
+        def retrieve_many(params = {})
+          parsed, options = FinchAPI::HRIS::IndividualRetrieveManyParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: "employer/individual",
+            body: parsed,
+            page: FinchAPI::Internal::ResponsesPage,
+            model: FinchAPI::HRIS::IndividualResponse,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [FinchAPI::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+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.
+        #
+        # @overload retrieve_many(requests:, request_options: {})
+        #
+        # @param requests [Array<FinchAPI::HRIS::PayStatementRetrieveManyParams::Request>] The array of batch requests.
+        #
+        # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [FinchAPI::Internal::ResponsesPage<FinchAPI::HRIS::PayStatementResponse>]
+        #
+        # @see FinchAPI::Models::HRIS::PayStatementRetrieveManyParams
+        def retrieve_many(params)
+          parsed, options = FinchAPI::HRIS::PayStatementRetrieveManyParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: "employer/pay-statement",
+            body: parsed,
+            page: FinchAPI::Internal::ResponsesPage,
+            model: FinchAPI::HRIS::PayStatementResponse,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [FinchAPI::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class Payments
+        # Some parameter documentations has been truncated, see
+        # {FinchAPI::Models::HRIS::PaymentListParams} for more details.
+        #
+        # Read payroll and contractor related payments by the company.
+        #
+        # @overload list(end_date:, start_date:, request_options: {})
+        #
+        # @param end_date [Date] The end date to retrieve payments by a company (inclusive) in `YYYY-MM-DD` forma
+        #
+        # @param start_date [Date] The start date to retrieve payments by a company (inclusive) in `YYYY-MM-DD` for
+        #
+        # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [FinchAPI::Internal::SinglePage<FinchAPI::HRIS::Payment>]
+        #
+        # @see FinchAPI::Models::HRIS::PaymentListParams
+        def list(params)
+          parsed, options = FinchAPI::HRIS::PaymentListParams.dump_request(params)
+          @client.request(
+            method: :get,
+            path: "employer/payment",
+            query: parsed,
+            page: FinchAPI::Internal::SinglePage,
+            model: FinchAPI::HRIS::Payment,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [FinchAPI::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/finch_api/resources/hris.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Resources
+    class HRIS
+      # @return [FinchAPI::Resources::HRIS::Company]
+      attr_reader :company
+
+      # @return [FinchAPI::Resources::HRIS::Directory]
+      attr_reader :directory
+
+      # @return [FinchAPI::Resources::HRIS::Individuals]
+      attr_reader :individuals
+
+      # @return [FinchAPI::Resources::HRIS::Employments]
+      attr_reader :employments
+
+      # @return [FinchAPI::Resources::HRIS::Payments]
+      attr_reader :payments
+
+      # @return [FinchAPI::Resources::HRIS::PayStatements]
+      attr_reader :pay_statements
+
+      # @return [FinchAPI::Resources::HRIS::Documents]
+      attr_reader :documents
+
+      # @return [FinchAPI::Resources::HRIS::Benefits]
+      attr_reader :benefits
+
+      # @api private
+      #
+      # @param client [FinchAPI::Client]
+      def initialize(client:)
+        @client = client
+        @company = FinchAPI::Resources::HRIS::Company.new(client: client)
+        @directory = FinchAPI::Resources::HRIS::Directory.new(client: client)
+        @individuals = FinchAPI::Resources::HRIS::Individuals.new(client: client)
+        @employments = FinchAPI::Resources::HRIS::Employments.new(client: client)
+        @payments = FinchAPI::Resources::HRIS::Payments.new(client: client)
+        @pay_statements = FinchAPI::Resources::HRIS::PayStatements.new(client: client)
+        @documents = FinchAPI::Resources::HRIS::Documents.new(client: client)
+        @benefits = FinchAPI::Resources::HRIS::Benefits.new(client: client)
+      end
+    end
+  end
+end

data/lib/finch_api/resources/jobs/automated.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Resources
+    class Jobs
+      class Automated
+        # Enqueue an automated job.
+        #
+        # `data_sync_all`: Enqueue a job to re-sync all data for a connection.
+        # `data_sync_all` has a concurrency limit of 1 job at a time per connection. This
+        # means that if this endpoint is called while a job is already in progress for
+        # this connection, Finch will return the `job_id` of the job that is currently in
+        # progress. Finch allows a fixed window rate limit of 1 forced refresh per hour
+        # per connection.
+        #
+        # `w4_form_employee_sync`: Enqueues a job for sync W-4 data for a particular
+        # individual, identified by `individual_id`. This feature is currently in beta.
+        #
+        # This endpoint is available for _Scale_ tier customers as an add-on. To request
+        # access to this endpoint, please contact your Finch account manager.
+        #
+        # @overload create(type:, params:, request_options: {})
+        #
+        # @param type [Symbol, FinchAPI::Jobs::AutomatedCreateParams::Type] The type of job to start.
+        #
+        # @param params [FinchAPI::Jobs::AutomatedCreateParams::Params]
+        #
+        # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [FinchAPI::Models::Jobs::AutomatedCreateResponse]
+        #
+        # @see FinchAPI::Models::Jobs::AutomatedCreateParams
+        def create(params)
+          parsed, options = FinchAPI::Jobs::AutomatedCreateParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: "jobs/automated",
+            body: parsed,
+            model: FinchAPI::Models::Jobs::AutomatedCreateResponse,
+            options: options
+          )
+        end
+
+        # Get an automated job by `job_id`.
+        #
+        # @overload retrieve(job_id, request_options: {})
+        #
+        # @param job_id [String]
+        # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [FinchAPI::Jobs::AutomatedAsyncJob]
+        #
+        # @see FinchAPI::Models::Jobs::AutomatedRetrieveParams
+        def retrieve(job_id, params = {})
+          @client.request(
+            method: :get,
+            path: ["jobs/automated/%1$s", job_id],
+            model: FinchAPI::Jobs::AutomatedAsyncJob,
+            options: params[:request_options]
+          )
+        end
+
+        # Get all automated jobs. Automated jobs are completed by a machine. By default,
+        # jobs are sorted in descending order by submission time. For scheduled jobs such
+        # as data syncs, only the next scheduled job is shown.
+        #
+        # @overload list(limit: nil, offset: nil, request_options: {})
+        #
+        # @param limit [Integer] Number of items to return
+        #
+        # @param offset [Integer] Index to start from (defaults to 0)
+        #
+        # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [FinchAPI::Models::Jobs::AutomatedListResponse]
+        #
+        # @see FinchAPI::Models::Jobs::AutomatedListParams
+        def list(params = {})
+          parsed, options = FinchAPI::Jobs::AutomatedListParams.dump_request(params)
+          @client.request(
+            method: :get,
+            path: "jobs/automated",
+            query: parsed,
+            model: FinchAPI::Models::Jobs::AutomatedListResponse,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [FinchAPI::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/finch_api/resources/jobs/manual.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Resources
+    class Jobs
+      class Manual
+        # Get a manual job by `job_id`. Manual jobs are completed by a human and include
+        # Assisted Benefits jobs.
+        #
+        # @overload retrieve(job_id, request_options: {})
+        #
+        # @param job_id [String]
+        # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [FinchAPI::Jobs::ManualAsyncJob]
+        #
+        # @see FinchAPI::Models::Jobs::ManualRetrieveParams
+        def retrieve(job_id, params = {})
+          @client.request(
+            method: :get,
+            path: ["jobs/manual/%1$s", job_id],
+            model: FinchAPI::Jobs::ManualAsyncJob,
+            options: params[:request_options]
+          )
+        end
+
+        # @api private
+        #
+        # @param client [FinchAPI::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/finch_api/resources/jobs.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Resources
+    class Jobs
+      # @return [FinchAPI::Resources::Jobs::Automated]
+      attr_reader :automated
+
+      # @return [FinchAPI::Resources::Jobs::Manual]
+      attr_reader :manual
+
+      # @api private
+      #
+      # @param client [FinchAPI::Client]
+      def initialize(client:)
+        @client = client
+        @automated = FinchAPI::Resources::Jobs::Automated.new(client: client)
+        @manual = FinchAPI::Resources::Jobs::Manual.new(client: client)
+      end
+    end
+  end
+end

data/lib/finch_api/resources/payroll/pay_groups.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Resources
+    class Payroll
+      class PayGroups
+        # Read information from a single pay group
+        #
+        # @overload retrieve(pay_group_id, request_options: {})
+        #
+        # @param pay_group_id [String]
+        # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [FinchAPI::Models::Payroll::PayGroupRetrieveResponse]
+        #
+        # @see FinchAPI::Models::Payroll::PayGroupRetrieveParams
+        def retrieve(pay_group_id, params = {})
+          @client.request(
+            method: :get,
+            path: ["employer/pay-groups/%1$s", pay_group_id],
+            model: FinchAPI::Models::Payroll::PayGroupRetrieveResponse,
+            options: params[:request_options]
+          )
+        end
+
+        # Read company pay groups and frequencies
+        #
+        # @overload list(individual_id: nil, pay_frequencies: nil, request_options: {})
+        #
+        # @param individual_id [String]
+        # @param pay_frequencies [Array<String>]
+        # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [FinchAPI::Internal::SinglePage<FinchAPI::Models::Payroll::PayGroupListResponse>]
+        #
+        # @see FinchAPI::Models::Payroll::PayGroupListParams
+        def list(params = {})
+          parsed, options = FinchAPI::Payroll::PayGroupListParams.dump_request(params)
+          @client.request(
+            method: :get,
+            path: "employer/pay-groups",
+            query: parsed,
+            page: FinchAPI::Internal::SinglePage,
+            model: FinchAPI::Models::Payroll::PayGroupListResponse,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [FinchAPI::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/finch_api/resources/payroll.rb

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