finch-api 0.1.0.pre.alpha.1 → 0.1.0.pre.alpha.2

data/rbi/lib/finch-api/models/hris/supported_benefit.rbi

@@ -4,90 +4,74 @@ module FinchAPI
   module Models
     module HRIS
       class SupportedBenefit < FinchAPI::BaseModel
+        # Whether the provider supports an annual maximum for this benefit.
         sig { returns(T.nilable(T::Boolean)) }
-        def annual_maximum
-        end
-
-        sig { params(_: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
-        def annual_maximum=(_)
-        end
+        attr_accessor :annual_maximum
 
+        # Whether the provider supports catch up for this benefit. This field will only be
+        #   true for retirement benefits.
         sig { returns(T.nilable(T::Boolean)) }
-        def catch_up
-        end
-
-        sig { params(_: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
-        def catch_up=(_)
-        end
-
-        sig { returns(T.nilable(T::Array[T.nilable(Symbol)])) }
-        def company_contribution
-        end
+        attr_accessor :catch_up
 
+        # Supported contribution types. An empty array indicates contributions are not
+        #   supported.
         sig do
-          params(_: T.nilable(T::Array[T.nilable(Symbol)])).returns(T.nilable(T::Array[T.nilable(Symbol)]))
-        end
-        def company_contribution=(_)
+          returns(
+            T.nilable(
+              T::Array[T.nilable(FinchAPI::Models::HRIS::SupportedBenefit::CompanyContribution::TaggedSymbol)]
+            )
+          )
         end
+        attr_accessor :company_contribution
 
         sig { returns(T.nilable(String)) }
-        def description
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def description=(_)
-        end
-
-        sig { returns(T.nilable(T::Array[T.nilable(Symbol)])) }
-        def employee_deduction
-        end
+        attr_accessor :description
 
+        # Supported deduction types. An empty array indicates deductions are not
+        #   supported.
         sig do
-          params(_: T.nilable(T::Array[T.nilable(Symbol)])).returns(T.nilable(T::Array[T.nilable(Symbol)]))
-        end
-        def employee_deduction=(_)
-        end
-
-        sig { returns(T.nilable(T::Array[T.nilable(Symbol)])) }
-        def frequencies
+          returns(
+            T.nilable(T::Array[T.nilable(FinchAPI::Models::HRIS::SupportedBenefit::EmployeeDeduction::TaggedSymbol)])
+          )
         end
+        attr_accessor :employee_deduction
 
-        sig { params(_: T::Array[T.nilable(Symbol)]).returns(T::Array[T.nilable(Symbol)]) }
-        def frequencies=(_)
-        end
+        # The list of frequencies supported by the provider for this benefit
+        sig { returns(T.nilable(T::Array[T.nilable(FinchAPI::Models::HRIS::BenefitFrequency::TaggedSymbol)])) }
+        attr_reader :frequencies
 
-        sig { returns(T.nilable(T::Array[T.nilable(Symbol)])) }
-        def hsa_contribution_limit
-        end
+        sig { params(frequencies: T::Array[T.nilable(FinchAPI::Models::HRIS::BenefitFrequency::OrSymbol)]).void }
+        attr_writer :frequencies
 
+        # 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.
         sig do
-          params(_: T.nilable(T::Array[T.nilable(Symbol)])).returns(T.nilable(T::Array[T.nilable(Symbol)]))
-        end
-        def hsa_contribution_limit=(_)
-        end
-
-        sig { returns(T.nilable(Symbol)) }
-        def type
+          returns(
+            T.nilable(
+              T::Array[T.nilable(FinchAPI::Models::HRIS::SupportedBenefit::HsaContributionLimit::TaggedSymbol)]
+            )
+          )
         end
+        attr_accessor :hsa_contribution_limit
 
-        sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-        def type=(_)
-        end
+        # Type of benefit.
+        sig { returns(T.nilable(FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)) }
+        attr_accessor :type
 
         sig do
           params(
             annual_maximum: T.nilable(T::Boolean),
             catch_up: T.nilable(T::Boolean),
-            company_contribution: T.nilable(T::Array[T.nilable(Symbol)]),
+            company_contribution: T.nilable(T::Array[T.nilable(FinchAPI::Models::HRIS::SupportedBenefit::CompanyContribution::OrSymbol)]),
             description: T.nilable(String),
-            employee_deduction: T.nilable(T::Array[T.nilable(Symbol)]),
-            frequencies: T::Array[T.nilable(Symbol)],
-            hsa_contribution_limit: T.nilable(T::Array[T.nilable(Symbol)]),
-            type: T.nilable(Symbol)
+            employee_deduction: T.nilable(T::Array[T.nilable(FinchAPI::Models::HRIS::SupportedBenefit::EmployeeDeduction::OrSymbol)]),
+            frequencies: T::Array[T.nilable(FinchAPI::Models::HRIS::BenefitFrequency::OrSymbol)],
+            hsa_contribution_limit: T.nilable(T::Array[T.nilable(FinchAPI::Models::HRIS::SupportedBenefit::HsaContributionLimit::OrSymbol)]),
+            type: T.nilable(FinchAPI::Models::HRIS::BenefitType::OrSymbol)
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(
+        def self.new(
           annual_maximum: nil,
           catch_up: nil,
           company_contribution: nil,
@@ -105,47 +89,67 @@ module FinchAPI
               {
                 annual_maximum: T.nilable(T::Boolean),
                 catch_up: T.nilable(T::Boolean),
-                company_contribution: T.nilable(T::Array[T.nilable(Symbol)]),
+                company_contribution: T.nilable(
+                  T::Array[T.nilable(FinchAPI::Models::HRIS::SupportedBenefit::CompanyContribution::TaggedSymbol)]
+                ),
                 description: T.nilable(String),
-                employee_deduction: T.nilable(T::Array[T.nilable(Symbol)]),
-                frequencies: T::Array[T.nilable(Symbol)],
-                hsa_contribution_limit: T.nilable(T::Array[T.nilable(Symbol)]),
-                type: T.nilable(Symbol)
+                employee_deduction: T.nilable(T::Array[T.nilable(FinchAPI::Models::HRIS::SupportedBenefit::EmployeeDeduction::TaggedSymbol)]),
+                frequencies: T::Array[T.nilable(FinchAPI::Models::HRIS::BenefitFrequency::TaggedSymbol)],
+                hsa_contribution_limit: T.nilable(
+                  T::Array[T.nilable(FinchAPI::Models::HRIS::SupportedBenefit::HsaContributionLimit::TaggedSymbol)]
+                ),
+                type: T.nilable(FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
               }
             )
         end
         def to_hash
         end
 
-        class CompanyContribution < FinchAPI::Enum
-          abstract!
+        module CompanyContribution
+          extend FinchAPI::Enum
 
-          FIXED = T.let(:fixed, T.nilable(Symbol))
-          PERCENT = T.let(:percent, T.nilable(Symbol))
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::SupportedBenefit::CompanyContribution) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, FinchAPI::Models::HRIS::SupportedBenefit::CompanyContribution::TaggedSymbol) }
 
-          sig { override.returns(T::Array[Symbol]) }
+          FIXED = T.let(:fixed, FinchAPI::Models::HRIS::SupportedBenefit::CompanyContribution::TaggedSymbol)
+          PERCENT = T.let(:percent, FinchAPI::Models::HRIS::SupportedBenefit::CompanyContribution::TaggedSymbol)
+
+          sig { override.returns(T::Array[FinchAPI::Models::HRIS::SupportedBenefit::CompanyContribution::TaggedSymbol]) }
           def self.values
           end
         end
 
-        class EmployeeDeduction < FinchAPI::Enum
-          abstract!
+        module EmployeeDeduction
+          extend FinchAPI::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::SupportedBenefit::EmployeeDeduction) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, FinchAPI::Models::HRIS::SupportedBenefit::EmployeeDeduction::TaggedSymbol) }
 
-          FIXED = T.let(:fixed, T.nilable(Symbol))
-          PERCENT = T.let(:percent, T.nilable(Symbol))
+          FIXED = T.let(:fixed, FinchAPI::Models::HRIS::SupportedBenefit::EmployeeDeduction::TaggedSymbol)
+          PERCENT = T.let(:percent, FinchAPI::Models::HRIS::SupportedBenefit::EmployeeDeduction::TaggedSymbol)
 
-          sig { override.returns(T::Array[Symbol]) }
+          sig { override.returns(T::Array[FinchAPI::Models::HRIS::SupportedBenefit::EmployeeDeduction::TaggedSymbol]) }
           def self.values
           end
         end
 
-        class HsaContributionLimit < FinchAPI::Enum
-          abstract!
+        module HsaContributionLimit
+          extend FinchAPI::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::SupportedBenefit::HsaContributionLimit) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, FinchAPI::Models::HRIS::SupportedBenefit::HsaContributionLimit::TaggedSymbol) }
 
