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

data/lib/finch_api/models/hris/benefit_create_params.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      # @see FinchAPI::Resources::HRIS::Benefits#create
+      class BenefitCreateParams < FinchAPI::Internal::Type::BaseModel
+        extend FinchAPI::Internal::Type::RequestParameters::Converter
+        include FinchAPI::Internal::Type::RequestParameters
+
+        # @!attribute company_contribution
+        #   The company match for this benefit.
+        #
+        #   @return [FinchAPI::HRIS::BenefitCreateParams::CompanyContribution, nil]
+        optional :company_contribution,
+                 -> { FinchAPI::HRIS::BenefitCreateParams::CompanyContribution },
+                 nil?: true
+
+        # @!attribute description
+        #   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).
+        #
+        #   @return [String, nil]
+        optional :description, String
+
+        # @!attribute frequency
+        #   The frequency of the benefit deduction/contribution.
+        #
+        #   @return [Symbol, FinchAPI::HRIS::BenefitFrequency, nil]
+        optional :frequency, enum: -> { FinchAPI::HRIS::BenefitFrequency }, nil?: true
+
+        # @!attribute type
+        #   Type of benefit.
+        #
+        #   @return [Symbol, FinchAPI::HRIS::BenefitType, nil]
+        optional :type, enum: -> { FinchAPI::HRIS::BenefitType }, nil?: true
+
+        # @!method initialize(company_contribution: nil, description: nil, frequency: nil, type: nil, request_options: {})
+        #   Some parameter documentations has been truncated, see
+        #   {FinchAPI::Models::HRIS::BenefitCreateParams} for more details.
+        #
+        #   @param company_contribution [FinchAPI::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::HRIS::BenefitFrequency, nil] The frequency of the benefit deduction/contribution.
+        #
+        #   @param type [Symbol, FinchAPI::HRIS::BenefitType, nil] Type of benefit.
+        #
+        #   @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}]
+
+        class CompanyContribution < FinchAPI::Internal::Type::BaseModel
+          # @!attribute tiers
+          #
+          #   @return [Array<FinchAPI::HRIS::BenefitCreateParams::CompanyContribution::Tier>, nil]
+          optional :tiers,
+                   -> {
+                     FinchAPI::Internal::Type::ArrayOf[FinchAPI::HRIS::BenefitCreateParams::CompanyContribution::Tier]
+                   }
+
+          # @!attribute type
+          #
+          #   @return [Symbol, FinchAPI::HRIS::BenefitCreateParams::CompanyContribution::Type, nil]
+          optional :type, enum: -> { FinchAPI::HRIS::BenefitCreateParams::CompanyContribution::Type }
+
+          # @!method initialize(tiers: nil, type: nil)
+          #   The company match for this benefit.
+          #
+          #   @param tiers [Array<FinchAPI::HRIS::BenefitCreateParams::CompanyContribution::Tier>]
+          #   @param type [Symbol, FinchAPI::HRIS::BenefitCreateParams::CompanyContribution::Type]
+
+          class Tier < FinchAPI::Internal::Type::BaseModel
+            # @!attribute match
+            #
+            #   @return [Integer, nil]
+            optional :match, Integer
+
+            # @!attribute threshold
+            #
+            #   @return [Integer, nil]
+            optional :threshold, Integer
+
+            # @!method initialize(match: nil, threshold: nil)
+            #   @param match [Integer]
+            #   @param threshold [Integer]
+          end
+
+          # @see FinchAPI::HRIS::BenefitCreateParams::CompanyContribution#type
+          module Type
+            extend FinchAPI::Internal::Type::Enum
+
+            MATCH = :match
+
+            # @!method self.values
+            #   @return [Array<Symbol>]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/finch_api/models/hris/benefit_features_and_operations.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      class BenefitFeaturesAndOperations < FinchAPI::Internal::Type::BaseModel
+        # @!attribute supported_features
+        #
+        #   @return [FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures, nil]
+        optional :supported_features, -> { FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures }
+
+        # @!attribute supported_operations
+        #
+        #   @return [FinchAPI::HRIS::SupportPerBenefitType, nil]
+        optional :supported_operations, -> { FinchAPI::HRIS::SupportPerBenefitType }
+
+        # @!method initialize(supported_features: nil, supported_operations: nil)
+        #   @param supported_features [FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures]
+        #   @param supported_operations [FinchAPI::HRIS::SupportPerBenefitType]
+
+        # @see FinchAPI::HRIS::BenefitFeaturesAndOperations#supported_features
+        class SupportedFeatures < FinchAPI::Internal::Type::BaseModel
+          # @!attribute annual_maximum
+          #   Whether the provider supports an annual maximum for this benefit.
+          #
+          #   @return [Boolean, nil]
+          optional :annual_maximum, FinchAPI::Internal::Type::Boolean, nil?: true
+
+          # @!attribute catch_up
+          #   Whether the provider supports catch up for this benefit. This field will only be
+          #   true for retirement benefits.
+          #
+          #   @return [Boolean, nil]
+          optional :catch_up, FinchAPI::Internal::Type::Boolean, nil?: true
+
+          # @!attribute company_contribution
+          #   Supported contribution types. An empty array indicates contributions are not
+          #   supported.
+          #
+          #   @return [Array<Symbol, FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::CompanyContribution, nil>, nil]
+          optional :company_contribution,
+                   -> {
+                     FinchAPI::Internal::Type::ArrayOf[enum: FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::CompanyContribution,
+                                                       nil?: true]
+                   },
+                   nil?: true
+
+          # @!attribute description
+          #
+          #   @return [String, nil]
+          optional :description, String, nil?: true
+
+          # @!attribute employee_deduction
+          #   Supported deduction types. An empty array indicates deductions are not
+          #   supported.
+          #
+          #   @return [Array<Symbol, FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::EmployeeDeduction, nil>, nil]
+          optional :employee_deduction,
+                   -> {
+                     FinchAPI::Internal::Type::ArrayOf[enum: FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::EmployeeDeduction,
+                                                       nil?: true]
+                   },
+                   nil?: true
+
+          # @!attribute frequencies
+          #   The list of frequencies supported by the provider for this benefit
+          #
+          #   @return [Array<Symbol, FinchAPI::HRIS::BenefitFrequency, nil>, nil]
+          optional :frequencies,
+                   -> {
+                     FinchAPI::Internal::Type::ArrayOf[enum: FinchAPI::HRIS::BenefitFrequency, nil?: true]
+                   }
+
+          # @!attribute hsa_contribution_limit
+          #   Whether the provider supports HSA contribution limits. Empty if this feature is
+          #   not supported for the benefit. This array only has values for HSA benefits.
+          #
+          #   @return [Array<Symbol, FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::HsaContributionLimit, nil>, nil]
+          optional :hsa_contribution_limit,
+                   -> {
+                     FinchAPI::Internal::Type::ArrayOf[enum: FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::HsaContributionLimit,
+                                                       nil?: true]
+                   },
+                   nil?: true
+
+          # @!method initialize(annual_maximum: nil, catch_up: nil, company_contribution: nil, description: nil, employee_deduction: nil, frequencies: nil, hsa_contribution_limit: nil)
+          #   Some parameter documentations has been truncated, see
+          #   {FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures} for more
+          #   details.
+          #
+          #   @param annual_maximum [Boolean, nil] Whether the provider supports an annual maximum for this benefit.
+          #
+          #   @param catch_up [Boolean, nil] Whether the provider supports catch up for this benefit. This field will only be
+          #
+          #   @param company_contribution [Array<Symbol, FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::CompanyContribution, nil>, nil] Supported contribution types. An empty array indicates contributions are not sup
+          #
+          #   @param description [String, nil]
+          #
+          #   @param employee_deduction [Array<Symbol, FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::EmployeeDeduction, nil>, nil] Supported deduction types. An empty array indicates deductions are not supported
+          #
+          #   @param frequencies [Array<Symbol, FinchAPI::HRIS::BenefitFrequency, nil>] The list of frequencies supported by the provider for this benefit
+          #
+          #   @param hsa_contribution_limit [Array<Symbol, FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::HsaContributionLimit, nil>, nil] Whether the provider supports HSA contribution limits. Empty if this feature is
+
+          module CompanyContribution
+            extend FinchAPI::Internal::Type::Enum
+
+            FIXED = :fixed
+            PERCENT = :percent
+
+            # @!method self.values
+            #   @return [Array<Symbol>]
+          end
+
+          module EmployeeDeduction
+            extend FinchAPI::Internal::Type::Enum
+
+            FIXED = :fixed
+            PERCENT = :percent
+
+            # @!method self.values
+            #   @return [Array<Symbol>]
+          end
+
+          module HsaContributionLimit
+            extend FinchAPI::Internal::Type::Enum
+
+            INDIVIDUAL = :individual
+            FAMILY = :family
+
+            # @!method self.values
+            #   @return [Array<Symbol>]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/finch_api/models/hris/benefit_frequency.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      # The frequency of the benefit deduction/contribution.
+      module BenefitFrequency
+        extend FinchAPI::Internal::Type::Enum
+
+        ONE_TIME = :one_time
+        EVERY_PAYCHECK = :every_paycheck
+        MONTHLY = :monthly
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+    end
+  end
+end

