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

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

@@ -5,35 +5,35 @@ module FinchAPI
     module HRIS
       class BenefitFeaturesAndOperations < FinchAPI::BaseModel
         sig { returns(T.nilable(FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures)) }
-        def supported_features
-        end
+        attr_reader :supported_features
 
         sig do
-          params(_: FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures)
-            .returns(FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures)
-        end
-        def supported_features=(_)
+          params(
+            supported_features: T.any(FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures, FinchAPI::Util::AnyHash)
+          )
+            .void
         end
+        attr_writer :supported_features
 
         sig { returns(T.nilable(FinchAPI::Models::HRIS::SupportPerBenefitType)) }
-        def supported_operations
-        end
+        attr_reader :supported_operations
 
         sig do
-          params(_: FinchAPI::Models::HRIS::SupportPerBenefitType)
-            .returns(FinchAPI::Models::HRIS::SupportPerBenefitType)
-        end
-        def supported_operations=(_)
+          params(
+            supported_operations: T.any(FinchAPI::Models::HRIS::SupportPerBenefitType, FinchAPI::Util::AnyHash)
+          )
+            .void
         end
+        attr_writer :supported_operations
 
         sig do
           params(
-            supported_features: FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures,
-            supported_operations: FinchAPI::Models::HRIS::SupportPerBenefitType
+            supported_features: T.any(FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures, FinchAPI::Util::AnyHash),
+            supported_operations: T.any(FinchAPI::Models::HRIS::SupportPerBenefitType, FinchAPI::Util::AnyHash)
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(supported_features: nil, supported_operations: nil)
+        def self.new(supported_features: nil, supported_operations: nil)
         end
 
         sig do
@@ -49,81 +49,101 @@ module FinchAPI
         end
 
         class SupportedFeatures < 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::BenefitFeaturesAndOperations::SupportedFeatures::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=(_)
+            returns(
+              T.nilable(
+                T::Array[
+                T.nilable(
+                  FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::EmployeeDeduction::TaggedSymbol
+                )
+                ]
+              )
+            )
           end
+          attr_accessor :employee_deduction
 
-          sig { returns(T.nilable(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 { params(_: T::Array[T.nilable(Symbol)]).returns(T::Array[T.nilable(Symbol)]) }
-          def frequencies=(_)
-          end
-
-          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=(_)
+            returns(
+              T.nilable(
+                T::Array[
+                T.nilable(
+                  FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::HsaContributionLimit::TaggedSymbol
+                )
+                ]
+              )
+            )
           end
+          attr_accessor :hsa_contribution_limit
 
           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::BenefitFeaturesAndOperations::SupportedFeatures::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)])
+              employee_deduction: T.nilable(
+                T::Array[
+                T.nilable(
+                  FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::EmployeeDeduction::OrSymbol
+                )
+                ]
+              ),
+              frequencies: T::Array[T.nilable(FinchAPI::Models::HRIS::BenefitFrequency::OrSymbol)],
+              hsa_contribution_limit: T.nilable(
+                T::Array[
+                T.nilable(
+                  FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::HsaContributionLimit::OrSymbol
+                )
+                ]
+              )
             )
-              .void
+              .returns(T.attached_class)
           end