-          INDIVIDUAL = T.let(:individual, T.nilable(Symbol))
-          FAMILY = T.let(:family, T.nilable(Symbol))
+          INDIVIDUAL =
+            T.let(:individual, FinchAPI::Models::HRIS::SupportedBenefit::HsaContributionLimit::TaggedSymbol)
+          FAMILY = T.let(:family, FinchAPI::Models::HRIS::SupportedBenefit::HsaContributionLimit::TaggedSymbol)
 
-          sig { override.returns(T::Array[Symbol]) }
+          sig { override.returns(T::Array[FinchAPI::Models::HRIS::SupportedBenefit::HsaContributionLimit::TaggedSymbol]) }
           def self.values
           end
         end

data/rbi/lib/finch-api/models/hris/update_company_benefit_response.rbi

@@ -5,15 +5,10 @@ module FinchAPI
     module HRIS
       class UpdateCompanyBenefitResponse < FinchAPI::BaseModel
         sig { returns(String) }
-        def benefit_id
-        end
-
-        sig { params(_: String).returns(String) }
-        def benefit_id=(_)
-        end
+        attr_accessor :benefit_id
 
-        sig { params(benefit_id: String).void }
-        def initialize(benefit_id:)
+        sig { params(benefit_id: String).returns(T.attached_class) }
+        def self.new(benefit_id:)
         end
 
         sig { override.returns({benefit_id: String}) }