data/lib/finch_api/models/hris/benefit_list_params.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      # @see FinchAPI::Resources::HRIS::Benefits#list
+      class BenefitListParams < FinchAPI::Internal::Type::BaseModel
+        extend FinchAPI::Internal::Type::RequestParameters::Converter
+        include FinchAPI::Internal::Type::RequestParameters
+
+        # @!method initialize(request_options: {})
+        #   @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}]
+      end
+    end
+  end
+end

data/lib/finch_api/models/hris/benefit_list_supported_benefits_params.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      # @see FinchAPI::Resources::HRIS::Benefits#list_supported_benefits
+      class BenefitListSupportedBenefitsParams < FinchAPI::Internal::Type::BaseModel
+        extend FinchAPI::Internal::Type::RequestParameters::Converter
+        include FinchAPI::Internal::Type::RequestParameters
+
+        # @!method initialize(request_options: {})
+        #   @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}]
+      end
+    end
+  end
+end

data/lib/finch_api/models/hris/benefit_list_supported_benefits_response.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      # @see FinchAPI::Resources::HRIS::Benefits#list_supported_benefits
+      class BenefitListSupportedBenefitsResponse < FinchAPI::Internal::Type::BaseModel
+        # @!attribute annual_maximum
+        #   Whether the provider supports an annual maximum for this benefit.
+        #
+        #   @return [Boolean, nil]
+        optional :annual_maximum, FinchAPI::Internal::Type::Boolean, nil?: true
+
+        # @!attribute catch_up
+        #   Whether the provider supports catch up for this benefit. This field will only be
+        #   true for retirement benefits.
+        #
+        #   @return [Boolean, nil]
+        optional :catch_up, FinchAPI::Internal::Type::Boolean, nil?: true
+
+        # @!attribute company_contribution
+        #   Supported contribution types. An empty array indicates contributions are not
+        #   supported.
+        #
+        #   @return [Array<Symbol, FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::CompanyContribution, nil>, nil]
+        optional :company_contribution,
+                 -> { FinchAPI::Internal::Type::ArrayOf[enum: FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::CompanyContribution, nil?: true] },
+                 nil?: true
+
+        # @!attribute description
+        #
+        #   @return [String, nil]
+        optional :description, String, nil?: true
+
+        # @!attribute employee_deduction
+        #   Supported deduction types. An empty array indicates deductions are not
+        #   supported.
+        #
+        #   @return [Array<Symbol, FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::EmployeeDeduction, nil>, nil]
+        optional :employee_deduction,
+                 -> { FinchAPI::Internal::Type::ArrayOf[enum: FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::EmployeeDeduction, nil?: true] },
+                 nil?: true
+
+        # @!attribute frequencies
+        #   The list of frequencies supported by the provider for this benefit
+        #
+        #   @return [Array<Symbol, FinchAPI::HRIS::BenefitFrequency, nil>, nil]
+        optional :frequencies,
+                 -> { FinchAPI::Internal::Type::ArrayOf[enum: FinchAPI::HRIS::BenefitFrequency, nil?: true] }
+
+        # @!attribute hsa_contribution_limit
+        #   Whether the provider supports HSA contribution limits. Empty if this feature is
+        #   not supported for the benefit. This array only has values for HSA benefits.
+        #
+        #   @return [Array<Symbol, FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::HsaContributionLimit, nil>, nil]
+        optional :hsa_contribution_limit,
+                 -> { FinchAPI::Internal::Type::ArrayOf[enum: FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::HsaContributionLimit, nil?: true] },
+                 nil?: true
+
+        # @!method initialize(annual_maximum: nil, catch_up: nil, company_contribution: nil, description: nil, employee_deduction: nil, frequencies: nil, hsa_contribution_limit: nil)
+        #   Some parameter documentations has been truncated, see
+        #   {FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse} for more details.
+        #
+        #   @param annual_maximum [Boolean, nil] Whether the provider supports an annual maximum for this benefit.
+        #
+        #   @param catch_up [Boolean, nil] Whether the provider supports catch up for this benefit. This field will only be
+        #
+        #   @param company_contribution [Array<Symbol, FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::CompanyContribution, nil>, nil] Supported contribution types. An empty array indicates contributions are not sup
+        #
+        #   @param description [String, nil]
+        #
+        #   @param employee_deduction [Array<Symbol, FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::EmployeeDeduction, nil>, nil] Supported deduction types. An empty array indicates deductions are not supported
+        #
+        #   @param frequencies [Array<Symbol, FinchAPI::HRIS::BenefitFrequency, nil>] The list of frequencies supported by the provider for this benefit
+        #
+        #   @param hsa_contribution_limit [Array<Symbol, FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::HsaContributionLimit, nil>, nil] Whether the provider supports HSA contribution limits. Empty if this feature is
+
+        module CompanyContribution
+          extend FinchAPI::Internal::Type::Enum
+
+          FIXED = :fixed
+          PERCENT = :percent
+
+          # @!method self.values
+          #   @return [Array<Symbol>]
+        end
+
+        module EmployeeDeduction
+          extend FinchAPI::Internal::Type::Enum
+
+          FIXED = :fixed
+          PERCENT = :percent
+
+          # @!method self.values
+          #   @return [Array<Symbol>]
+        end
+
+        module HsaContributionLimit
+          extend FinchAPI::Internal::Type::Enum
+
+          INDIVIDUAL = :individual
+          FAMILY = :family
+
+          # @!method self.values
+          #   @return [Array<Symbol>]
+        end
+      end
+    end
+  end
+end

