finch-api 0.1.0.pre.alpha.23 → 0.1.0.pre.alpha.24

data/rbi/finch_api/models/hris/benefit_create_params.rbi

@@ -105,41 +105,19 @@ module FinchAPI
 
           sig do
             returns(
-              T.nilable(
-                T::Array[
-                  FinchAPI::HRIS::BenefitCreateParams::CompanyContribution::Tier
-                ]
-              )
+              T::Array[
+                FinchAPI::HRIS::BenefitCreateParams::CompanyContribution::Tier
+              ]
             )
           end
-          attr_reader :tiers
-
-          sig do
-            params(
-              tiers:
-                T::Array[
-                  FinchAPI::HRIS::BenefitCreateParams::CompanyContribution::Tier::OrHash
-                ]
-            ).void
-          end
-          attr_writer :tiers
+          attr_accessor :tiers
 
           sig do
             returns(
-              T.nilable(
-                FinchAPI::HRIS::BenefitCreateParams::CompanyContribution::Type::OrSymbol
-              )
+              FinchAPI::HRIS::BenefitCreateParams::CompanyContribution::Type::OrSymbol
             )
           end
-          attr_reader :type
-
-          sig do
-            params(
-              type:
-                FinchAPI::HRIS::BenefitCreateParams::CompanyContribution::Type::OrSymbol
-            ).void
-          end
-          attr_writer :type
+          attr_accessor :type
 
           # The company match for this benefit.
           sig do
@@ -152,7 +130,7 @@ module FinchAPI
                 FinchAPI::HRIS::BenefitCreateParams::CompanyContribution::Type::OrSymbol
             ).returns(T.attached_class)
           end
-          def self.new(tiers: nil, type: nil)
+          def self.new(tiers:, type:)
           end
 
           sig do
@@ -179,24 +157,18 @@ module FinchAPI
                 )
               end
 
-            sig { returns(T.nilable(Integer)) }
-            attr_reader :match
-
-            sig { params(match: Integer).void }
-            attr_writer :match
-
-            sig { returns(T.nilable(Integer)) }
-            attr_reader :threshold
+            sig { returns(Integer) }
+            attr_accessor :match
 
-            sig { params(threshold: Integer).void }
-            attr_writer :threshold
+            sig { returns(Integer) }
+            attr_accessor :threshold
 
             sig do
               params(match: Integer, threshold: Integer).returns(
                 T.attached_class
               )
             end
-            def self.new(match: nil, threshold: nil)
+            def self.new(match:, threshold:)
             end
 
             sig { override.returns({ match: Integer, threshold: Integer }) }

data/rbi/finch_api/models/hris/benefit_frequency.rbi

