finch-api 0.1.0.pre.alpha.19 → 0.1.0.pre.alpha.20

data/rbi/finch_api/models/hris/pay_statement.rbi

@@ -49,11 +49,8 @@ module FinchAPI
         attr_writer :gross_pay
 
         # A stable Finch `id` (UUID v4) for an individual in the company
-        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 { returns(T.nilable(FinchAPI::Money)) }
         attr_reader :net_pay
@@ -126,22 +123,22 @@ module FinchAPI
         end
         def self.new(
           # The array of earnings objects associated with this pay statement
-          earnings: nil,
+          earnings:,
           # The array of deductions objects associated with this pay statement.
-          employee_deductions: nil,
-          employer_contributions: nil,
-          gross_pay: nil,
+          employee_deductions:,
+          employer_contributions:,
+          gross_pay:,
           # A stable Finch `id` (UUID v4) for an individual in the company
-          individual_id: nil,
-          net_pay: nil,
+          individual_id:,
+          net_pay:,
           # The payment method.
-          payment_method: nil,
+          payment_method:,
           # The array of taxes objects associated with this pay statement.
-          taxes: nil,
+          taxes:,
           # The number of hours worked for this pay period
-          total_hours: nil,
+          total_hours:,
           # The type of the payment associated with the pay statement.
-          type: nil
+          type:
         )
         end
 
@@ -198,23 +195,6 @@ module FinchAPI
           sig { returns(T.nilable(Integer)) }
           attr_accessor :amount
 
-          sig do
-            returns(
-              T.nilable(FinchAPI::HRIS::PayStatement::Earning::Attributes)
-            )
-          end
-          attr_reader :attributes
-
-          sig do
-            params(
-              attributes:
-                T.nilable(
-                  FinchAPI::HRIS::PayStatement::Earning::Attributes::OrHash
-                )
-            ).void
-          end
-          attr_writer :attributes
-
           # The earnings currency code.
           sig { returns(T.nilable(String)) }
           attr_accessor :currency
@@ -238,33 +218,52 @@ module FinchAPI
           end
           attr_accessor :type
 
+          sig do
+            returns(
+              T.nilable(FinchAPI::HRIS::PayStatement::Earning::Attributes)
+            )
+          end
+          attr_reader :attributes
+
           sig do
             params(
-              amount: T.nilable(Integer),
               attributes:
                 T.nilable(
                   FinchAPI::HRIS::PayStatement::Earning::Attributes::OrHash
-                ),
+                )
+            ).void
+          end
+          attr_writer :attributes
+
+          sig do
+            params(
+              amount: T.nilable(Integer),
               currency: T.nilable(String),
               hours: T.nilable(Float),
               name: T.nilable(String),
               type:
-                T.nilable(FinchAPI::HRIS::PayStatement::Earning::Type::OrSymbol)
+                T.nilable(
+                  FinchAPI::HRIS::PayStatement::Earning::Type::OrSymbol
+                ),
+              attributes:
+                T.nilable(
+                  FinchAPI::HRIS::PayStatement::Earning::Attributes::OrHash
+                )
             ).returns(T.attached_class)
           end
           def self.new(
             # The earnings amount in cents.
-            amount: nil,
-            attributes: nil,
+            amount:,
             # The earnings currency code.
-            currency: nil,
+            currency:,
             # The number of hours associated with this earning. (For salaried employees, this
             # could be hours per pay period, `0` or `null`, depending on the provider).
-            hours: nil,
+            hours:,
             # The exact name of the deduction from the pay statement.
-            name: nil,
+            name:,
             # The type of earning.
-            type: nil
+            type:,
+            attributes: nil
           )
           end
 
@@ -272,110 +271,21 @@ module FinchAPI
             override.returns(
               {
                 amount: T.nilable(Integer),
-                attributes:
-                  T.nilable(FinchAPI::HRIS::PayStatement::Earning::Attributes),
                 currency: T.nilable(String),
                 hours: T.nilable(Float),
                 name: T.nilable(String),
                 type:
                   T.nilable(
                     FinchAPI::HRIS::PayStatement::Earning::Type::TaggedSymbol
-                  )
+                  ),
+                attributes:
+                  T.nilable(FinchAPI::HRIS::PayStatement::Earning::Attributes)
               }
             )
           end
           def to_hash
           end
 
