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

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

@@ -8,25 +8,26 @@ module FinchAPI
           extend FinchAPI::RequestParameters::Converter
           include FinchAPI::RequestParameters
 
+          # Array of the individual_id to enroll and a configuration object.
           sig { returns(T.nilable(T::Array[FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual])) }
-          def individuals
-          end
+          attr_reader :individuals
 
           sig do
-            params(_: T::Array[FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual])
-              .returns(T::Array[FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual])
-          end
-          def individuals=(_)
+            params(
+              individuals: T::Array[T.any(FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual, FinchAPI::Util::AnyHash)]
+            )
+              .void
           end
+          attr_writer :individuals
 
           sig do
             params(
-              individuals: T::Array[FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual],
-              request_options: T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])
+              individuals: T::Array[T.any(FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual, FinchAPI::Util::AnyHash)],
+              request_options: T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash)
             )
-              .void
+              .returns(T.attached_class)
           end
-          def initialize(individuals: nil, request_options: {})
+          def self.new(individuals: nil, request_options: {})
           end
 
           sig do
@@ -47,32 +48,37 @@ module FinchAPI
                 T.nilable(FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration)
               )
             end
-            def configuration
-            end
+            attr_reader :configuration
 
             sig do
-              params(_: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration)
-                .returns(FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration)
-            end
-            def configuration=(_)
+              params(
+                configuration: T.any(
+                  FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration,
+                  FinchAPI::Util::AnyHash
+                )
+              )
+                .void
             end
+            attr_writer :configuration
 
+            # Finch id (uuidv4) for the individual to enroll
             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
 
             sig do
               params(
-                configuration: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration,
+                configuration: T.any(
+                  FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration,
+                  FinchAPI::Util::AnyHash
+                ),
                 individual_id: String
               )
-                .void
+                .returns(T.attached_class)
             end
-            def initialize(configuration: nil, individual_id: nil)
+            def self.new(configuration: nil, individual_id: nil)
             end
 
             sig do
@@ -88,29 +94,35 @@ module FinchAPI
             end
 
             class Configuration < FinchAPI::BaseModel
-              sig { returns(T.nilable(Symbol)) }
-              def annual_contribution_limit
+              # For HSA benefits only - whether the contribution limit is for an individual or
+              #   family
+              sig do
+                returns(
+                  T.nilable(
+                    FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::AnnualContributionLimit::OrSymbol
+                  )
+                )
               end
+              attr_reader :annual_contribution_limit
 
-              sig { params(_: Symbol).returns(Symbol) }
-              def annual_contribution_limit=(_)
+              sig do
+                params(
+                  annual_contribution_limit: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::AnnualContributionLimit::OrSymbol
+                )
+                  .void
               end
+              attr_writer :annual_contribution_limit
 
+              # Maximum annual amount in cents
               sig { returns(T.nilable(Integer)) }
-              def annual_maximum
-              end
-
-              sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-              def annual_maximum=(_)
-              end
+              attr_accessor :annual_maximum
 
+              # For retirement benefits only - whether catch up contributions are enabled
               sig { returns(T.nilable(T::Boolean)) }
-              def catch_up
-              end
+              attr_reader :catch_up
 
-              sig { params(_: T::Boolean).returns(T::Boolean) }
-              def catch_up=(_)
-              end
+              sig { params(catch_up: T::Boolean).void }
+              attr_writer :catch_up
 
               sig do
                 returns(
@@ -119,19 +131,18 @@ module FinchAPI
                   )
                 )
               end
-              def company_contribution
-              end
+              attr_reader :company_contribution
 
               sig do
                 params(
-                  _: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution
-                )
-                  .returns(
-                    FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution
+                  company_contribution: T.any(
+                    FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution,
+                    FinchAPI::Util::AnyHash
                   )
+                )
+                  .void
               end
-              def company_contribution=(_)
-              end
+              attr_writer :company_contribution
 
               sig do
                 returns(
@@ -140,31 +151,36 @@ module FinchAPI
                   )
                 )
               end
-              def employee_deduction
-              end
+              attr_reader :employee_deduction
 
               sig do
                 params(
-                  _: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction
-                )
-                  .returns(
-                    FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction
+                  employee_deduction: T.any(
+                    FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction,
+                    FinchAPI::Util::AnyHash
                   )
+                )
+                  .void
               end
-              def employee_deduction=(_)
-              end
+              attr_writer :employee_deduction
 
               sig do
                 params(
-                  annual_contribution_limit: Symbol,
+                  annual_contribution_limit: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::AnnualContributionLimit::OrSymbol,
                   annual_maximum: T.nilable(Integer),
                   catch_up: T::Boolean,
-                  company_contribution: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution,
-                  employee_deduction: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction
+                  company_contribution: T.any(
+                    FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution,
+                    FinchAPI::Util::AnyHash
+                  ),
+                  employee_deduction: T.any(
+                    FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction,
+                    FinchAPI::Util::AnyHash
+                  )
                 )