@@ -11,12 +11,12 @@ module FinchAPI
           T.type_alias { T.all(Symbol, FinchAPI::HRIS::BenefitFrequency) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        ONE_TIME =
-          T.let(:one_time, FinchAPI::HRIS::BenefitFrequency::TaggedSymbol)
         EVERY_PAYCHECK =
           T.let(:every_paycheck, FinchAPI::HRIS::BenefitFrequency::TaggedSymbol)
         MONTHLY =
           T.let(:monthly, FinchAPI::HRIS::BenefitFrequency::TaggedSymbol)
+        ONE_TIME =
+          T.let(:one_time, FinchAPI::HRIS::BenefitFrequency::TaggedSymbol)
 
         sig do
           override.returns(

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

@@ -16,45 +16,35 @@ module FinchAPI
             end
 
           sig do
-            returns(
-              T.nilable(FinchAPI::HRIS::Benefits::IndividualBenefit::Body)
-            )
-          end
-          attr_reader :body
-
-          sig do
-            params(
-              body: FinchAPI::HRIS::Benefits::IndividualBenefit::Body::OrHash
-            ).void
+            returns(FinchAPI::HRIS::Benefits::IndividualBenefit::Body::Variants)
           end
-          attr_writer :body
-
-          sig { returns(T.nilable(Integer)) }
-          attr_reader :code
+          attr_accessor :body
 
-          sig { params(code: Integer).void }
-          attr_writer :code
+          sig { returns(Integer) }
+          attr_accessor :code
 
-          sig { returns(T.nilable(String)) }
-          attr_reader :individual_id
-
-          sig { params(individual_id: String).void }
-          attr_writer :individual_id
+          sig { returns(String) }
+          attr_accessor :individual_id
 
           sig do
             params(
-              body: FinchAPI::HRIS::Benefits::IndividualBenefit::Body::OrHash,
+              body:
+                T.any(
+                  FinchAPI::HRIS::Benefits::IndividualBenefit::Body::UnionMember0::OrHash,
+                  FinchAPI::HRIS::Benefits::IndividualBenefit::Body::BatchError::OrHash
+                ),
               code: Integer,
               individual_id: String
             ).returns(T.attached_class)
           end
-          def self.new(body: nil, code: nil, individual_id: nil)
+          def self.new(body:, code:, individual_id:)
           end
 
           sig do
             override.returns(
               {
-                body: FinchAPI::HRIS::Benefits::IndividualBenefit::Body,
+                body:
+                  FinchAPI::HRIS::Benefits::IndividualBenefit::Body::Variants,
                 code: Integer,
                 individual_id: String
               }
@@ -63,136 +53,207 @@ module FinchAPI
           def to_hash
           end
 
-          class Body < FinchAPI::Internal::Type::BaseModel
-            OrHash =
+          module Body
+            extend FinchAPI::Internal::Type::Union
+
+            Variants =
               T.type_alias do
                 T.any(
-                  FinchAPI::HRIS::Benefits::IndividualBenefit::Body,
-                  FinchAPI::Internal::AnyHash
+                  FinchAPI::HRIS::Benefits::IndividualBenefit::Body::UnionMember0,
+                  FinchAPI::HRIS::Benefits::IndividualBenefit::Body::BatchError
                 )
               end
 
-            # If the benefit supports annual maximum, the amount in cents for this individual.
-            sig { returns(T.nilable(Integer)) }
-            attr_accessor :annual_maximum
+            class UnionMember0 < FinchAPI::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    FinchAPI::HRIS::Benefits::IndividualBenefit::Body::UnionMember0,
+                    FinchAPI::Internal::AnyHash
+                  )
+                end
 
-            # If the benefit supports catch up (401k, 403b, etc.), whether catch up is enabled
-            # for this individual.
-            sig { returns(T.nilable(T::Boolean)) }
-            attr_accessor :catch_up
+              # If the benefit supports annual maximum, the amount in cents for this individual.
+              sig { returns(T.nilable(Integer)) }
+              attr_accessor :annual_maximum
 
-            sig { returns(T.nilable(FinchAPI::HRIS::BenefitContribution)) }
-            attr_reader :company_contribution
+              # If the benefit supports catch up (401k, 403b, etc.), whether catch up is enabled
+              # for this individual.
+              sig { returns(T.nilable(T::Boolean)) }
+              attr_accessor :catch_up
 
-            sig do
-              params(
-                company_contribution:
-                  T.nilable(FinchAPI::HRIS::BenefitContribution::OrHash)
-              ).void
-            end
-            attr_writer :company_contribution
+              sig { returns(T.nilable(FinchAPI::HRIS::BenefitContribution)) }
+              attr_reader :company_contribution
 
-            sig { returns(T.nilable(FinchAPI::HRIS::BenefitContribution)) }
-            attr_reader :employee_deduction
+              sig do
+                params(
+                  company_contribution:
+                    T.nilable(FinchAPI::HRIS::BenefitContribution::OrHash)
+                ).void
+              end
+              attr_writer :company_contribution
 
-            sig do
-              params(
-                employee_deduction:
-                  T.nilable(FinchAPI::HRIS::BenefitContribution::OrHash)
-              ).void
-            end
-            attr_writer :employee_deduction
+              sig { returns(T.nilable(FinchAPI::HRIS::BenefitContribution)) }
+              attr_reader :employee_deduction
 
-            # Type for HSA contribution limit if the benefit is a HSA.
-            sig do
-              returns(
-                T.nilable(
-                  FinchAPI::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::TaggedSymbol
-                )
-              )
-            end
-            attr_accessor :hsa_contribution_limit
+              sig do
+                params(
+                  employee_deduction:
+                    T.nilable(FinchAPI::HRIS::BenefitContribution::OrHash)
+                ).void
+              end
+              attr_writer :employee_deduction
 
-            sig do
-              params(
-                annual_maximum: T.nilable(Integer),
-                catch_up: T.nilable(T::Boolean),
-                company_contribution:
-                  T.nilable(FinchAPI::HRIS::BenefitContribution::OrHash),
-                employee_deduction:
-                  T.nilable(FinchAPI::HRIS::BenefitContribution::OrHash),
-                hsa_contribution_limit:
+              # Type for HSA contribution limit if the benefit is a HSA.
+              sig do
+                returns(
                   T.nilable(
-                    FinchAPI::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::OrSymbol
+                    FinchAPI::HRIS::Benefits::IndividualBenefit::Body::UnionMember0::HsaContributionLimit::TaggedSymbol
                   )
-              ).returns(T.attached_class)
-            end
-            def self.new(
-              # If the benefit supports annual maximum, the amount in cents for this individual.
-              annual_maximum: nil,
-              # If the benefit supports catch up (401k, 403b, etc.), whether catch up is enabled
-              # for this individual.
-              catch_up: nil,
-              company_contribution: nil,
-              employee_deduction: nil,
-              # Type for HSA contribution limit if the benefit is a HSA.
-              hsa_contribution_limit: nil
-            )
-            end
+                )
+              end
+              attr_accessor :hsa_contribution_limit
 
-            sig do
-              override.returns(
-                {
+              sig do
+                params(
                   annual_maximum: T.nilable(Integer),
                   catch_up: T.nilable(T::Boolean),
                   company_contribution:
-                    T.nilable(FinchAPI::HRIS::BenefitContribution),
+                    T.nilable(FinchAPI::HRIS::BenefitContribution::OrHash),
                   employee_deduction:
-                    T.nilable(FinchAPI::HRIS::BenefitContribution),
+                    T.nilable(FinchAPI::HRIS::BenefitContribution::OrHash),
                   hsa_contribution_limit:
                     T.nilable(
-                      FinchAPI::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::TaggedSymbol
+                      FinchAPI::HRIS::Benefits::IndividualBenefit::Body::UnionMember0::HsaContributionLimit::OrSymbol
                     )
-                }
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                # If the benefit supports annual maximum, the amount in cents for this individual.
+                annual_maximum:,
+                # If the benefit supports catch up (401k, 403b, etc.), whether catch up is enabled
+                # for this individual.
+                catch_up:,
+                company_contribution:,
+                employee_deduction:,
+                # Type for HSA contribution limit if the benefit is a HSA.
+                hsa_contribution_limit: nil
               )
-            end
-            def to_hash
-            end
+              end
 
-            # Type for HSA contribution limit if the benefit is a HSA.
-            module HsaContributionLimit
-              extend FinchAPI::Internal::Type::Enum
+              sig do
+                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::UnionMember0::HsaContributionLimit::TaggedSymbol
+                      )
+                  }
+                )
+              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 do
+                    T.all(
+                      Symbol,
+                      FinchAPI::HRIS::Benefits::IndividualBenefit::Body::UnionMember0::HsaContributionLimit
+                    )
+                  end
+                OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-              TaggedSymbol =
+                INDIVIDUAL =
+                  T.let(
+                    :individual,
+                    FinchAPI::HRIS::Benefits::IndividualBenefit::Body::UnionMember0::HsaContributionLimit::TaggedSymbol
+                  )
+                FAMILY =
+                  T.let(
+                    :family,
+                    FinchAPI::HRIS::Benefits::IndividualBenefit::Body::UnionMember0::HsaContributionLimit::TaggedSymbol
+                  )
+
+                sig do
+                  override.returns(
+                    T::Array[
+                      FinchAPI::HRIS::Benefits::IndividualBenefit::Body::UnionMember0::HsaContributionLimit::TaggedSymbol
+                    ]
+                  )
+                end
+                def self.values
+                end
+              end
+            end
+
+            class BatchError < FinchAPI::Internal::Type::BaseModel
+              OrHash =
                 T.type_alias do