-          class Attributes < FinchAPI::Internal::Type::BaseModel
-            OrHash =
-              T.type_alias do
-                T.any(
-                  FinchAPI::HRIS::PayStatement::Earning::Attributes,
-                  FinchAPI::Internal::AnyHash
-                )
-              end
-
-            sig do
-              returns(
-                T.nilable(
-                  FinchAPI::HRIS::PayStatement::Earning::Attributes::Metadata
-                )
-              )
-            end
-            attr_reader :metadata
-
-            sig do
-              params(
-                metadata:
-                  FinchAPI::HRIS::PayStatement::Earning::Attributes::Metadata::OrHash
-              ).void
-            end
-            attr_writer :metadata
-
-            sig do
-              params(
-                metadata:
-                  FinchAPI::HRIS::PayStatement::Earning::Attributes::Metadata::OrHash
-              ).returns(T.attached_class)
-            end
-            def self.new(metadata: nil)
-            end
-
-            sig do
-              override.returns(
-                {
-                  metadata:
-                    FinchAPI::HRIS::PayStatement::Earning::Attributes::Metadata
-                }
-              )
-            end
-            def to_hash
-            end
-
-            class Metadata < FinchAPI::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    FinchAPI::HRIS::PayStatement::Earning::Attributes::Metadata,
-                    FinchAPI::Internal::AnyHash
-                  )
-                end
-
-              # The metadata to be attached to the entity by existing rules. It is a key-value
-              # pairs where the values can be of any type (string, number, boolean, object,
-              # array, etc.).
-              sig { returns(T.nilable(T::Hash[Symbol, T.nilable(T.anything)])) }
-              attr_reader :metadata
-
-              sig do
-                params(metadata: T::Hash[Symbol, T.nilable(T.anything)]).void
-              end
-              attr_writer :metadata
-
-              sig do
-                params(
-                  metadata: T::Hash[Symbol, T.nilable(T.anything)]
-                ).returns(T.attached_class)
-              end
-              def self.new(
-                # The metadata to be attached to the entity by existing rules. It is a key-value
-                # pairs where the values can be of any type (string, number, boolean, object,
-                # array, etc.).
-                metadata: nil
-              )
-              end
-
-              sig do
-                override.returns(
-                  { metadata: T::Hash[Symbol, T.nilable(T.anything)] }
-                )
-              end
-              def to_hash
-              end
-            end
-          end
-
           # The type of earning.
           module Type
             extend FinchAPI::Internal::Type::Enum
@@ -462,6 +372,88 @@ module FinchAPI
             def self.values
             end
           end
+
+          class Attributes < FinchAPI::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  FinchAPI::HRIS::PayStatement::Earning::Attributes,
+                  FinchAPI::Internal::AnyHash
+                )
+              end
+
+            sig do
+              returns(
+                FinchAPI::HRIS::PayStatement::Earning::Attributes::Metadata
+              )
+            end
+            attr_reader :metadata
+
+            sig do
+              params(
+                metadata:
+                  FinchAPI::HRIS::PayStatement::Earning::Attributes::Metadata::OrHash
+              ).void
+            end
+            attr_writer :metadata
+
+            sig do
+              params(
+                metadata:
+                  FinchAPI::HRIS::PayStatement::Earning::Attributes::Metadata::OrHash
+              ).returns(T.attached_class)
+            end
+            def self.new(metadata:)
+            end
+
+            sig do
+              override.returns(
+                {
+                  metadata:
+                    FinchAPI::HRIS::PayStatement::Earning::Attributes::Metadata
+                }
+              )
+            end
+            def to_hash
+            end
+
+            class Metadata < FinchAPI::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    FinchAPI::HRIS::PayStatement::Earning::Attributes::Metadata,
+                    FinchAPI::Internal::AnyHash
+                  )
+                end
+
+              # The metadata to be attached to the entity by existing rules. It is a key-value
+              # pairs where the values can be of any type (string, number, boolean, object,
+              # array, etc.).
+              sig { returns(T::Hash[Symbol, T.nilable(T.anything)]) }
+              attr_accessor :metadata
+
+              sig do
+                params(
+                  metadata: T::Hash[Symbol, T.nilable(T.anything)]
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                # The metadata to be attached to the entity by existing rules. It is a key-value
+                # pairs where the values can be of any type (string, number, boolean, object,
+                # array, etc.).
+                metadata:
+              )
+              end
+
+              sig do
+                override.returns(
+                  { metadata: T::Hash[Symbol, T.nilable(T.anything)] }
+                )
+              end
+              def to_hash
+              end
+            end
+          end
         end
 
         class EmployeeDeduction < FinchAPI::Internal::Type::BaseModel