data/rbi/lib/finch-api/models/hris/w42005.rbi

@@ -4,90 +4,89 @@ module FinchAPI
   module Models
     module HRIS
       class W42005 < FinchAPI::BaseModel
+        # Detailed information specific to the 2005 W4 form.
         sig { returns(T.nilable(FinchAPI::Models::HRIS::W42005::Data)) }
-        def data
-        end
+        attr_reader :data
 
-        sig { params(_: FinchAPI::Models::HRIS::W42005::Data).returns(FinchAPI::Models::HRIS::W42005::Data) }
-        def data=(_)
-        end
+        sig { params(data: T.any(FinchAPI::Models::HRIS::W42005::Data, FinchAPI::Util::AnyHash)).void }
+        attr_writer :data
 
-        sig { returns(T.nilable(Symbol)) }
-        def type
-        end
+        # Specifies the form type, indicating that this document is a 2005 W4 form.
+        sig { returns(T.nilable(FinchAPI::Models::HRIS::W42005::Type::TaggedSymbol)) }
+        attr_reader :type
 
-        sig { params(_: Symbol).returns(Symbol) }
-        def type=(_)
-        end
+        sig { params(type: FinchAPI::Models::HRIS::W42005::Type::OrSymbol).void }
+        attr_writer :type
 
+        # The tax year this W4 document applies to.
         sig { returns(T.nilable(Float)) }
-        def year
+        attr_accessor :year
+
+        # A 2005 version of the W-4 tax form containing information on an individual's
+        #   filing status, dependents, and withholding details.
+        sig do
+          params(
+            data: T.any(FinchAPI::Models::HRIS::W42005::Data, FinchAPI::Util::AnyHash),
+            type: FinchAPI::Models::HRIS::W42005::Type::OrSymbol,
+            year: T.nilable(Float)
+          )
+            .returns(T.attached_class)
         end
-
-        sig { params(_: T.nilable(Float)).returns(T.nilable(Float)) }
-        def year=(_)
+        def self.new(data: nil, type: nil, year: nil)
         end
 
-        sig { params(data: FinchAPI::Models::HRIS::W42005::Data, type: Symbol, year: T.nilable(Float)).void }
-        def initialize(data: nil, type: nil, year: nil)
+        sig do
+          override
+            .returns(
+              {
+                data: FinchAPI::Models::HRIS::W42005::Data,
+                type: FinchAPI::Models::HRIS::W42005::Type::TaggedSymbol,
+                year: T.nilable(Float)
+              }
+            )
         end
-
-        sig { override.returns({data: FinchAPI::Models::HRIS::W42005::Data, type: Symbol, year: T.nilable(Float)}) }
         def to_hash
         end
 
         class Data < FinchAPI::BaseModel
+          # Additional withholding amount (in cents).
           sig { returns(T.nilable(Integer)) }
-          def additional_withholding
-          end
+          attr_accessor :additional_withholding
 
-          sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-          def additional_withholding=(_)
-          end
+          # Indicates exemption status from federal tax withholding.
+          sig { returns(T.nilable(FinchAPI::Models::HRIS::W42005::Data::Exemption::TaggedSymbol)) }
+          attr_reader :exemption
 
-          sig { returns(T.nilable(Symbol)) }
-          def exemption
-          end
+          sig { params(exemption: FinchAPI::Models::HRIS::W42005::Data::Exemption::OrSymbol).void }
+          attr_writer :exemption
 
-          sig { params(_: Symbol).returns(Symbol) }
-          def exemption=(_)
-          end
-
-          sig { returns(T.nilable(Symbol)) }
-          def filing_status
-          end
-
-          sig { params(_: Symbol).returns(Symbol) }
-          def filing_status=(_)
-          end
+          # The individual's filing status for tax purposes.
+          sig { returns(T.nilable(FinchAPI::Models::HRIS::W42005::Data::FilingStatus::TaggedSymbol)) }
+          attr_accessor :filing_status
 
+          # The unique identifier for the individual associated with this 2005 W4 form.
           sig { returns(T.nilable(String)) }
