finch-api 0.1.0.pre.alpha.1

data/lib/finch-api/models/hris/benefits/enrolled_individual.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      module Benefits
+        class EnrolledIndividual < FinchAPI::BaseModel
+          # @!attribute [r] body
+          #
+          #   @return [FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Body, nil]
+          optional :body, -> { FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Body }
+
+          # @!parse
+          #   # @return [FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Body]
+          #   attr_writer :body
+
+          # @!attribute [r] code
+          #   HTTP status code. Either 201 or 200
+          #
+          #   @return [Integer, FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Code, nil]
+          optional :code, enum: -> { FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Code }
+
+          # @!parse
+          #   # @return [Integer, FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Code]
+          #   attr_writer :code
+
+          # @!attribute [r] individual_id
+          #
+          #   @return [String, nil]
+          optional :individual_id, String
+
+          # @!parse
+          #   # @return [String]
+          #   attr_writer :individual_id
+
+          # @!parse
+          #   # @param body [FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Body]
+          #   # @param code [Integer, FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Code]
+          #   # @param individual_id [String]
+          #   #
+          #   def initialize(body: nil, code: nil, individual_id: nil, **) = super
+
+          # def initialize: (Hash | FinchAPI::BaseModel) -> void
+
+          class Body < FinchAPI::BaseModel
+            # @!attribute finch_code
+            #   A descriptive identifier for the response
+            #
+            #   @return [String, nil]
+            optional :finch_code, String, nil?: true
+
+            # @!attribute message
+            #   Short description in English that provides more information about the response.
+            #
+            #   @return [String, nil]
+            optional :message, String, nil?: true
+
+            # @!attribute name
+            #   Identifier indicating whether the benefit was newly enrolled or updated.
+            #
+            #   @return [String, nil]
+            optional :name, String, nil?: true
+
+            # @!parse
+            #   # @param finch_code [String, nil]
+            #   # @param message [String, nil]
+            #   # @param name [String, nil]
+            #   #
+            #   def initialize(finch_code: nil, message: nil, name: nil, **) = super
+
+            # def initialize: (Hash | FinchAPI::BaseModel) -> void
+          end
+
+          # @abstract
+          #
+          # HTTP status code. Either 201 or 200
+          #
+          # @example
+          # ```ruby
+          # case code
+          # in 200
+          #   # ...
+          # in 201
+          #   # ...
+          # in 404
+          #   # ...
+          # in 403
+          #   # ...
+          # end
+          # ```
+          class Code < FinchAPI::Enum
+            OK = 200
+            CREATED = 201
+            NOT_FOUND = 404
+            FORBIDDEN = 403
+
+            finalize!
+
+            # @!parse
+            #   # @return [Array<Integer>]
+            #   #
+            #   def self.values; end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/finch-api/models/hris/benefits/individual_benefit.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      module Benefits
+        class IndividualBenefit < FinchAPI::BaseModel
+          # @!attribute [r] body
+          #
+          #   @return [FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body, nil]
+          optional :body, -> { FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body }
+
+          # @!parse
+          #   # @return [FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body]
+          #   attr_writer :body
+
+          # @!attribute [r] code
+          #
+          #   @return [Integer, nil]
+          optional :code, Integer
+
+          # @!parse
+          #   # @return [Integer]
+          #   attr_writer :code
+
+          # @!attribute [r] individual_id
+          #
+          #   @return [String, nil]
+          optional :individual_id, String
+
+          # @!parse
+          #   # @return [String]
+          #   attr_writer :individual_id
+
+          # @!parse
+          #   # @param body [FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body]
+          #   # @param code [Integer]
+          #   # @param individual_id [String]
+          #   #
+          #   def initialize(body: nil, code: nil, individual_id: nil, **) = super
+
+          # def initialize: (Hash | FinchAPI::BaseModel) -> void
+
+          class Body < FinchAPI::BaseModel
+            # @!attribute annual_maximum
+            #   If the benefit supports annual maximum, the amount in cents for this individual.
+            #
+            #   @return [Integer, nil]
+            optional :annual_maximum, Integer, nil?: true
+
+            # @!attribute catch_up
+            #   If the benefit supports catch up (401k, 403b, etc.), whether catch up is enabled
+            #     for this individual.
+            #
+            #   @return [Boolean, nil]
+            optional :catch_up, FinchAPI::BooleanModel, nil?: true
+
+            # @!attribute company_contribution
+            #
+            #   @return [FinchAPI::Models::HRIS::BenefitContribution, nil]
+            optional :company_contribution, -> { FinchAPI::Models::HRIS::BenefitContribution }, nil?: true
+
+            # @!attribute employee_deduction
+            #
+            #   @return [FinchAPI::Models::HRIS::BenefitContribution, nil]
+            optional :employee_deduction, -> { FinchAPI::Models::HRIS::BenefitContribution }, nil?: true
+
+            # @!attribute hsa_contribution_limit
+            #   Type for HSA contribution limit if the benefit is a HSA.
+            #
+            #   @return [Symbol, FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit, nil]
+            optional :hsa_contribution_limit,
+                     enum: -> { FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit },
+                     nil?: true
+
+            # @!parse
+            #   # @param annual_maximum [Integer, nil]
+            #   # @param catch_up [Boolean, nil]
+            #   # @param company_contribution [FinchAPI::Models::HRIS::BenefitContribution, nil]
+            #   # @param employee_deduction [FinchAPI::Models::HRIS::BenefitContribution, nil]
+            #   # @param hsa_contribution_limit [Symbol, FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit, nil]
+            #   #
+            #   def initialize(
+            #     annual_maximum: nil,
+            #     catch_up: nil,
+            #     company_contribution: nil,
+            #     employee_deduction: nil,
+            #     hsa_contribution_limit: nil,
+            #     **
+            #   )
+            #     super
+            #   end
+
+            # def initialize: (Hash | FinchAPI::BaseModel) -> void
+
+            # @abstract
+            #
+            # Type for HSA contribution limit if the benefit is a HSA.
+            #
+            # @example
+            # ```ruby
+            # case hsa_contribution_limit
+            # in :individual
+            #   # ...
+            # in :family
+            #   # ...
+            # end
+            # ```
+            class HsaContributionLimit < FinchAPI::Enum
+              INDIVIDUAL = :individual
+              FAMILY = :family
+
+              finalize!
+
+              # @!parse
+              #   # @return [Array<Symbol>]
+              #   #
+              #   def self.values; end
+            end
+          end
+        end
+      end
+
+      IndividualBenefit = Benefits::IndividualBenefit
+    end
+  end
+end

