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

data/rbi/finch_api/models/hris/benefit_list_supported_benefits_response.rbi

@@ -4,6 +4,9 @@ module FinchAPI
   module Models
     module HRIS
       class BenefitListSupportedBenefitsResponse < FinchAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
         # Whether the provider supports an annual maximum for this benefit.
         sig { returns(T.nilable(T::Boolean)) }
         attr_accessor :annual_maximum
@@ -18,7 +21,11 @@ module FinchAPI
         sig do
           returns(
             T.nilable(
-              T::Array[T.nilable(FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::CompanyContribution::TaggedSymbol)]
+              T::Array[
+                T.nilable(
+                  FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::CompanyContribution::TaggedSymbol
+                )
+              ]
             )
           )
         end
@@ -32,17 +39,34 @@ module FinchAPI
         sig do
           returns(
             T.nilable(
-              T::Array[T.nilable(FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::EmployeeDeduction::TaggedSymbol)]
+              T::Array[
+                T.nilable(
+                  FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::EmployeeDeduction::TaggedSymbol
+                )
+              ]
             )
           )
         end
         attr_accessor :employee_deduction
 
         # The list of frequencies supported by the provider for this benefit
-        sig { returns(T.nilable(T::Array[T.nilable(FinchAPI::Models::HRIS::BenefitFrequency::TaggedSymbol)])) }
+        sig do
+          returns(
+            T.nilable(
+              T::Array[
+                T.nilable(FinchAPI::HRIS::BenefitFrequency::TaggedSymbol)
+              ]
+            )
+          )
+        end
         attr_reader :frequencies
 
-        sig { params(frequencies: T::Array[T.nilable(FinchAPI::Models::HRIS::BenefitFrequency::OrSymbol)]).void }
+        sig do
+          params(
+            frequencies:
+              T::Array[T.nilable(FinchAPI::HRIS::BenefitFrequency::OrSymbol)]
+          ).void
+        end
         attr_writer :frequencies
 
         # Whether the provider supports HSA contribution limits. Empty if this feature is
@@ -64,19 +88,34 @@ module FinchAPI
           params(
             annual_maximum: T.nilable(T::Boolean),
             catch_up: T.nilable(T::Boolean),
-            company_contribution: T.nilable(
-              T::Array[T.nilable(FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::CompanyContribution::OrSymbol)]
-            ),
+            company_contribution:
+              T.nilable(
+                T::Array[
+                  T.nilable(
+                    FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::CompanyContribution::OrSymbol
+                  )
+                ]
+              ),
             description: T.nilable(String),
-            employee_deduction: T.nilable(
-              T::Array[T.nilable(FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::EmployeeDeduction::OrSymbol)]
-            ),
-            frequencies: T::Array[T.nilable(FinchAPI::Models::HRIS::BenefitFrequency::OrSymbol)],
-            hsa_contribution_limit: T.nilable(
-              T::Array[T.nilable(FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::HsaContributionLimit::OrSymbol)]
-            )
-          )
-            .returns(T.attached_class)
+            employee_deduction:
+              T.nilable(
+                T::Array[
+                  T.nilable(
+                    FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::EmployeeDeduction::OrSymbol
+                  )
+                ]
+              ),
+            frequencies:
+              T::Array[T.nilable(FinchAPI::HRIS::BenefitFrequency::OrSymbol)],
+            hsa_contribution_limit:
+              T.nilable(
+                T::Array[
+                  T.nilable(
+                    FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::HsaContributionLimit::OrSymbol
+                  )
+                ]
+              )
+          ).returns(T.attached_class)
         end
         def self.new(
           # Whether the provider supports an annual maximum for this benefit.
@@ -96,38 +135,59 @@ module FinchAPI
           # 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.
           hsa_contribution_limit: nil
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                annual_maximum: T.nilable(T::Boolean),
-                catch_up: T.nilable(T::Boolean),
-                company_contribution: T.nilable(
-                  T::Array[T.nilable(FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::CompanyContribution::TaggedSymbol)]
+          override.returns(
+            {
+              annual_maximum: T.nilable(T::Boolean),
+              catch_up: T.nilable(T::Boolean),
+              company_contribution:
+                T.nilable(
+                  T::Array[
+                    T.nilable(
+                      FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::CompanyContribution::TaggedSymbol
+                    )
+                  ]
                 ),
-                description: T.nilable(String),
-                employee_deduction: T.nilable(
-                  T::Array[T.nilable(FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::EmployeeDeduction::TaggedSymbol)]
+              description: T.nilable(String),
+              employee_deduction:
+                T.nilable(
+                  T::Array[
+                    T.nilable(
+                      FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::EmployeeDeduction::TaggedSymbol
+                    )
+                  ]
                 ),
-                frequencies: T::Array[T.nilable(FinchAPI::Models::HRIS::BenefitFrequency::TaggedSymbol)],
-                hsa_contribution_limit: T.nilable(
+              frequencies:
+                T::Array[
+                  T.nilable(FinchAPI::HRIS::BenefitFrequency::TaggedSymbol)
+                ],
+              hsa_contribution_limit:
+                T.nilable(
                   T::Array[
                     T.nilable(
                       FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::HsaContributionLimit::TaggedSymbol
                     )
                   ]
                 )
-              }
-            )
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
 
         module CompanyContribution
           extend FinchAPI::Internal::Type::Enum
 
           TaggedSymbol =
-            T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::CompanyContribution) }
+            T.type_alias do
+              T.all(
+                Symbol,
+                FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::CompanyContribution
+              )
+            end
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
           FIXED =
@@ -142,19 +202,26 @@ module FinchAPI
             )
 
           sig do
-            override
-              .returns(
-                T::Array[FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::CompanyContribution::TaggedSymbol]
-              )
+            override.returns(
+              T::Array[
+                FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::CompanyContribution::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
           end
-          def self.values; end
         end
 
         module EmployeeDeduction
           extend FinchAPI::Internal::Type::Enum
 
           TaggedSymbol =
-            T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::EmployeeDeduction) }
+            T.type_alias do
+              T.all(
+                Symbol,
+                FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::EmployeeDeduction
+              )
+            end
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
           FIXED =
@@ -169,19 +236,26 @@ module FinchAPI
             )
 
           sig do