-          def individual_id
-          end
+          attr_reader :individual_id
 
-          sig { params(_: String).returns(String) }
-          def individual_id=(_)
-          end
+          sig { params(individual_id: String).void }
+          attr_writer :individual_id
 
+          # Total number of allowances claimed (in cents).
           sig { returns(T.nilable(Integer)) }
-          def total_number_of_allowances
-          end
-
-          sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-          def total_number_of_allowances=(_)
-          end
+          attr_accessor :total_number_of_allowances
 
+          # Detailed information specific to the 2005 W4 form.
           sig do
             params(
               additional_withholding: T.nilable(Integer),
-              exemption: Symbol,
-              filing_status: Symbol,
+              exemption: FinchAPI::Models::HRIS::W42005::Data::Exemption::OrSymbol,
+              filing_status: T.nilable(FinchAPI::Models::HRIS::W42005::Data::FilingStatus::OrSymbol),
               individual_id: String,
               total_number_of_allowances: T.nilable(Integer)
             )
-              .void
+              .returns(T.attached_class)
           end
-          def initialize(
+          def self.new(
             additional_withholding: nil,
             exemption: nil,
             filing_status: nil,
@@ -101,8 +100,8 @@ module FinchAPI
               .returns(
                 {
                   additional_withholding: T.nilable(Integer),
-                  exemption: Symbol,
-                  filing_status: Symbol,
+                  exemption: FinchAPI::Models::HRIS::W42005::Data::Exemption::TaggedSymbol,
+                  filing_status: T.nilable(FinchAPI::Models::HRIS::W42005::Data::FilingStatus::TaggedSymbol),
                   individual_id: String,
                   total_number_of_allowances: T.nilable(Integer)
                 }
@@ -111,36 +110,53 @@ module FinchAPI
           def to_hash
           end
 
-          class Exemption < FinchAPI::Enum
-            abstract!
+          # Indicates exemption status from federal tax withholding.
+          module Exemption
+            extend FinchAPI::Enum
+
+            TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::W42005::Data::Exemption) }
+            OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::HRIS::W42005::Data::Exemption::TaggedSymbol) }
 
-            EXEMPT = :exempt
-            NON_EXEMPT = :non_exempt
+            EXEMPT = T.let(:exempt, FinchAPI::Models::HRIS::W42005::Data::Exemption::TaggedSymbol)
+            NON_EXEMPT = T.let(:non_exempt, FinchAPI::Models::HRIS::W42005::Data::Exemption::TaggedSymbol)
 
-            sig { override.returns(T::Array[Symbol]) }
+            sig { override.returns(T::Array[FinchAPI::Models::HRIS::W42005::Data::Exemption::TaggedSymbol]) }
             def self.values
             end
           end
 
-          class FilingStatus < FinchAPI::Enum
-            abstract!
+          # The individual's filing status for tax purposes.
+          module FilingStatus
+            extend FinchAPI::Enum
 
-            MARRIED = :married
-            MARRIED_BUT_WITHHOLD_AT_HIGHER_SINGLE_RATE = :married_but_withhold_at_higher_single_rate
-            SINGLE = :single
+            TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::W42005::Data::FilingStatus) }
+            OrSymbol =
+              T.type_alias { T.any(Symbol, FinchAPI::Models::HRIS::W42005::Data::FilingStatus::TaggedSymbol) }
 
-            sig { override.returns(T::Array[Symbol]) }
+            MARRIED = T.let(:married, FinchAPI::Models::HRIS::W42005::Data::FilingStatus::TaggedSymbol)
+            MARRIED_BUT_WITHHOLD_AT_HIGHER_SINGLE_RATE =
+              T.let(
+                :married_but_withhold_at_higher_single_rate,
+                FinchAPI::Models::HRIS::W42005::Data::FilingStatus::TaggedSymbol
+              )
+            SINGLE = T.let(:single, FinchAPI::Models::HRIS::W42005::Data::FilingStatus::TaggedSymbol)
+
+            sig { override.returns(T::Array[FinchAPI::Models::HRIS::W42005::Data::FilingStatus::TaggedSymbol]) }
             def self.values
             end
           end
         end
 
-        class Type < FinchAPI::Enum
-          abstract!
+        # Specifies the form type, indicating that this document is a 2005 W4 form.
+        module Type
+          extend FinchAPI::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::W42005::Type) }
+          OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::HRIS::W42005::Type::TaggedSymbol) }
 
-          W4_2005 = :w4_2005
+          W4_2005 = T.let(:w4_2005, FinchAPI::Models::HRIS::W42005::Type::TaggedSymbol)
 
-          sig { override.returns(T::Array[Symbol]) }
+          sig { override.returns(T::Array[FinchAPI::Models::HRIS::W42005::Type::TaggedSymbol]) }
           def self.values
           end
         end