-                  .void
+                  .returns(T.attached_class)
               end
-              def initialize(
+              def self.new(
                 annual_contribution_limit: nil,
                 annual_maximum: nil,
                 catch_up: nil,
@@ -177,7 +193,7 @@ module FinchAPI
                 override
                   .returns(
                     {
-                      annual_contribution_limit: Symbol,
+                      annual_contribution_limit: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::AnnualContributionLimit::OrSymbol,
                       annual_maximum: T.nilable(Integer),
                       catch_up: T::Boolean,
                       company_contribution: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution,
@@ -188,86 +204,215 @@ module FinchAPI
               def to_hash
               end
 
-              class AnnualContributionLimit < FinchAPI::Enum
-                abstract!
+              # For HSA benefits only - whether the contribution limit is for an individual or
+              #   family
+              module AnnualContributionLimit
+                extend FinchAPI::Enum
 
-                INDIVIDUAL = :individual
-                FAMILY = :family
+                TaggedSymbol =
+                  T.type_alias do
+                    T.all(Symbol, FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::AnnualContributionLimit)
+                  end
+                OrSymbol =
+                  T.type_alias do
+                    T.any(
+                      Symbol,
+                      FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::AnnualContributionLimit::TaggedSymbol
+                    )
+                  end
+
+                INDIVIDUAL =
+                  T.let(
+                    :individual,
+                    FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::AnnualContributionLimit::TaggedSymbol
+                  )
+                FAMILY =
+                  T.let(
+                    :family,
+                    FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::AnnualContributionLimit::TaggedSymbol
+                  )
 
-                sig { override.returns(T::Array[Symbol]) }
+                sig do
+                  override
+                    .returns(
+                      T::Array[
+                      FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::AnnualContributionLimit::TaggedSymbol
+                      ]
+                    )
+                end
                 def self.values
                 end
               end
 
               class CompanyContribution < FinchAPI::BaseModel
+                # Amount in cents for fixed type or basis points (1/100th of a percent) for
+                #   percent type
                 sig { returns(T.nilable(Integer)) }
-                def amount
-                end
+                attr_reader :amount
 
-                sig { params(_: Integer).returns(Integer) }
-                def amount=(_)
-                end
+                sig { params(amount: Integer).void }
+                attr_writer :amount
 
-                sig { returns(T.nilable(Symbol)) }
-                def type
+                sig do
+                  returns(
+                    T.nilable(
+                      FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution::Type::OrSymbol
+                    )
+                  )
                 end
+                attr_reader :type
 
-                sig { params(_: Symbol).returns(Symbol) }
-                def type=(_)
+                sig do
+                  params(
+                    type: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution::Type::OrSymbol
+                  )
+                    .void
                 end
+                attr_writer :type
 
-                sig { params(amount: Integer, type: Symbol).void }
-                def initialize(amount: nil, type: nil)
+                sig do
+                  params(
+                    amount: Integer,
+                    type: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution::Type::OrSymbol
+                  )
+                    .returns(T.attached_class)
+                end
+                def self.new(amount: nil, type: nil)
                 end
 
-                sig { override.returns({amount: Integer, type: Symbol}) }
+                sig do
+                  override
+                    .returns(
+                      {
+                        amount: Integer,
+                        type: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution::Type::OrSymbol
+                      }
+                    )
+                end
                 def to_hash
                 end
 
-                class Type < FinchAPI::Enum
-                  abstract!
-
-                  FIXED = :fixed
-                  PERCENT = :percent
-
-                  sig { override.returns(T::Array[Symbol]) }
+                module Type
+                  extend FinchAPI::Enum
+
+                  TaggedSymbol =
+                    T.type_alias do
+                      T.all(Symbol, FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution::Type)
+                    end
+                  OrSymbol =
+                    T.type_alias do
+                      T.any(
+                        Symbol,
+                        FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution::Type::TaggedSymbol
+                      )
+                    end
+
+                  FIXED =
+                    T.let(
+                      :fixed,
+                      FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution::Type::TaggedSymbol
+                    )
+                  PERCENT =
+                    T.let(
+                      :percent,
+                      FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution::Type::TaggedSymbol
+                    )
+
+                  sig do
+                    override
+                      .returns(
+                        T::Array[
+                        FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution::Type::TaggedSymbol
+                        ]
+                      )
+                  end
                   def self.values
                   end
                 end
               end
 
               class EmployeeDeduction < FinchAPI::BaseModel
+                # Amount in cents for fixed type or basis points (1/100th of a percent) for
+                #   percent type
                 sig { returns(T.nilable(Integer)) }
-                def amount
-                end
+                attr_reader :amount
 
-                sig { params(_: Integer).returns(Integer) }
-                def amount=(_)
-                end
+                sig { params(amount: Integer).void }
+                attr_writer :amount
 
-                sig { returns(T.nilable(Symbol)) }
-                def type
+                sig do
+                  returns(
+                    T.nilable(
+                      FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction::Type::OrSymbol
+                    )
+                  )
                 end
+                attr_reader :type
 
-                sig { params(_: Symbol).returns(Symbol) }
-                def type=(_)
+                sig do
+                  params(
+                    type: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction::Type::OrSymbol
+                  )
+                    .void
                 end
+                attr_writer :type
 
-                sig { params(amount: Integer, type: Symbol).void }
-                def initialize(amount: nil, type: nil)
+                sig do
+                  params(
+                    amount: Integer,
+                    type: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction::Type::OrSymbol
+                  )
+                    .returns(T.attached_class)
+                end
+                def self.new(amount: nil, type: nil)
                 end
 
-                sig { override.returns({amount: Integer, type: Symbol}) }
+                sig do
+                  override
+                    .returns(
+                      {
+                        amount: Integer,
+                        type: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction::Type::OrSymbol
+                      }
+                    )
+                end
                 def to_hash
                 end
 
-                class Type < FinchAPI::Enum
-                  abstract!
-
-                  FIXED = :fixed
-                  PERCENT = :percent
-
-                  sig { override.returns(T::Array[Symbol]) }
+                module Type
+                  extend FinchAPI::Enum
+
+                  TaggedSymbol =
+                    T.type_alias do
+                      T.all(Symbol, FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction::Type)
+                    end
+                  OrSymbol =
+                    T.type_alias do
+                      T.any(
+                        Symbol,
+                        FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction::Type::TaggedSymbol
+                      )
+                    end
+
+                  FIXED =
+                    T.let(
+                      :fixed,
+                      FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction::Type::TaggedSymbol
+                    )
+                  PERCENT =
+                    T.let(
+                      :percent,
+                      FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction::Type::TaggedSymbol
+                    )
+
+                  sig do
+                    override
+                      .returns(
+                        T::Array[
+                        FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction::Type::TaggedSymbol
+                        ]
+                      )
+                  end
                   def self.values
                   end
                 end

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

@@ -8,8 +8,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/benefits/individual_enrolled_ids_response.rbi

@@ -6,23 +6,13 @@ module FinchAPI
       module Benefits
         class IndividualEnrolledIDsResponse < FinchAPI::BaseModel
           sig { returns(String) }
-          def benefit_id
-          end
-
-          sig { params(_: String).returns(String) }
-          def benefit_id=(_)
-          end
+          attr_accessor :benefit_id
 
           sig { returns(T::Array[String]) }
-          def individual_ids
-          end
-
-          sig { params(_: T::Array[String]).returns(T::Array[String]) }
-          def individual_ids=(_)
-          end
+          attr_accessor :individual_ids
 
-          sig { params(benefit_id: String, individual_ids: T::Array[String]).void }
-          def initialize(benefit_id:, individual_ids:)
+          sig { params(benefit_id: String, individual_ids: T::Array[String]).returns(T.attached_class) }
+          def self.new(benefit_id:, individual_ids:)
           end
 
           sig { override.returns({benefit_id: String, individual_ids: T::Array[String]}) }

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

@@ -8,22 +8,25 @@ module FinchAPI
           extend FinchAPI::RequestParameters::Converter
           include FinchAPI::RequestParameters
 
+          # comma-delimited list of stable Finch uuids for each individual. If empty,
+          #   defaults to all individuals
           sig { returns(T.nilable(String)) }
-          def individual_ids
-          end
+          attr_reader :individual_ids
 
-          sig { params(_: String).returns(String) }
-          def individual_ids=(_)
-          end
+          sig { params(individual_ids: String).void }
+          attr_writer :individual_ids
 
           sig do
             params(
               individual_ids: 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(individual_ids: nil, request_options: {})
+          def self.new(individual_ids: nil, request_options: {})
           end
 
           sig { override.returns({individual_ids: String, request_options: FinchAPI::RequestOptions}) }

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

@@ -8,22 +8,21 @@ module FinchAPI
           extend FinchAPI::RequestParameters::Converter
           include FinchAPI::RequestParameters
 
+          # Array of individual_ids to unenroll.
           sig { returns(T.nilable(T::Array[String])) }
-          def individual_ids
-          end
+          attr_reader :individual_ids
 
-          sig { params(_: T::Array[String]).returns(T::Array[String]) }
-          def individual_ids=(_)
-          end
+          sig { params(individual_ids: T::Array[String]).void }
+          attr_writer :individual_ids
 
           sig do
             params(
               individual_ids: T::Array[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(individual_ids: nil, request_options: {})
+          def self.new(individual_ids: nil, request_options: {})
           end
 
           sig do