@@ -477,6 +469,22 @@ module FinchAPI
           sig { returns(T.nilable(Integer)) }
           attr_accessor :amount
 
+          # The deduction currency.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :currency
+
+          # The deduction name from the pay statement.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :name
+
+          # Boolean indicating if the deduction is pre-tax.
+          sig { returns(T.nilable(T::Boolean)) }
+          attr_accessor :pre_tax
+
+          # Type of benefit.
+          sig { returns(T.nilable(FinchAPI::HRIS::BenefitType::TaggedSymbol)) }
+          attr_accessor :type
+
           sig do
             returns(
               T.nilable(
@@ -496,47 +504,31 @@ module FinchAPI
           end
           attr_writer :attributes
 
-          # The deduction currency.
-          sig { returns(T.nilable(String)) }
-          attr_accessor :currency
-
-          # The deduction name from the pay statement.
-          sig { returns(T.nilable(String)) }
-          attr_accessor :name
-
-          # Boolean indicating if the deduction is pre-tax.
-          sig { returns(T.nilable(T::Boolean)) }
-          attr_accessor :pre_tax
-
-          # Type of benefit.
-          sig { returns(T.nilable(FinchAPI::HRIS::BenefitType::TaggedSymbol)) }
-          attr_accessor :type
-
           sig do
             params(
               amount: T.nilable(Integer),
-              attributes:
-                T.nilable(
-                  FinchAPI::HRIS::PayStatement::EmployeeDeduction::Attributes::OrHash
-                ),
               currency: T.nilable(String),
               name: T.nilable(String),
               pre_tax: T.nilable(T::Boolean),
-              type: T.nilable(FinchAPI::HRIS::BenefitType::OrSymbol)
+              type: T.nilable(FinchAPI::HRIS::BenefitType::OrSymbol),
+              attributes:
+                T.nilable(
+                  FinchAPI::HRIS::PayStatement::EmployeeDeduction::Attributes::OrHash
+                )
             ).returns(T.attached_class)
           end
           def self.new(
             # The deduction amount in cents.
-            amount: nil,
-            attributes: nil,
+            amount:,
             # The deduction currency.
-            currency: nil,
+            currency:,
             # The deduction name from the pay statement.
-            name: nil,
+            name:,
             # Boolean indicating if the deduction is pre-tax.
-            pre_tax: nil,
+            pre_tax:,
             # Type of benefit.
-            type: nil
+            type:,
+            attributes: nil
           )
           end
 
@@ -544,14 +536,14 @@ module FinchAPI
             override.returns(
               {
                 amount: T.nilable(Integer),
-                attributes:
-                  T.nilable(
-                    FinchAPI::HRIS::PayStatement::EmployeeDeduction::Attributes
-                  ),
                 currency: T.nilable(String),
                 name: T.nilable(String),
                 pre_tax: T.nilable(T::Boolean),
-                type: T.nilable(FinchAPI::HRIS::BenefitType::TaggedSymbol)
+                type: T.nilable(FinchAPI::HRIS::BenefitType::TaggedSymbol),
+                attributes:
+                  T.nilable(
+                    FinchAPI::HRIS::PayStatement::EmployeeDeduction::Attributes
+                  )
               }
             )
           end
@@ -569,9 +561,7 @@ module FinchAPI
 
             sig do
               returns(
-                T.nilable(
-                  FinchAPI::HRIS::PayStatement::EmployeeDeduction::Attributes::Metadata
-                )
+                FinchAPI::HRIS::PayStatement::EmployeeDeduction::Attributes::Metadata
               )
             end
             attr_reader :metadata
@@ -590,7 +580,7 @@ module FinchAPI
                   FinchAPI::HRIS::PayStatement::EmployeeDeduction::Attributes::Metadata::OrHash
               ).returns(T.attached_class)
             end
-            def self.new(metadata: nil)
+            def self.new(metadata:)
             end
 
             sig do
@@ -616,13 +606,8 @@ module FinchAPI
               # The metadata to be attached to the entity by existing rules. It is a key-value
               # pairs where the values can be of any type (string, number, boolean, object,
               # array, etc.).
-              sig { returns(T.nilable(T::Hash[Symbol, T.nilable(T.anything)])) }
-              attr_reader :metadata
-
-              sig do
-                params(metadata: T::Hash[Symbol, T.nilable(T.anything)]).void
-              end
-              attr_writer :metadata
+              sig { returns(T::Hash[Symbol, T.nilable(T.anything)]) }
+              attr_accessor :metadata
 
               sig do
                 params(
@@ -633,7 +618,7 @@ module FinchAPI
                 # The metadata to be attached to the entity by existing rules. It is a key-value
                 # pairs where the values can be of any type (string, number, boolean, object,
                 # array, etc.).
-                metadata: nil
+                metadata:
               )
               end
 
@@ -657,6 +642,18 @@ module FinchAPI
               )
             end
 