data/lib/finch_api/models/hris/benefit_retrieve_params.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      # @see FinchAPI::Resources::HRIS::Benefits#retrieve
+      class BenefitRetrieveParams < FinchAPI::Internal::Type::BaseModel
+        extend FinchAPI::Internal::Type::RequestParameters::Converter
+        include FinchAPI::Internal::Type::RequestParameters
+
+        # @!method initialize(request_options: {})
+        #   @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}]
+      end
+    end
+  end
+end

data/lib/finch_api/models/hris/benefit_type.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      # Type of benefit.
+      module BenefitType
+        extend FinchAPI::Internal::Type::Enum
+
+        BENEFIT_TYPE_401K = :"401k"
+        BENEFIT_TYPE_401K_ROTH = :"401k_roth"
+        BENEFIT_TYPE_401K_LOAN = :"401k_loan"
+        BENEFIT_TYPE_403B = :"403b"
+        BENEFIT_TYPE_403B_ROTH = :"403b_roth"
+        BENEFIT_TYPE_457 = :"457"
+        BENEFIT_TYPE_457_ROTH = :"457_roth"
+        S125_MEDICAL = :s125_medical
+        S125_DENTAL = :s125_dental
+        S125_VISION = :s125_vision
+        HSA_PRE = :hsa_pre
+        HSA_POST = :hsa_post
+        FSA_MEDICAL = :fsa_medical
+        FSA_DEPENDENT_CARE = :fsa_dependent_care
+        SIMPLE_IRA = :simple_ira
+        SIMPLE = :simple
+        COMMUTER = :commuter
+        CUSTOM_POST_TAX = :custom_post_tax
+        CUSTOM_PRE_TAX = :custom_pre_tax
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+    end
+  end
+end