-            override
-              .returns(
-                T::Array[FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::EmployeeDeduction::TaggedSymbol]
-              )
+            override.returns(
+              T::Array[
+                FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::EmployeeDeduction::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
           end
-          def self.values; end
         end
 
         module HsaContributionLimit
           extend FinchAPI::Internal::Type::Enum
 
           TaggedSymbol =
-            T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::HsaContributionLimit) }
+            T.type_alias do
+              T.all(
+                Symbol,
+                FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::HsaContributionLimit
+              )
+            end
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
           INDIVIDUAL =
@@ -196,12 +270,14 @@ module FinchAPI
             )
 
           sig do
-            override
-              .returns(
-                T::Array[FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::HsaContributionLimit::TaggedSymbol]
-              )
+            override.returns(
+              T::Array[
+                FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::HsaContributionLimit::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
           end
-          def self.values; end
         end
       end
     end

data/rbi/finch_api/models/hris/benefit_retrieve_params.rbi

@@ -7,14 +7,20 @@ module FinchAPI
         extend FinchAPI::Internal::Type::RequestParameters::Converter
         include FinchAPI::Internal::Type::RequestParameters
 
+        OrHash =
+          T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
         sig do
-          params(request_options: T.any(FinchAPI::RequestOptions, FinchAPI::Internal::AnyHash))
-            .returns(T.attached_class)
+          params(request_options: FinchAPI::RequestOptions::OrHash).returns(
+            T.attached_class
+          )
+        end
+        def self.new(request_options: {})
         end
-        def self.new(request_options: {}); end
 
-        sig { override.returns({request_options: FinchAPI::RequestOptions}) }
-        def to_hash; end
+        sig { override.returns({ request_options: FinchAPI::RequestOptions }) }
+        def to_hash
+        end
       end
     end
   end

data/rbi/finch_api/models/hris/benefit_type.rbi

@@ -7,31 +7,50 @@ module FinchAPI
       module BenefitType
         extend FinchAPI::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::BenefitType) }
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, FinchAPI::HRIS::BenefitType) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        BENEFIT_TYPE_401K = T.let(:"401k", FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
-        BENEFIT_TYPE_401K_ROTH = T.let(:"401k_roth", FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
-        BENEFIT_TYPE_401K_LOAN = T.let(:"401k_loan", FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
-        BENEFIT_TYPE_403B = T.let(:"403b", FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
-        BENEFIT_TYPE_403B_ROTH = T.let(:"403b_roth", FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
-        BENEFIT_TYPE_457 = T.let(:"457", FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
-        BENEFIT_TYPE_457_ROTH = T.let(:"457_roth", FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
-        S125_MEDICAL = T.let(:s125_medical, FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
-        S125_DENTAL = T.let(:s125_dental, FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
-        S125_VISION = T.let(:s125_vision, FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
-        HSA_PRE = T.let(:hsa_pre, FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
-        HSA_POST = T.let(:hsa_post, FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
-        FSA_MEDICAL = T.let(:fsa_medical, FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
-        FSA_DEPENDENT_CARE = T.let(:fsa_dependent_care, FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
-        SIMPLE_IRA = T.let(:simple_ira, FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
-        SIMPLE = T.let(:simple, FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
-        COMMUTER = T.let(:commuter, FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
-        CUSTOM_POST_TAX = T.let(:custom_post_tax, FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
-        CUSTOM_PRE_TAX = T.let(:custom_pre_tax, FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
+        BENEFIT_TYPE_401K =
+          T.let(:"401k", FinchAPI::HRIS::BenefitType::TaggedSymbol)
+        BENEFIT_TYPE_401K_ROTH =
+          T.let(:"401k_roth", FinchAPI::HRIS::BenefitType::TaggedSymbol)
+        BENEFIT_TYPE_401K_LOAN =
+          T.let(:"401k_loan", FinchAPI::HRIS::BenefitType::TaggedSymbol)
+        BENEFIT_TYPE_403B =
+          T.let(:"403b", FinchAPI::HRIS::BenefitType::TaggedSymbol)
+        BENEFIT_TYPE_403B_ROTH =
+          T.let(:"403b_roth", FinchAPI::HRIS::BenefitType::TaggedSymbol)
+        BENEFIT_TYPE_457 =
+          T.let(:"457", FinchAPI::HRIS::BenefitType::TaggedSymbol)
+        BENEFIT_TYPE_457_ROTH =
+          T.let(:"457_roth", FinchAPI::HRIS::BenefitType::TaggedSymbol)
+        S125_MEDICAL =
+          T.let(:s125_medical, FinchAPI::HRIS::BenefitType::TaggedSymbol)
+        S125_DENTAL =
+          T.let(:s125_dental, FinchAPI::HRIS::BenefitType::TaggedSymbol)
+        S125_VISION =
+          T.let(:s125_vision, FinchAPI::HRIS::BenefitType::TaggedSymbol)
+        HSA_PRE = T.let(:hsa_pre, FinchAPI::HRIS::BenefitType::TaggedSymbol)
+        HSA_POST = T.let(:hsa_post, FinchAPI::HRIS::BenefitType::TaggedSymbol)
+        FSA_MEDICAL =
+          T.let(:fsa_medical, FinchAPI::HRIS::BenefitType::TaggedSymbol)
+        FSA_DEPENDENT_CARE =
+          T.let(:fsa_dependent_care, FinchAPI::HRIS::BenefitType::TaggedSymbol)
+        SIMPLE_IRA =
+          T.let(:simple_ira, FinchAPI::HRIS::BenefitType::TaggedSymbol)
+        SIMPLE = T.let(:simple, FinchAPI::HRIS::BenefitType::TaggedSymbol)
+        COMMUTER = T.let(:commuter, FinchAPI::HRIS::BenefitType::TaggedSymbol)
+        CUSTOM_POST_TAX =
+          T.let(:custom_post_tax, FinchAPI::HRIS::BenefitType::TaggedSymbol)
+        CUSTOM_PRE_TAX =
+          T.let(:custom_pre_tax, FinchAPI::HRIS::BenefitType::TaggedSymbol)
 
-        sig { override.returns(T::Array[FinchAPI::Models::HRIS::BenefitType::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(T::Array[FinchAPI::HRIS::BenefitType::TaggedSymbol])
+        end
+        def self.values
+        end
       end
     end
   end

data/rbi/finch_api/models/hris/benefit_update_params.rbi

@@ -7,6 +7,9 @@ module FinchAPI
         extend FinchAPI::Internal::Type::RequestParameters::Converter
         include FinchAPI::Internal::Type::RequestParameters
 
+        OrHash =
+          T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
         # Updated name or description.
         sig { returns(T.nilable(String)) }
         attr_reader :description
@@ -17,20 +20,23 @@ module FinchAPI
         sig do
           params(
             description: String,
-            request_options: T.any(
-              FinchAPI::RequestOptions,
-              FinchAPI::Internal::AnyHash
-            )
-          )
-            .returns(T.attached_class)
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(T.attached_class)
         end
         def self.new(
           # Updated name or description.
           description: nil,
           request_options: {}
-        ); end
-        sig { override.returns({description: String, request_options: FinchAPI::RequestOptions}) }
-        def to_hash; end
+        )
+        end
+
+        sig do
+          override.returns(
+            { description: String, request_options: FinchAPI::RequestOptions }
+          )
+        end
+        def to_hash
+        end
       end
     end
   end

data/rbi/finch_api/models/hris/benefits/enrolled_individual_benefit_response.rbi

@@ -5,14 +5,19 @@ module FinchAPI
     module HRIS
       module Benefits
         class EnrolledIndividualBenefitResponse < FinchAPI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
           sig { returns(String) }
           attr_accessor :job_id
 
           sig { params(job_id: String).returns(T.attached_class) }
-          def self.new(job_id:); end
+          def self.new(job_id:)
+          end
 
-          sig { override.returns({job_id: String}) }
-          def to_hash; end
+          sig { override.returns({ job_id: String }) }
+          def to_hash
+          end
         end
       end
     end

data/rbi/finch_api/models/hris/benefits/individual_benefit.rbi

@@ -3,16 +3,24 @@
 module FinchAPI
   module Models
     module HRIS
+      IndividualBenefit = Benefits::IndividualBenefit
+
       module Benefits
         class IndividualBenefit < FinchAPI::Internal::Type::BaseModel
-          sig { returns(T.nilable(FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body)) }
+          OrHash =
+            T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
+          sig do
+            returns(
+              T.nilable(FinchAPI::HRIS::Benefits::IndividualBenefit::Body)
+            )
+          end
           attr_reader :body
 
           sig do
             params(
-              body: T.any(FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body, FinchAPI::Internal::AnyHash)
-            )
-              .void
+              body: FinchAPI::HRIS::Benefits::IndividualBenefit::Body::OrHash
+            ).void
           end
           attr_writer :body
 
@@ -30,23 +38,30 @@ module FinchAPI
 
           sig do
             params(
-              body: T.any(FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body, FinchAPI::Internal::AnyHash),
+              body: FinchAPI::HRIS::Benefits::IndividualBenefit::Body::OrHash,
               code: Integer,
               individual_id: String
-            )
-              .returns(T.attached_class)
+            ).returns(T.attached_class)
+          end
+          def self.new(body: nil, code: nil, individual_id: nil)
           end
-          def self.new(body: nil, code: nil, individual_id: nil); end
 
           sig do
-            override
-              .returns(
-                {body: FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body, code: Integer, individual_id: String}
-              )
+            override.returns(
+              {
+                body: FinchAPI::HRIS::Benefits::IndividualBenefit::Body,
+                code: Integer,
+                individual_id: String
+              }
+            )
+          end
+          def to_hash
           end
-          def to_hash; end
 
           class Body < FinchAPI::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
             # If the benefit supports annual maximum, the amount in cents for this individual.
             sig { returns(T.nilable(Integer)) }
             attr_accessor :annual_maximum
@@ -56,32 +71,34 @@ module FinchAPI
             sig { returns(T.nilable(T::Boolean)) }
             attr_accessor :catch_up
 
-            sig { returns(T.nilable(FinchAPI::Models::HRIS::BenefitContribution)) }
+            sig { returns(T.nilable(FinchAPI::HRIS::BenefitContribution)) }
             attr_reader :company_contribution
 
             sig do
               params(
-                company_contribution: T.nilable(T.any(FinchAPI::Models::HRIS::BenefitContribution, FinchAPI::Internal::AnyHash))
-              )
-                .void
+                company_contribution:
+                  T.nilable(FinchAPI::HRIS::BenefitContribution::OrHash)
+              ).void
             end
             attr_writer :company_contribution
 
-            sig { returns(T.nilable(FinchAPI::Models::HRIS::BenefitContribution)) }
+            sig { returns(T.nilable(FinchAPI::HRIS::BenefitContribution)) }
             attr_reader :employee_deduction
 
             sig do
               params(
-                employee_deduction: T.nilable(T.any(FinchAPI::Models::HRIS::BenefitContribution, FinchAPI::Internal::AnyHash))
-              )
-                .void
+                employee_deduction:
+                  T.nilable(FinchAPI::HRIS::BenefitContribution::OrHash)
+              ).void
             end
             attr_writer :employee_deduction
 
             # Type for HSA contribution limit if the benefit is a HSA.
             sig do
               returns(
-                T.nilable(FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::TaggedSymbol)
+                T.nilable(
+                  FinchAPI::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::TaggedSymbol
+                )
               )
             end
             attr_accessor :hsa_contribution_limit
@@ -90,11 +107,15 @@ module FinchAPI
               params(
                 annual_maximum: T.nilable(Integer),
                 catch_up: T.nilable(T::Boolean),
-                company_contribution: T.nilable(T.any(FinchAPI::Models::HRIS::BenefitContribution, FinchAPI::Internal::AnyHash)),
-                employee_deduction: T.nilable(T.any(FinchAPI::Models::HRIS::BenefitContribution, FinchAPI::Internal::AnyHash)),
-                hsa_contribution_limit: T.nilable(FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::OrSymbol)
-              )
-                .returns(T.attached_class)
+                company_contribution:
+                  T.nilable(FinchAPI::HRIS::BenefitContribution::OrHash),
+                employee_deduction:
+                  T.nilable(FinchAPI::HRIS::BenefitContribution::OrHash),
+                hsa_contribution_limit:
+                  T.nilable(
+                    FinchAPI::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::OrSymbol
+                  )
+              ).returns(T.attached_class)
             end
             def self.new(
               # If the benefit supports annual maximum, the amount in cents for this individual.
@@ -106,53 +127,65 @@ module FinchAPI
               employee_deduction: nil,
               # Type for HSA contribution limit if the benefit is a HSA.
               hsa_contribution_limit: nil
-            ); end
+            )
+            end
+
             sig do
-              override
-                .returns(
-                  {
-                    annual_maximum: T.nilable(Integer),
-                    catch_up: T.nilable(T::Boolean),
-                    company_contribution: T.nilable(FinchAPI::Models::HRIS::BenefitContribution),
-                    employee_deduction: T.nilable(FinchAPI::Models::HRIS::BenefitContribution),
-                    hsa_contribution_limit: T.nilable(FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::TaggedSymbol)
-                  }
-                )
+              override.returns(
+                {
+                  annual_maximum: T.nilable(Integer),
+                  catch_up: T.nilable(T::Boolean),
+                  company_contribution:
+                    T.nilable(FinchAPI::HRIS::BenefitContribution),
+                  employee_deduction:
+                    T.nilable(FinchAPI::HRIS::BenefitContribution),
+                  hsa_contribution_limit:
+                    T.nilable(
+                      FinchAPI::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::TaggedSymbol
+                    )
+                }
+              )
+            end
+            def to_hash
             end
-            def to_hash; end
 
             # Type for HSA contribution limit if the benefit is a HSA.
             module HsaContributionLimit
               extend FinchAPI::Internal::Type::Enum
 
               TaggedSymbol =
-                T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit) }
+                T.type_alias do
+                  T.all(
+                    Symbol,
+                    FinchAPI::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit
+                  )
+                end
               OrSymbol = T.type_alias { T.any(Symbol, String) }
 
               INDIVIDUAL =
                 T.let(
                   :individual,
-                  FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::TaggedSymbol
+                  FinchAPI::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::TaggedSymbol
                 )
               FAMILY =
                 T.let(
                   :family,
-                  FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::TaggedSymbol
+                  FinchAPI::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::TaggedSymbol
                 )
 
               sig do
-                override
-                  .returns(
-                    T::Array[FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::TaggedSymbol]
-                  )
+                override.returns(
+                  T::Array[
+                    FinchAPI::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::TaggedSymbol
+                  ]
+                )
+              end
+              def self.values
               end
-              def self.values; end
             end
           end
         end
       end
-
-      IndividualBenefit = Benefits::IndividualBenefit
     end
   end
 end