+          # The contribution currency.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :currency
+
+          # The contribution name from the pay statement.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :name
+
+          # Type of benefit.
+          sig { returns(T.nilable(FinchAPI::HRIS::BenefitType::TaggedSymbol)) }
+          attr_accessor :type
+
           # The contribution amount in cents.
           sig { returns(T.nilable(Integer)) }
           attr_accessor :amount
@@ -680,54 +677,42 @@ module FinchAPI
           end
           attr_writer :attributes
 
-          # The contribution currency.
-          sig { returns(T.nilable(String)) }
-          attr_accessor :currency
-
-          # The contribution name from the pay statement.
-          sig { returns(T.nilable(String)) }
-          attr_accessor :name
-
-          # Type of benefit.
-          sig { returns(T.nilable(FinchAPI::HRIS::BenefitType::TaggedSymbol)) }
-          attr_accessor :type
-
           sig do
             params(
+              currency: T.nilable(String),
+              name: T.nilable(String),
+              type: T.nilable(FinchAPI::HRIS::BenefitType::OrSymbol),
               amount: T.nilable(Integer),
               attributes:
                 T.nilable(
                   FinchAPI::HRIS::PayStatement::EmployerContribution::Attributes::OrHash
-                ),
-              currency: T.nilable(String),
-              name: T.nilable(String),
-              type: T.nilable(FinchAPI::HRIS::BenefitType::OrSymbol)
+                )
             ).returns(T.attached_class)
           end
           def self.new(
-            # The contribution amount in cents.
-            amount: nil,
-            attributes: nil,
             # The contribution currency.
-            currency: nil,
+            currency:,
             # The contribution name from the pay statement.
-            name: nil,
+            name:,
             # Type of benefit.
-            type: nil
+            type:,
+            # The contribution amount in cents.
+            amount: nil,
+            attributes: nil
           )
           end
 
           sig do
             override.returns(
               {
+                currency: T.nilable(String),
+                name: T.nilable(String),
+                type: T.nilable(FinchAPI::HRIS::BenefitType::TaggedSymbol),
                 amount: T.nilable(Integer),
                 attributes:
                   T.nilable(
                     FinchAPI::HRIS::PayStatement::EmployerContribution::Attributes
-                  ),
-                currency: T.nilable(String),
-                name: T.nilable(String),
-                type: T.nilable(FinchAPI::HRIS::BenefitType::TaggedSymbol)
+                  )
               }
             )
           end
@@ -745,9 +730,7 @@ module FinchAPI
 
             sig do
               returns(
-                T.nilable(
-                  FinchAPI::HRIS::PayStatement::EmployerContribution::Attributes::Metadata
-                )
+                FinchAPI::HRIS::PayStatement::EmployerContribution::Attributes::Metadata
               )
             end
             attr_reader :metadata
@@ -766,7 +749,7 @@ module FinchAPI
                   FinchAPI::HRIS::PayStatement::EmployerContribution::Attributes::Metadata::OrHash
               ).returns(T.attached_class)
             end
-            def self.new(metadata: nil)
+            def self.new(metadata:)
             end
 
             sig do
@@ -792,13 +775,8 @@ module FinchAPI
               # The metadata to be attached to the entity by existing rules. It is a key-value
               # pairs where the values can be of any type (string, number, boolean, object,
               # array, etc.).