-                  T.all(
-                    Symbol,
-                    FinchAPI::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit
+                  T.any(
+                    FinchAPI::HRIS::Benefits::IndividualBenefit::Body::BatchError,
+                    FinchAPI::Internal::AnyHash
                   )
                 end
-              OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-              INDIVIDUAL =
-                T.let(
-                  :individual,
-                  FinchAPI::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::TaggedSymbol
-                )
-              FAMILY =
-                T.let(
-                  :family,
-                  FinchAPI::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::TaggedSymbol
-                )
+              sig { returns(Float) }
+              attr_accessor :code
+
+              sig { returns(String) }
+              attr_accessor :message
+
+              sig { returns(String) }
+              attr_accessor :name
+
+              sig { returns(T.nilable(String)) }
+              attr_reader :finch_code
+
+              sig { params(finch_code: String).void }
+              attr_writer :finch_code
+
+              sig do
+                params(
+                  code: Float,
+                  message: String,
+                  name: String,
+                  finch_code: String
+                ).returns(T.attached_class)
+              end
+              def self.new(code:, message:, name:, finch_code: nil)
+              end
 
               sig do
                 override.returns(
-                  T::Array[
-                    FinchAPI::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::TaggedSymbol
-                  ]
+                  {
+                    code: Float,
+                    message: String,
+                    name: String,
+                    finch_code: String
+                  }
                 )
               end
-              def self.values
+              def to_hash
               end
             end
+
+            sig do
+              override.returns(
+                T::Array[
+                  FinchAPI::HRIS::Benefits::IndividualBenefit::Body::Variants
+                ]
+              )
+            end
+            def self.variants
+            end
           end
         end
       end

data/rbi/finch_api/models/hris/company_benefit.rbi

@@ -13,6 +13,19 @@ module FinchAPI
         sig { returns(String) }
         attr_accessor :benefit_id
 
+        sig { returns(T.nilable(String)) }
+        attr_accessor :description
+
+        # The frequency of the benefit deduction/contribution.
+        sig do
+          returns(T.nilable(FinchAPI::HRIS::BenefitFrequency::TaggedSymbol))
+        end
+        attr_accessor :frequency
+
+        # Type of benefit.
+        sig { returns(T.nilable(FinchAPI::HRIS::BenefitType::TaggedSymbol)) }
+        attr_accessor :type
+
         # The company match for this benefit.
         sig do
           returns(
@@ -31,41 +44,28 @@ module FinchAPI
         end
         attr_writer :company_contribution
 
-        sig { returns(T.nilable(String)) }
-        attr_accessor :description
-
-        # The frequency of the benefit deduction/contribution.
-        sig do
-          returns(T.nilable(FinchAPI::HRIS::BenefitFrequency::TaggedSymbol))
-        end
-        attr_accessor :frequency
-
-        # Type of benefit.
-        sig { returns(T.nilable(FinchAPI::HRIS::BenefitType::TaggedSymbol)) }
-        attr_accessor :type
-
         sig do
           params(
             benefit_id: String,
+            description: T.nilable(String),
+            frequency: T.nilable(FinchAPI::HRIS::BenefitFrequency::OrSymbol),
+            type: T.nilable(FinchAPI::HRIS::BenefitType::OrSymbol),
             company_contribution:
               T.nilable(
                 FinchAPI::HRIS::CompanyBenefit::CompanyContribution::OrHash
-              ),
-            description: T.nilable(String),
-            frequency: T.nilable(FinchAPI::HRIS::BenefitFrequency::OrSymbol),
-            type: T.nilable(FinchAPI::HRIS::BenefitType::OrSymbol)
+              )
           ).returns(T.attached_class)
         end
         def self.new(
           # The id of the benefit.
           benefit_id:,
-          # The company match for this benefit.
-          company_contribution:,
           description:,
           # The frequency of the benefit deduction/contribution.
           frequency:,
           # Type of benefit.
-          type:
+          type:,
+          # The company match for this benefit.
+          company_contribution: nil
         )
         end
 
@@ -73,12 +73,12 @@ module FinchAPI
           override.returns(
             {
               benefit_id: String,
-              company_contribution:
-                T.nilable(FinchAPI::HRIS::CompanyBenefit::CompanyContribution),
               description: T.nilable(String),
               frequency:
                 T.nilable(FinchAPI::HRIS::BenefitFrequency::TaggedSymbol),
-              type: T.nilable(FinchAPI::HRIS::BenefitType::TaggedSymbol)
+              type: T.nilable(FinchAPI::HRIS::BenefitType::TaggedSymbol),
+              company_contribution:
+                T.nilable(FinchAPI::HRIS::CompanyBenefit::CompanyContribution)
             }
           )
         end
@@ -96,41 +96,19 @@ module FinchAPI
 
           sig do
             returns(
-              T.nilable(
-                T::Array[
-                  FinchAPI::HRIS::CompanyBenefit::CompanyContribution::Tier
-                ]
-              )
+              T::Array[
+                FinchAPI::HRIS::CompanyBenefit::CompanyContribution::Tier
+              ]
             )
           end
-          attr_reader :tiers
-
-          sig do
-            params(
-              tiers:
-                T::Array[
-                  FinchAPI::HRIS::CompanyBenefit::CompanyContribution::Tier::OrHash
-                ]
-            ).void
-          end
-          attr_writer :tiers
+          attr_accessor :tiers
 
           sig do
             returns(
-              T.nilable(
-                FinchAPI::HRIS::CompanyBenefit::CompanyContribution::Type::TaggedSymbol
-              )
+              FinchAPI::HRIS::CompanyBenefit::CompanyContribution::Type::TaggedSymbol
             )
           end
-          attr_reader :type
-
-          sig do
-            params(
-              type:
-                FinchAPI::HRIS::CompanyBenefit::CompanyContribution::Type::OrSymbol
-            ).void
-          end
-          attr_writer :type
+          attr_accessor :type
 
           # The company match for this benefit.
           sig do
@@ -143,7 +121,7 @@ module FinchAPI
                 FinchAPI::HRIS::CompanyBenefit::CompanyContribution::Type::OrSymbol
             ).returns(T.attached_class)
           end
-          def self.new(tiers: nil, type: nil)
+          def self.new(tiers:, type:)
           end
 
           sig do
@@ -170,24 +148,18 @@ module FinchAPI
                 )
               end
 
-            sig { returns(T.nilable(Integer)) }
-            attr_reader :match
-
-            sig { params(match: Integer).void }
-            attr_writer :match
-
-            sig { returns(T.nilable(Integer)) }
-            attr_reader :threshold
+            sig { returns(Integer) }
+            attr_accessor :match
 
-            sig { params(threshold: Integer).void }
-            attr_writer :threshold
+            sig { returns(Integer) }
+            attr_accessor :threshold
 
             sig do
               params(match: Integer, threshold: Integer).returns(
                 T.attached_class
               )
             end
-            def self.new(match: nil, threshold: nil)
+            def self.new(match:, threshold:)
             end
 
             sig { override.returns({ match: Integer, threshold: Integer }) }