-          def initialize(
+          def self.new(
             annual_maximum: nil,
             catch_up: nil,
             company_contribution: nil,
@@ -140,46 +160,139 @@ 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::BenefitFeaturesAndOperations::SupportedFeatures::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)])
+                  employee_deduction: T.nilable(
+                    T::Array[
+                    T.nilable(
+                      FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::EmployeeDeduction::TaggedSymbol
+                    )
+                    ]
+                  ),
+                  frequencies: T::Array[T.nilable(FinchAPI::Models::HRIS::BenefitFrequency::TaggedSymbol)],
+                  hsa_contribution_limit: T.nilable(
+                    T::Array[
+                    T.nilable(
+                      FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::HsaContributionLimit::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 do
+                T.all(Symbol, FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::CompanyContribution)
+              end
+            OrSymbol =
+              T.type_alias do
+                T.any(
+                  Symbol,
+                  FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::CompanyContribution::TaggedSymbol
+                )
+              end
 
-            sig { override.returns(T::Array[Symbol]) }
+            FIXED =
+              T.let(
+                :fixed,
+                FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::CompanyContribution::TaggedSymbol
+              )
+            PERCENT =
+              T.let(
+                :percent,
+                FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::CompanyContribution::TaggedSymbol
+              )
+
+            sig do
+              override
+                .returns(
+                  T::Array[FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::CompanyContribution::TaggedSymbol]
+                )
+            end
             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::BenefitFeaturesAndOperations::SupportedFeatures::EmployeeDeduction) }
+            OrSymbol =
+              T.type_alias do
+                T.any(
+                  Symbol,
+                  FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::EmployeeDeduction::TaggedSymbol
+                )
+              end
 
-            FIXED = T.let(:fixed, T.nilable(Symbol))
-            PERCENT = T.let(:percent, T.nilable(Symbol))
+            FIXED =
+              T.let(
+                :fixed,
+                FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::EmployeeDeduction::TaggedSymbol
+              )
+            PERCENT =
+              T.let(
+                :percent,
+                FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::EmployeeDeduction::TaggedSymbol
+              )
 
-            sig { override.returns(T::Array[Symbol]) }
+            sig do
+              override
+                .returns(
+                  T::Array[FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::EmployeeDeduction::TaggedSymbol]
+                )
+            end
             def self.values
             end
           end
 
-          class HsaContributionLimit < FinchAPI::Enum
-            abstract!
+          module HsaContributionLimit
+            extend FinchAPI::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(Symbol, FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::HsaContributionLimit)
+              end
+            OrSymbol =
+              T.type_alias do
+                T.any(
+                  Symbol,
+                  FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::HsaContributionLimit::TaggedSymbol
+                )
+              end
 
-            INDIVIDUAL = T.let(:individual, T.nilable(Symbol))
-            FAMILY = T.let(:family, T.nilable(Symbol))
+            INDIVIDUAL =
+              T.let(
+                :individual,
+                FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::HsaContributionLimit::TaggedSymbol
+              )
+            FAMILY =
+              T.let(
+                :family,
+                FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::HsaContributionLimit::TaggedSymbol
+              )
 
-            sig { override.returns(T::Array[Symbol]) }
+            sig do
+              override
+                .returns(
+                  T::Array[
+                  FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::HsaContributionLimit::TaggedSymbol
+                  ]
+                )
+            end
             def self.values
             end
           end

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

@@ -3,14 +3,17 @@
 module FinchAPI
   module Models
     module HRIS
-      class BenefitFrequency < FinchAPI::Enum
-        abstract!
+      module BenefitFrequency
+        extend FinchAPI::Enum
 
-        ONE_TIME = T.let(:one_time, T.nilable(Symbol))
-        EVERY_PAYCHECK = T.let(:every_paycheck, T.nilable(Symbol))
-        MONTHLY = T.let(:monthly, T.nilable(Symbol))
+        TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::BenefitFrequency) }
+        OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::HRIS::BenefitFrequency::TaggedSymbol) }
 
-        sig { override.returns(T::Array[Symbol]) }
+        ONE_TIME = T.let(:one_time, FinchAPI::Models::HRIS::BenefitFrequency::TaggedSymbol)
+        EVERY_PAYCHECK = T.let(:every_paycheck, FinchAPI::Models::HRIS::BenefitFrequency::TaggedSymbol)
+        MONTHLY = T.let(:monthly, FinchAPI::Models::HRIS::BenefitFrequency::TaggedSymbol)
+
+        sig { override.returns(T::Array[FinchAPI::Models::HRIS::BenefitFrequency::TaggedSymbol]) }
         def self.values
         end
       end

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

@@ -7,8 +7,15 @@ module FinchAPI
         extend FinchAPI::RequestParameters::Converter
         include FinchAPI::RequestParameters
 
-        sig { params(request_options: T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])).void }
-        def initialize(request_options: {})
+        sig do
+          params(
+            request_options: T.any(
+              FinchAPI::RequestOptions,
+              FinchAPI::Util::AnyHash
+            )
+          ).returns(T.attached_class)
+        end
+        def self.new(request_options: {})
         end
 
         sig { override.returns({request_options: FinchAPI::RequestOptions}) }

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

@@ -7,8 +7,15 @@ module FinchAPI
         extend FinchAPI::RequestParameters::Converter
         include FinchAPI::RequestParameters
 