-              sig { returns(T.nilable(T::Hash[Symbol, T.nilable(T.anything)])) }
-              attr_reader :metadata
-
-              sig do
-                params(metadata: T::Hash[Symbol, T.nilable(T.anything)]).void
-              end
-              attr_writer :metadata
+              sig { returns(T::Hash[Symbol, T.nilable(T.anything)]) }
+              attr_accessor :metadata
 
               sig do
                 params(
@@ -809,7 +787,7 @@ module FinchAPI
                 # The metadata to be attached to the entity by existing rules. It is a key-value
                 # pairs where the values can be of any type (string, number, boolean, object,
                 # array, etc.).
-                metadata: nil
+                metadata:
               )
               end
 
@@ -870,23 +848,6 @@ module FinchAPI
               )
             end
 
-          # The tax amount in cents.
-          sig { returns(T.nilable(Integer)) }
-          attr_accessor :amount
-
-          sig do
-            returns(T.nilable(FinchAPI::HRIS::PayStatement::Tax::Attributes))
-          end
-          attr_reader :attributes
-
-          sig do
-            params(
-              attributes:
-                T.nilable(FinchAPI::HRIS::PayStatement::Tax::Attributes::OrHash)
-            ).void
-          end
-          attr_writer :attributes
-
           # The currency code.
           sig { returns(T.nilable(String)) }
           attr_accessor :currency
@@ -907,53 +868,109 @@ module FinchAPI
           end
           attr_accessor :type
 
+          # The tax amount in cents.
+          sig { returns(T.nilable(Integer)) }
+          attr_accessor :amount
+
+          sig do
+            returns(T.nilable(FinchAPI::HRIS::PayStatement::Tax::Attributes))
+          end
+          attr_reader :attributes
+
           sig do
             params(
-              amount: T.nilable(Integer),
               attributes:
-                T.nilable(
-                  FinchAPI::HRIS::PayStatement::Tax::Attributes::OrHash
-                ),
+                T.nilable(FinchAPI::HRIS::PayStatement::Tax::Attributes::OrHash)
+            ).void
+          end
+          attr_writer :attributes
+
+          sig do
+            params(
               currency: T.nilable(String),
               employer: T.nilable(T::Boolean),
               name: T.nilable(String),
-              type: T.nilable(FinchAPI::HRIS::PayStatement::Tax::Type::OrSymbol)
+              type:
+                T.nilable(FinchAPI::HRIS::PayStatement::Tax::Type::OrSymbol),
+              amount: T.nilable(Integer),
+              attributes:
+                T.nilable(FinchAPI::HRIS::PayStatement::Tax::Attributes::OrHash)
             ).returns(T.attached_class)
           end
           def self.new(
-            # The tax amount in cents.
-            amount: nil,
-            attributes: nil,
             # The currency code.
-            currency: nil,
+            currency:,
             # `true` if the amount is paid by the employers.
-            employer: nil,
+            employer:,
             # The exact name of tax from the pay statement.
-            name: nil,
+            name:,
             # The type of taxes.
-            type: nil
+            type:,
+            # The tax amount in cents.
+            amount: nil,
+            attributes: nil
           )
           end
 
           sig do
             override.returns(
               {
-                amount: T.nilable(Integer),
-                attributes:
-                  T.nilable(FinchAPI::HRIS::PayStatement::Tax::Attributes),
                 currency: T.nilable(String),
                 employer: T.nilable(T::Boolean),
                 name: T.nilable(String),
                 type:
                   T.nilable(
                     FinchAPI::HRIS::PayStatement::Tax::Type::TaggedSymbol
-                  )
+                  ),
+                amount: T.nilable(Integer),
+                attributes:
+                  T.nilable(FinchAPI::HRIS::PayStatement::Tax::Attributes)
               }
             )
           end
           def to_hash
           end
 