data/lib/finch-api/models/hris/benefits/individual_enroll_many_params.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      module Benefits
+        class IndividualEnrollManyParams < FinchAPI::BaseModel
+          # @!parse
+          #   extend FinchAPI::RequestParameters::Converter
+          include FinchAPI::RequestParameters
+
+          # @!attribute [r] individuals
+          #   Array of the individual_id to enroll and a configuration object.
+          #
+          #   @return [Array<FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual>, nil]
+          optional :individuals,
+                   -> { FinchAPI::ArrayOf[FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual] }
+
+          # @!parse
+          #   # @return [Array<FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual>]
+          #   attr_writer :individuals
+
+          # @!parse
+          #   # @param individuals [Array<FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual>]
+          #   # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}]
+          #   #
+          #   def initialize(individuals: nil, request_options: {}, **) = super
+
+          # def initialize: (Hash | FinchAPI::BaseModel) -> void
+
+          class Individual < FinchAPI::BaseModel
+            # @!attribute [r] configuration
+            #
+            #   @return [FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration, nil]
+            optional :configuration,
+                     -> { FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration }
+
+            # @!parse
+            #   # @return [FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration]
+            #   attr_writer :configuration
+
+            # @!attribute [r] individual_id
+            #   Finch id (uuidv4) for the individual to enroll
+            #
+            #   @return [String, nil]
+            optional :individual_id, String
+
+            # @!parse
+            #   # @return [String]
+            #   attr_writer :individual_id
+
+            # @!parse
+            #   # @param configuration [FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration]
+            #   # @param individual_id [String]
+            #   #
+            #   def initialize(configuration: nil, individual_id: nil, **) = super
+
+            # def initialize: (Hash | FinchAPI::BaseModel) -> void
+
+            class Configuration < FinchAPI::BaseModel
+              # @!attribute [r] annual_contribution_limit
+              #   For HSA benefits only - whether the contribution limit is for an individual or
+              #     family
+              #
+              #   @return [Symbol, FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::AnnualContributionLimit, nil]
+              optional :annual_contribution_limit,
+                       enum: -> { FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::AnnualContributionLimit }
+
+              # @!parse
+              #   # @return [Symbol, FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::AnnualContributionLimit]
+              #   attr_writer :annual_contribution_limit
+
+              # @!attribute annual_maximum
+              #   Maximum annual amount in cents
+              #
+              #   @return [Integer, nil]
+              optional :annual_maximum, Integer, nil?: true
+
+              # @!attribute [r] catch_up
+              #   For retirement benefits only - whether catch up contributions are enabled
+              #
+              #   @return [Boolean, nil]
+              optional :catch_up, FinchAPI::BooleanModel
+
+              # @!parse
+              #   # @return [Boolean]
+              #   attr_writer :catch_up
+
+              # @!attribute [r] company_contribution
+              #
+              #   @return [FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution, nil]
+              optional :company_contribution,
+                       -> { FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution }
+
+              # @!parse
+              #   # @return [FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution]
+              #   attr_writer :company_contribution
+
+              # @!attribute [r] employee_deduction
+              #
+              #   @return [FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction, nil]
+              optional :employee_deduction,
+                       -> { FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction }
+
+              # @!parse
+              #   # @return [FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction]
+              #   attr_writer :employee_deduction
+
+              # @!parse
+              #   # @param annual_contribution_limit [Symbol, FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::AnnualContributionLimit]
+              #   # @param annual_maximum [Integer, nil]
+              #   # @param catch_up [Boolean]
+              #   # @param company_contribution [FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution]
+              #   # @param employee_deduction [FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction]
+              #   #
+              #   def initialize(
+              #     annual_contribution_limit: nil,
+              #     annual_maximum: nil,
+              #     catch_up: nil,
+              #     company_contribution: nil,
+              #     employee_deduction: nil,
+              #     **
+              #   )
+              #     super
+              #   end
+
+              # def initialize: (Hash | FinchAPI::BaseModel) -> void
+
+              # @abstract
+              #
+              # For HSA benefits only - whether the contribution limit is for an individual or
+              #   family
+              #
+              # @example
+              # ```ruby
+              # case annual_contribution_limit
+              # in :individual
+              #   # ...
+              # in :family
+              #   # ...
+              # end
+              # ```
+              class AnnualContributionLimit < FinchAPI::Enum
+                INDIVIDUAL = :individual
+                FAMILY = :family
+
+                finalize!
+
+                # @!parse
+                #   # @return [Array<Symbol>]
+                #   #
+                #   def self.values; end
+              end
+
+              class CompanyContribution < FinchAPI::BaseModel
+                # @!attribute [r] amount
+                #   Amount in cents for fixed type or basis points (1/100th of a percent) for
+                #     percent type
+                #
+                #   @return [Integer, nil]
+                optional :amount, Integer
+
+                # @!parse
+                #   # @return [Integer]
+                #   attr_writer :amount
+
+                # @!attribute [r] type
+                #
+                #   @return [Symbol, FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution::Type, nil]
+                optional :type,
+                         enum: -> { FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution::Type }
+
+                # @!parse
+                #   # @return [Symbol, FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution::Type]
+                #   attr_writer :type
+
+                # @!parse
+                #   # @param amount [Integer]
+                #   # @param type [Symbol, FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution::Type]
+                #   #
+                #   def initialize(amount: nil, type: nil, **) = super
+
+                # def initialize: (Hash | FinchAPI::BaseModel) -> void
+
+                # @abstract
+                #
+                # @example
+                # ```ruby
+                # case type
+                # in :fixed
+                #   # ...
+                # in :percent
+                #   # ...
+                # end
+                # ```
+                class Type < FinchAPI::Enum
+                  FIXED = :fixed
+                  PERCENT = :percent
+
+                  finalize!
+
+                  # @!parse
+                  #   # @return [Array<Symbol>]
+                  #   #
+                  #   def self.values; end
+                end
+              end
+
+              class EmployeeDeduction < FinchAPI::BaseModel
+                # @!attribute [r] amount
+                #   Amount in cents for fixed type or basis points (1/100th of a percent) for
+                #     percent type
+                #
+                #   @return [Integer, nil]
+                optional :amount, Integer
+
+                # @!parse
+                #   # @return [Integer]
+                #   attr_writer :amount
+
+                # @!attribute [r] type
+                #
+                #   @return [Symbol, FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction::Type, nil]
+                optional :type,
+                         enum: -> { FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction::Type }
+
+                # @!parse
+                #   # @return [Symbol, FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction::Type]
+                #   attr_writer :type
+
+                # @!parse
+                #   # @param amount [Integer]
+                #   # @param type [Symbol, FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction::Type]
+                #   #
+                #   def initialize(amount: nil, type: nil, **) = super
+
+                # def initialize: (Hash | FinchAPI::BaseModel) -> void
+
+                # @abstract
+                #
+                # @example
+                # ```ruby
+                # case type
+                # in :fixed
+                #   # ...
+                # in :percent
+                #   # ...
+                # end
+                # ```
+                class Type < FinchAPI::Enum
+                  FIXED = :fixed
+                  PERCENT = :percent
+
+                  finalize!
+
+                  # @!parse
+                  #   # @return [Array<Symbol>]
+                  #   #
+                  #   def self.values; end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/finch-api/models/hris/benefits/individual_enrolled_ids_params.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      module Benefits
+        class IndividualEnrolledIDsParams < FinchAPI::BaseModel
+          # @!parse
+          #   extend FinchAPI::RequestParameters::Converter
+          include FinchAPI::RequestParameters
+
+          # @!parse
+          #   # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}]
+          #   #
+          #   def initialize(request_options: {}, **) = super
+
+          # def initialize: (Hash | FinchAPI::BaseModel) -> void
+        end
+      end
+    end
+  end
+end