-        sig { params(request_options: T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])).void }
-        def initialize(request_options: {})
+        sig do
+          params(
+            request_options: T.any(
+              FinchAPI::RequestOptions,
+              FinchAPI::Util::AnyHash
+            )
+          ).returns(T.attached_class)
+        end
+        def self.new(request_options: {})
         end
 
         sig { override.returns({request_options: FinchAPI::RequestOptions}) }

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

@@ -7,8 +7,15 @@ module FinchAPI
         extend FinchAPI::RequestParameters::Converter
         include FinchAPI::RequestParameters
 
-        sig { params(request_options: T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])).void }
-        def initialize(request_options: {})
+        sig do
+          params(
+            request_options: T.any(
+              FinchAPI::RequestOptions,
+              FinchAPI::Util::AnyHash
+            )
+          ).returns(T.attached_class)
+        end
+        def self.new(request_options: {})
         end
 
         sig { override.returns({request_options: FinchAPI::RequestOptions}) }

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

@@ -3,30 +3,34 @@
 module FinchAPI
   module Models
     module HRIS
-      class BenefitType < FinchAPI::Enum
-        abstract!
+      # Type of benefit.
+      module BenefitType
+        extend FinchAPI::Enum
 
-        NUMBER_401K = T.let(:"401k", T.nilable(Symbol))
-        NUMBER_401K_ROTH = T.let(:"401k_roth", T.nilable(Symbol))
-        NUMBER_401K_LOAN = T.let(:"401k_loan", T.nilable(Symbol))
-        NUMBER_403B = T.let(:"403b", T.nilable(Symbol))
-        NUMBER_403B_ROTH = T.let(:"403b_roth", T.nilable(Symbol))
-        NUMBER_457 = T.let(:"457", T.nilable(Symbol))
-        NUMBER_457_ROTH = T.let(:"457_roth", T.nilable(Symbol))
-        S125_MEDICAL = T.let(:s125_medical, T.nilable(Symbol))
-        S125_DENTAL = T.let(:s125_dental, T.nilable(Symbol))
-        S125_VISION = T.let(:s125_vision, T.nilable(Symbol))
-        HSA_PRE = T.let(:hsa_pre, T.nilable(Symbol))
-        HSA_POST = T.let(:hsa_post, T.nilable(Symbol))
-        FSA_MEDICAL = T.let(:fsa_medical, T.nilable(Symbol))
-        FSA_DEPENDENT_CARE = T.let(:fsa_dependent_care, T.nilable(Symbol))
-        SIMPLE_IRA = T.let(:simple_ira, T.nilable(Symbol))
-        SIMPLE = T.let(:simple, T.nilable(Symbol))
-        COMMUTER = T.let(:commuter, T.nilable(Symbol))
-        CUSTOM_POST_TAX = T.let(:custom_post_tax, T.nilable(Symbol))
-        CUSTOM_PRE_TAX = T.let(:custom_pre_tax, T.nilable(Symbol))
+        TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::BenefitType) }
+        OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::HRIS::BenefitType::TaggedSymbol) }
 
-        sig { override.returns(T::Array[Symbol]) }
+        NUMBER_401K = T.let(:"401k", FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
+        NUMBER_401K_ROTH = T.let(:"401k_roth", FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
+        NUMBER_401K_LOAN = T.let(:"401k_loan", FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
+        NUMBER_403B = T.let(:"403b", FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
+        NUMBER_403B_ROTH = T.let(:"403b_roth", FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
+        NUMBER_457 = T.let(:"457", FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
+        NUMBER_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)
+
+        sig { override.returns(T::Array[FinchAPI::Models::HRIS::BenefitType::TaggedSymbol]) }
         def self.values
         end
       end

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

@@ -7,25 +7,21 @@ module FinchAPI
         extend FinchAPI::RequestParameters::Converter
         include FinchAPI::RequestParameters
 
+        # Updated name or description.
         sig { returns(T.nilable(String)) }
-        def description
-        end
+        attr_reader :description
 
-        sig { params(_: String).returns(String) }
-        def description=(_)
-        end
+        sig { params(description: String).void }
+        attr_writer :description
 
         sig do
           params(
             description: String,
-            request_options: T.any(
-              FinchAPI::RequestOptions,
-              T::Hash[Symbol, T.anything]
-            )
+            request_options: T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash)
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(description: nil, request_options: {})
+        def self.new(description: nil, request_options: {})
         end
 
         sig { override.returns({description: String, request_options: FinchAPI::RequestOptions}) }