+          # The type of taxes.
+          module Type
+            extend FinchAPI::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(Symbol, FinchAPI::HRIS::PayStatement::Tax::Type)
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            STATE =
+              T.let(
+                :state,
+                FinchAPI::HRIS::PayStatement::Tax::Type::TaggedSymbol
+              )
+            FEDERAL =
+              T.let(
+                :federal,
+                FinchAPI::HRIS::PayStatement::Tax::Type::TaggedSymbol
+              )
+            LOCAL =
+              T.let(
+                :local,
+                FinchAPI::HRIS::PayStatement::Tax::Type::TaggedSymbol
+              )
+            FICA =
+              T.let(
+                :fica,
+                FinchAPI::HRIS::PayStatement::Tax::Type::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[FinchAPI::HRIS::PayStatement::Tax::Type::TaggedSymbol]
+              )
+            end
+            def self.values
+            end
+          end
+
           class Attributes < FinchAPI::Internal::Type::BaseModel
             OrHash =
               T.type_alias do
@@ -964,11 +981,7 @@ module FinchAPI
               end
 
             sig do
-              returns(
-                T.nilable(
-                  FinchAPI::HRIS::PayStatement::Tax::Attributes::Metadata
-                )
-              )
+              returns(FinchAPI::HRIS::PayStatement::Tax::Attributes::Metadata)
             end
             attr_reader :metadata
 
@@ -986,7 +999,7 @@ module FinchAPI
                   FinchAPI::HRIS::PayStatement::Tax::Attributes::Metadata::OrHash
               ).returns(T.attached_class)
             end
-            def self.new(metadata: nil)
+            def self.new(metadata:)
             end
 
             sig do
@@ -1012,13 +1025,8 @@ module FinchAPI
               # The metadata to be attached to the entity by existing rules. It is a key-value
               # pairs where the values can be of any type (string, number, boolean, object,
               # array, etc.).
-              sig { returns(T.nilable(T::Hash[Symbol, T.nilable(T.anything)])) }
-              attr_reader :metadata
-
-              sig do
-                params(metadata: T::Hash[Symbol, T.nilable(T.anything)]).void
-              end
-              attr_writer :metadata
+              sig { returns(T::Hash[Symbol, T.nilable(T.anything)]) }
+              attr_accessor :metadata
 
               sig do
                 params(
@@ -1029,7 +1037,7 @@ module FinchAPI
                 # The metadata to be attached to the entity by existing rules. It is a key-value
                 # pairs where the values can be of any type (string, number, boolean, object,
                 # array, etc.).
-                metadata: nil
+                metadata:
               )
               end
 
@@ -1042,46 +1050,6 @@ module FinchAPI
               end
             end
           end
-
-          # The type of taxes.
-          module Type
-            extend FinchAPI::Internal::Type::Enum
-
-            TaggedSymbol =
-              T.type_alias do
-                T.all(Symbol, FinchAPI::HRIS::PayStatement::Tax::Type)
-              end
-            OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-            STATE =
-              T.let(
-                :state,
-                FinchAPI::HRIS::PayStatement::Tax::Type::TaggedSymbol
-              )
-            FEDERAL =
-              T.let(
-                :federal,
-                FinchAPI::HRIS::PayStatement::Tax::Type::TaggedSymbol
-              )
-            LOCAL =
-              T.let(
-                :local,
-                FinchAPI::HRIS::PayStatement::Tax::Type::TaggedSymbol
-              )
-            FICA =
-              T.let(
-                :fica,
-                FinchAPI::HRIS::PayStatement::Tax::Type::TaggedSymbol
-              )
-
-            sig do
-              override.returns(
-                T::Array[FinchAPI::HRIS::PayStatement::Tax::Type::TaggedSymbol]
-              )
-            end
-            def self.values
-            end
-          end
         end
 
         # The type of the payment associated with the pay statement.
@@ -1092,11 +1060,6 @@ module FinchAPI
             T.type_alias { T.all(Symbol, FinchAPI::HRIS::PayStatement::Type) }
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-          REGULAR_PAYROLL =
-            T.let(
-              :regular_payroll,
-              FinchAPI::HRIS::PayStatement::Type::TaggedSymbol
-            )
           OFF_CYCLE_PAYROLL =
             T.let(
               :off_cycle_payroll,
@@ -1107,6 +1070,11 @@ module FinchAPI
               :one_time_payment,
               FinchAPI::HRIS::PayStatement::Type::TaggedSymbol
             )
+          REGULAR_PAYROLL =
+            T.let(
+              :regular_payroll,
+              FinchAPI::HRIS::PayStatement::Type::TaggedSymbol
+            )
 
           sig do
             override.returns(