data/lib/finch_api/models/hris/benefit_update_params.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      # @see FinchAPI::Resources::HRIS::Benefits#update
+      class BenefitUpdateParams < FinchAPI::Internal::Type::BaseModel
+        extend FinchAPI::Internal::Type::RequestParameters::Converter
+        include FinchAPI::Internal::Type::RequestParameters
+
+        # @!attribute description
+        #   Updated name or description.
+        #
+        #   @return [String, nil]
+        optional :description, String
+
+        # @!method initialize(description: nil, request_options: {})
+        #   @param description [String] Updated name or description.
+        #
+        #   @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}]
+      end
+    end
+  end
+end

data/lib/finch_api/models/hris/benefits/enrolled_individual_benefit_response.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      module Benefits
+        # @see FinchAPI::Resources::HRIS::Benefits::Individuals#enroll_many
+        class EnrolledIndividualBenefitResponse < FinchAPI::Internal::Type::BaseModel
+          # @!attribute job_id
+          #
+          #   @return [String]
+          required :job_id, String
+
+          # @!method initialize(job_id:)
+          #   @param job_id [String]
+        end
+      end
+    end
+  end
+end

data/lib/finch_api/models/hris/benefits/individual_benefit.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      module Benefits
+        # @see FinchAPI::Resources::HRIS::Benefits::Individuals#retrieve_many_benefits
+        class IndividualBenefit < FinchAPI::Internal::Type::BaseModel
+          # @!attribute body
+          #
+          #   @return [FinchAPI::HRIS::Benefits::IndividualBenefit::Body, nil]
+          optional :body, -> { FinchAPI::HRIS::Benefits::IndividualBenefit::Body }
+
+          # @!attribute code
+          #
+          #   @return [Integer, nil]
+          optional :code, Integer
+
+          # @!attribute individual_id
+          #
+          #   @return [String, nil]
+          optional :individual_id, String
+
+          # @!method initialize(body: nil, code: nil, individual_id: nil)
+          #   @param body [FinchAPI::HRIS::Benefits::IndividualBenefit::Body]
+          #   @param code [Integer]
+          #   @param individual_id [String]
+
+          # @see FinchAPI::HRIS::Benefits::IndividualBenefit#body
+          class Body < FinchAPI::Internal::Type::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::Internal::Type::Boolean, nil?: true
+
+            # @!attribute company_contribution
+            #
+            #   @return [FinchAPI::HRIS::BenefitContribution, nil]
+            optional :company_contribution, -> { FinchAPI::HRIS::BenefitContribution }, nil?: true
+
+            # @!attribute employee_deduction
+            #
+            #   @return [FinchAPI::HRIS::BenefitContribution, nil]
+            optional :employee_deduction, -> { FinchAPI::HRIS::BenefitContribution }, nil?: true
+
+            # @!attribute hsa_contribution_limit
+            #   Type for HSA contribution limit if the benefit is a HSA.
+            #
+            #   @return [Symbol, FinchAPI::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit, nil]
+            optional :hsa_contribution_limit,
+                     enum: -> { FinchAPI::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit },
+                     nil?: true
+
+            # @!method initialize(annual_maximum: nil, catch_up: nil, company_contribution: nil, employee_deduction: nil, hsa_contribution_limit: nil)
+            #   Some parameter documentations has been truncated, see
+            #   {FinchAPI::HRIS::Benefits::IndividualBenefit::Body} for more details.
+            #
+            #   @param annual_maximum [Integer, nil] If the benefit supports annual maximum, the amount in cents for this individual.
+            #
+            #   @param catch_up [Boolean, nil] If the benefit supports catch up (401k, 403b, etc.), whether catch up is enabled
+            #
+            #   @param company_contribution [FinchAPI::HRIS::BenefitContribution, nil]
+            #
+            #   @param employee_deduction [FinchAPI::HRIS::BenefitContribution, nil]
+            #
+            #   @param hsa_contribution_limit [Symbol, FinchAPI::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit, nil] Type for HSA contribution limit if the benefit is a HSA.
+
+            # Type for HSA contribution limit if the benefit is a HSA.
+            #
+            # @see FinchAPI::HRIS::Benefits::IndividualBenefit::Body#hsa_contribution_limit
+            module HsaContributionLimit
+              extend FinchAPI::Internal::Type::Enum
+
+              INDIVIDUAL = :individual
+              FAMILY = :family
+
+              # @!method self.values
+              #   @return [Array<Symbol>]
+            end
+          end
+        end
+      end
+
+      IndividualBenefit = Benefits::IndividualBenefit
+    end
+  end
+end