data/lib/finch-api/models/hris/benefits/individual_enrolled_ids_response.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      module Benefits
+        class IndividualEnrolledIDsResponse < FinchAPI::BaseModel
+          # @!attribute benefit_id
+          #
+          #   @return [String]
+          required :benefit_id, String
+
+          # @!attribute individual_ids
+          #
+          #   @return [Array<String>]
+          required :individual_ids, FinchAPI::ArrayOf[String]
+
+          # @!parse
+          #   # @param benefit_id [String]
+          #   # @param individual_ids [Array<String>]
+          #   #
+          #   def initialize(benefit_id:, individual_ids:, **) = super
+
+          # def initialize: (Hash | FinchAPI::BaseModel) -> void
+        end
+      end
+    end
+  end
+end

data/lib/finch-api/models/hris/benefits/individual_retrieve_many_benefits_params.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      module Benefits
+        class IndividualRetrieveManyBenefitsParams < FinchAPI::BaseModel
+          # @!parse
+          #   extend FinchAPI::RequestParameters::Converter
+          include FinchAPI::RequestParameters
+
+          # @!attribute [r] individual_ids
+          #   comma-delimited list of stable Finch uuids for each individual. If empty,
+          #     defaults to all individuals
+          #
+          #   @return [String, nil]
+          optional :individual_ids, String
+
+          # @!parse
+          #   # @return [String]
+          #   attr_writer :individual_ids
+
+          # @!parse
+          #   # @param individual_ids [String]
+          #   # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}]
+          #   #
+          #   def initialize(individual_ids: nil, request_options: {}, **) = super
+
+          # def initialize: (Hash | FinchAPI::BaseModel) -> void
+        end
+      end
+    end
+  end
+end

data/lib/finch-api/models/hris/benefits/individual_unenroll_many_params.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      module Benefits
+        class IndividualUnenrollManyParams < FinchAPI::BaseModel
+          # @!parse
+          #   extend FinchAPI::RequestParameters::Converter
+          include FinchAPI::RequestParameters
+
+          # @!attribute [r] individual_ids
+          #   Array of individual_ids to unenroll.
+          #
+          #   @return [Array<String>, nil]
+          optional :individual_ids, FinchAPI::ArrayOf[String]
+
+          # @!parse
+          #   # @return [Array<String>]
+          #   attr_writer :individual_ids
+
+          # @!parse
+          #   # @param individual_ids [Array<String>]
+          #   # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}]
+          #   #
+          #   def initialize(individual_ids: nil, request_options: {}, **) = super
+
+          # def initialize: (Hash | FinchAPI::BaseModel) -> void
+        end
+      end
+    end
+  end
+end