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

data/rbi/lib/finch-api/models/sandbox/payment_create_params.rbi

@@ -8,42 +8,38 @@ module FinchAPI
         include FinchAPI::RequestParameters
 
         sig { returns(T.nilable(String)) }
-        def end_date
-        end
+        attr_reader :end_date
 
-        sig { params(_: String).returns(String) }
-        def end_date=(_)
-        end
+        sig { params(end_date: String).void }
+        attr_writer :end_date
 
         sig { returns(T.nilable(T::Array[FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement])) }
-        def pay_statements
-        end
+        attr_reader :pay_statements
 
         sig do
-          params(_: T::Array[FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement])
-            .returns(T::Array[FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement])
-        end
-        def pay_statements=(_)
+          params(
+            pay_statements: T::Array[T.any(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement, FinchAPI::Util::AnyHash)]
+          )
+            .void
         end
+        attr_writer :pay_statements
 
         sig { returns(T.nilable(String)) }
-        def start_date
-        end
+        attr_reader :start_date
 
-        sig { params(_: String).returns(String) }
-        def start_date=(_)
-        end
+        sig { params(start_date: String).void }
+        attr_writer :start_date
 
         sig do
           params(
             end_date: String,
-            pay_statements: T::Array[FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement],
+            pay_statements: T::Array[T.any(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement, FinchAPI::Util::AnyHash)],
             start_date: 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(end_date: nil, pay_statements: nil, start_date: nil, request_options: {})
+        def self.new(end_date: nil, pay_statements: nil, start_date: nil, request_options: {})
         end
 
         sig do
@@ -61,25 +57,15 @@ module FinchAPI
         end
 
         class PayStatement < FinchAPI::BaseModel
+          # The array of earnings objects associated with this pay statement
           sig do
             returns(
               T.nilable(T::Array[T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning)])
             )
           end
-          def earnings
-          end
-
-          sig do
-            params(
-              _: T.nilable(T::Array[T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning)])
-            )
-              .returns(
-                T.nilable(T::Array[T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning)])
-              )
-          end
-          def earnings=(_)
-          end
+          attr_accessor :earnings
 
+          # The array of deductions objects associated with this pay statement.
           sig do
             returns(
               T.nilable(
@@ -87,23 +73,7 @@ module FinchAPI
               )
             )
           end
-          def employee_deductions
-          end
-
-          sig do
-            params(
-              _: T.nilable(
-                T::Array[T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployeeDeduction)]
-              )
-            )
-              .returns(
-                T.nilable(
-                  T::Array[T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployeeDeduction)]
-                )
-              )
-          end
-          def employee_deductions=(_)
-          end
+          attr_accessor :employee_deductions
 
           sig do
             returns(
@@ -112,105 +82,89 @@ module FinchAPI
               )
             )
           end
-          def employer_contributions
-          end
-
-          sig do
-            params(
-              _: T.nilable(
-                T::Array[T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployerContribution)]
-              )
-            )
-              .returns(
-                T.nilable(
-                  T::Array[T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployerContribution)]
-                )
-              )
-          end
-          def employer_contributions=(_)
-          end
+          attr_accessor :employer_contributions
 
           sig { returns(T.nilable(FinchAPI::Models::Money)) }
-          def gross_pay
-          end
+          attr_reader :gross_pay
 
-          sig { params(_: T.nilable(FinchAPI::Models::Money)).returns(T.nilable(FinchAPI::Models::Money)) }
-          def gross_pay=(_)
-          end
+          sig { params(gross_pay: T.nilable(T.any(FinchAPI::Models::Money, FinchAPI::Util::AnyHash))).void }
+          attr_writer :gross_pay
 
+          # A stable Finch `id` (UUID v4) for an individual in the company
           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 { returns(T.nilable(FinchAPI::Models::Money)) }
-          def net_pay
-          end
-
-          sig { params(_: T.nilable(FinchAPI::Models::Money)).returns(T.nilable(FinchAPI::Models::Money)) }
-          def net_pay=(_)
-          end
+          attr_reader :net_pay
 
-          sig { returns(T.nilable(Symbol)) }
-          def payment_method
-          end
+          sig { params(net_pay: T.nilable(T.any(FinchAPI::Models::Money, FinchAPI::Util::AnyHash))).void }
+          attr_writer :net_pay
 
-          sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-          def payment_method=(_)
-          end
+          # The payment method.
+          sig { returns(T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::PaymentMethod::OrSymbol)) }
+          attr_accessor :payment_method
 
+          # The array of taxes objects associated with this pay statement.
           sig { returns(T.nilable(T::Array[T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax)])) }
-          def taxes
-          end
-
-          sig do
-            params(
-              _: T.nilable(T::Array[T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax)])
-            )
-              .returns(T.nilable(T::Array[T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax)]))
-          end
-          def taxes=(_)
-          end
+          attr_accessor :taxes
 
+          # The number of hours worked for this pay period
           sig { returns(T.nilable(Float)) }
-          def total_hours
-          end
+          attr_accessor :total_hours
 
-          sig { params(_: T.nilable(Float)).returns(T.nilable(Float)) }
-          def total_hours=(_)
-          end
-
-          sig { returns(T.nilable(Symbol)) }
-          def type
-          end
-
-          sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-          def type=(_)
-          end
+          # The type of the payment associated with the pay statement.
+          sig { returns(T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Type::OrSymbol)) }
+          attr_accessor :type
 
           sig do
             params(
-              earnings: T.nilable(T::Array[T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning)]),
+              earnings: T.nilable(
+                T::Array[
+                T.nilable(
+                  T.any(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning, FinchAPI::Util::AnyHash)
+                )
+                ]
+              ),
               employee_deductions: T.nilable(
-                T::Array[T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployeeDeduction)]
+                T::Array[
+                T.nilable(
+                  T.any(
+                    FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployeeDeduction,
+                    FinchAPI::Util::AnyHash
+                  )
+                )
+                ]
               ),
               employer_contributions: T.nilable(
-                T::Array[T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployerContribution)]
+                T::Array[
+                T.nilable(
+                  T.any(
+                    FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployerContribution,
+                    FinchAPI::Util::AnyHash
+                  )
+                )
+                ]
               ),
-              gross_pay: T.nilable(FinchAPI::Models::Money),
+              gross_pay: T.nilable(T.any(FinchAPI::Models::Money, FinchAPI::Util::AnyHash)),
               individual_id: String,
-              net_pay: T.nilable(FinchAPI::Models::Money),
-              payment_method: T.nilable(Symbol),
-              taxes: T.nilable(T::Array[T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax)]),
+              net_pay: T.nilable(T.any(FinchAPI::Models::Money, FinchAPI::Util::AnyHash)),
+              payment_method: T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::PaymentMethod::OrSymbol),
+              taxes: T.nilable(
+                T::Array[
+                T.nilable(
+                  T.any(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax, FinchAPI::Util::AnyHash)
+                )
+                ]
+              ),
               total_hours: T.nilable(Float),
-              type: T.nilable(Symbol)
+              type: T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Type::OrSymbol)
             )
-              .void
+              .returns(T.attached_class)
           end
-          def initialize(
+          def self.new(
             earnings: nil,
             employee_deductions: nil,
             employer_contributions: nil,
@@ -238,10 +192,10 @@ module FinchAPI
                   gross_pay: T.nilable(FinchAPI::Models::Money),
                   individual_id: String,
                   net_pay: T.nilable(FinchAPI::Models::Money),
-                  payment_method: T.nilable(Symbol),
+                  payment_method: T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::PaymentMethod::OrSymbol),
                   taxes: T.nilable(T::Array[T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax)]),
                   total_hours: T.nilable(Float),
-                  type: T.nilable(Symbol)
+                  type: T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Type::OrSymbol)
                 }
               )
           end
@@ -249,69 +203,60 @@ module FinchAPI
           end
 
           class Earning < FinchAPI::BaseModel
+            # The earnings amount in cents.
             sig { returns(T.nilable(Integer)) }
-            def amount
-            end
-
-            sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-            def amount=(_)
-            end
+            attr_accessor :amount
 
             sig { returns(T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Attributes)) }
-            def attributes
-            end
+            attr_reader :attributes
 
             sig do
-              params(_: T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Attributes))
-                .returns(T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Attributes))
-            end
-            def attributes=(_)
+              params(
+                attributes: T.nilable(
+                  T.any(
+                    FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Attributes,
+                    FinchAPI::Util::AnyHash
+                  )
+                )
+              )
+                .void
             end
+            attr_writer :attributes
 
+            # The earnings currency code.
             sig { returns(T.nilable(String)) }
-            def currency
-            end
-
-            sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-            def currency=(_)
-            end
+            attr_accessor :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).
             sig { returns(T.nilable(Float)) }
-            def hours
-            end
-
-            sig { params(_: T.nilable(Float)).returns(T.nilable(Float)) }
-            def hours=(_)
-            end
+            attr_accessor :hours
 
+            # The exact name of the deduction from the pay statement.
             sig { returns(T.nilable(String)) }
-            def name
-            end
-
-            sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-            def name=(_)
-            end
+            attr_accessor :name
 
-            sig { returns(T.nilable(Symbol)) }
-            def type
-            end
-
-            sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-            def type=(_)
-            end
+            # The type of earning.
+            sig { returns(T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Type::OrSymbol)) }
+            attr_accessor :type
 
             sig do
               params(
                 amount: T.nilable(Integer),
-                attributes: T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Attributes),
+                attributes: T.nilable(
+                  T.any(
+                    FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Attributes,
+                    FinchAPI::Util::AnyHash
+                  )
+                ),
                 currency: T.nilable(String),
                 hours: T.nilable(Float),
                 name: T.nilable(String),
-                type: T.nilable(Symbol)
+                type: T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Type::OrSymbol)
               )
-                .void
+                .returns(T.attached_class)
             end
-            def initialize(amount: nil, attributes: nil, currency: nil, hours: nil, name: nil, type: nil)
+            def self.new(amount: nil, attributes: nil, currency: nil, hours: nil, name: nil, type: nil)
             end
 
             sig do
@@ -323,7 +268,7 @@ module FinchAPI
                     currency: T.nilable(String),
                     hours: T.nilable(Float),
                     name: T.nilable(String),
-                    type: T.nilable(Symbol)
+                    type: T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Type::OrSymbol)
                   }
                 )
             end
@@ -336,23 +281,29 @@ module FinchAPI
                   T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Attributes::Metadata)
                 )
               end
-              def metadata
-              end
+              attr_reader :metadata
 
               sig do
-                params(_: FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Attributes::Metadata)
-                  .returns(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Attributes::Metadata)
-              end
-              def metadata=(_)
+                params(
+                  metadata: T.any(
+                    FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Attributes::Metadata,
+                    FinchAPI::Util::AnyHash
+                  )
+                )
+                  .void
               end
+              attr_writer :metadata
 
               sig do
                 params(
-                  metadata: FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Attributes::Metadata
+                  metadata: T.any(
+                    FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Attributes::Metadata,
+                    FinchAPI::Util::AnyHash
+                  )
                 )
-                  .void
+                  .returns(T.attached_class)
               end
-              def initialize(metadata: nil)
+              def self.new(metadata: nil)
               end
 
               sig do
@@ -365,16 +316,17 @@ module FinchAPI
               end
 
               class Metadata < FinchAPI::BaseModel
+                # 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.anything])) }
-                def metadata
-                end
-
-                sig { params(_: T::Hash[Symbol, T.anything]).returns(T::Hash[Symbol, T.anything]) }
-                def metadata=(_)
-                end
+                attr_reader :metadata
 
                 sig { params(metadata: T::Hash[Symbol, T.anything]).void }
-                def initialize(metadata: nil)
+                attr_writer :metadata
+
+                sig { params(metadata: T::Hash[Symbol, T.anything]).returns(T.attached_class) }
+                def self.new(metadata: nil)
                 end
 
                 sig { override.returns({metadata: T::Hash[Symbol, T.anything]}) }
@@ -383,101 +335,126 @@ module FinchAPI
               end
             end
 
-            class Type < FinchAPI::Enum
-              abstract!
+            # The type of earning.
+            module Type
+              extend FinchAPI::Enum
 
-              SALARY = T.let(:salary, T.nilable(Symbol))
-              WAGE = T.let(:wage, T.nilable(Symbol))
-              REIMBURSEMENT = T.let(:reimbursement, T.nilable(Symbol))
-              OVERTIME = T.let(:overtime, T.nilable(Symbol))
-              SEVERANCE = T.let(:severance, T.nilable(Symbol))
-              DOUBLE_OVERTIME = T.let(:double_overtime, T.nilable(Symbol))
-              PTO = T.let(:pto, T.nilable(Symbol))
-              SICK = T.let(:sick, T.nilable(Symbol))
-              BONUS = T.let(:bonus, T.nilable(Symbol))
-              COMMISSION = T.let(:commission, T.nilable(Symbol))
-              TIPS = T.let(:tips, T.nilable(Symbol))
-              NUMBER_1099 = T.let(:"1099", T.nilable(Symbol))
-              OTHER = T.let(:other, T.nilable(Symbol))
+              TaggedSymbol =
+                T.type_alias { T.all(Symbol, FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Type) }
+              OrSymbol =
+                T.type_alias { T.any(Symbol, FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Type::TaggedSymbol) }
 
-              sig { override.returns(T::Array[Symbol]) }
+              SALARY =
+                T.let(:salary, FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Type::TaggedSymbol)
+              WAGE =
+                T.let(:wage, FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Type::TaggedSymbol)
+              REIMBURSEMENT =
+                T.let(
+                  :reimbursement,
+                  FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Type::TaggedSymbol
+                )
+              OVERTIME =
+                T.let(
+                  :overtime,
+                  FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Type::TaggedSymbol
+                )
+              SEVERANCE =
+                T.let(
+                  :severance,
+                  FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Type::TaggedSymbol
+                )
+              DOUBLE_OVERTIME =
+                T.let(
+                  :double_overtime,
+                  FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Type::TaggedSymbol
+                )
+              PTO =
+                T.let(:pto, FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Type::TaggedSymbol)
+              SICK =
+                T.let(:sick, FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Type::TaggedSymbol)
+              BONUS =
+                T.let(:bonus, FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Type::TaggedSymbol)
+              COMMISSION =
+                T.let(
+                  :commission,
+                  FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Type::TaggedSymbol
+                )
+              TIPS =
+                T.let(:tips, FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Type::TaggedSymbol)
+              NUMBER_1099 =
+                T.let(:"1099", FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Type::TaggedSymbol)
+              OTHER =
+                T.let(:other, FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Type::TaggedSymbol)
+
+              sig do
+                override
+                  .returns(
+                    T::Array[FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Earning::Type::TaggedSymbol]
+                  )
+              end
               def self.values
               end
             end
           end
 
           class EmployeeDeduction < FinchAPI::BaseModel
+            # The deduction amount in cents.
             sig { returns(T.nilable(Integer)) }
-            def amount
-            end
-
-            sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-            def amount=(_)
-            end
+            attr_accessor :amount
 
             sig do
               returns(
                 T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployeeDeduction::Attributes)
               )
             end
-            def attributes
-            end
+            attr_reader :attributes
 
             sig do
               params(
-                _: T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployeeDeduction::Attributes)
-              )
-                .returns(
-                  T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployeeDeduction::Attributes)
+                attributes: T.nilable(
+                  T.any(
+                    FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployeeDeduction::Attributes,
+                    FinchAPI::Util::AnyHash
+                  )
                 )
+              )
+                .void
             end
-            def attributes=(_)
-            end
+            attr_writer :attributes
 
+            # The deduction currency.
             sig { returns(T.nilable(String)) }
-            def currency
-            end
-
-            sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-            def currency=(_)
-            end
+            attr_accessor :currency
 
+            # The deduction name from the pay statement.
             sig { returns(T.nilable(String)) }
-            def name
-            end
-
-            sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-            def name=(_)
-            end
+            attr_accessor :name
 
+            # Boolean indicating if the deduction is pre-tax.
             sig { returns(T.nilable(T::Boolean)) }
-            def pre_tax
-            end
-
-            sig { params(_: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
-            def pre_tax=(_)
-            end
+            attr_accessor :pre_tax
 
-            sig { returns(T.nilable(Symbol)) }
-            def type
-            end
-
-            sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-            def type=(_)
-            end
+            # Type of benefit.
+            sig { returns(T.nilable(FinchAPI::Models::HRIS::BenefitType::OrSymbol)) }
+            attr_accessor :type
 
             sig do
               params(
                 amount: T.nilable(Integer),
-                attributes: T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployeeDeduction::Attributes),
+                attributes: T.nilable(
+                  T.any(
+                    FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployeeDeduction::Attributes,
+                    FinchAPI::Util::AnyHash
+                  )
+                ),
                 currency: T.nilable(String),
                 name: T.nilable(String),
                 pre_tax: T.nilable(T::Boolean),
-                type: T.nilable(Symbol)
+                type: T.nilable(FinchAPI::Models::HRIS::BenefitType::OrSymbol)
               )
-                .void
+                .returns(T.attached_class)
             end
-            def initialize(amount: nil, attributes: nil, currency: nil, name: nil, pre_tax: nil, type: nil)
+            def self.new(amount: nil, attributes: nil, currency: nil, name: nil, pre_tax: nil, type: nil)
             end
 
             sig do
@@ -489,7 +466,7 @@ module FinchAPI
                     currency: T.nilable(String),
                     name: T.nilable(String),
                     pre_tax: T.nilable(T::Boolean),
-                    type: T.nilable(Symbol)
+                    type: T.nilable(FinchAPI::Models::HRIS::BenefitType::OrSymbol)
                   }
                 )
             end
@@ -504,27 +481,29 @@ module FinchAPI
                   )
                 )
               end
-              def metadata
-              end
+              attr_reader :metadata
 
               sig do
                 params(
-                  _: FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployeeDeduction::Attributes::Metadata
-                )
-                  .returns(
-                    FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployeeDeduction::Attributes::Metadata
+                  metadata: T.any(
+                    FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployeeDeduction::Attributes::Metadata,
+                    FinchAPI::Util::AnyHash
                   )
+                )
+                  .void
               end
-              def metadata=(_)
-              end
+              attr_writer :metadata
 
               sig do
                 params(
-                  metadata: FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployeeDeduction::Attributes::Metadata
+                  metadata: T.any(
+                    FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployeeDeduction::Attributes::Metadata,
+                    FinchAPI::Util::AnyHash
+                  )
                 )
-                  .void
+                  .returns(T.attached_class)
               end
-              def initialize(metadata: nil)
+              def self.new(metadata: nil)
               end
 
               sig do
@@ -539,16 +518,17 @@ module FinchAPI
               end
 
               class Metadata < FinchAPI::BaseModel
+                # 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.anything])) }
-                def metadata
-                end
-
-                sig { params(_: T::Hash[Symbol, T.anything]).returns(T::Hash[Symbol, T.anything]) }
-                def metadata=(_)
-                end
+                attr_reader :metadata
 
                 sig { params(metadata: T::Hash[Symbol, T.anything]).void }
-                def initialize(metadata: nil)
+                attr_writer :metadata
+
+                sig { params(metadata: T::Hash[Symbol, T.anything]).returns(T.attached_class) }
+                def self.new(metadata: nil)
                 end
 
                 sig { override.returns({metadata: T::Hash[Symbol, T.anything]}) }
@@ -559,68 +539,58 @@ module FinchAPI
           end
 
           class EmployerContribution < FinchAPI::BaseModel
+            # The contribution amount in cents.
             sig { returns(T.nilable(Integer)) }
-            def amount
-            end
-
-            sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-            def amount=(_)
-            end
+            attr_accessor :amount
 
             sig do
               returns(
                 T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployerContribution::Attributes)
               )
             end
-            def attributes
-            end
+            attr_reader :attributes
 
             sig do
               params(
-                _: T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployerContribution::Attributes)
-              )
-                .returns(
-                  T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployerContribution::Attributes)
+                attributes: T.nilable(
+                  T.any(
+                    FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployerContribution::Attributes,
+                    FinchAPI::Util::AnyHash
+                  )
                 )
+              )
+                .void
             end
-            def attributes=(_)
-            end
+            attr_writer :attributes
 
+            # The contribution currency.
             sig { returns(T.nilable(String)) }
-            def currency
-            end
-
-            sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-            def currency=(_)
-            end
+            attr_accessor :currency
 
+            # The contribution name from the pay statement.
             sig { returns(T.nilable(String)) }
-            def name
-            end
+            attr_accessor :name
 
-            sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-            def name=(_)
-            end
-
-            sig { returns(T.nilable(Symbol)) }
-            def type
-            end
-
-            sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-            def type=(_)
-            end
+            # Type of benefit.
+            sig { returns(T.nilable(FinchAPI::Models::HRIS::BenefitType::OrSymbol)) }
+            attr_accessor :type
 
             sig do
               params(
                 amount: T.nilable(Integer),
-                attributes: T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployerContribution::Attributes),
+                attributes: T.nilable(
+                  T.any(
+                    FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployerContribution::Attributes,
+                    FinchAPI::Util::AnyHash
+                  )
+                ),
                 currency: T.nilable(String),
                 name: T.nilable(String),
-                type: T.nilable(Symbol)
+                type: T.nilable(FinchAPI::Models::HRIS::BenefitType::OrSymbol)
               )
-                .void
+                .returns(T.attached_class)
             end
-            def initialize(amount: nil, attributes: nil, currency: nil, name: nil, type: nil)
+            def self.new(amount: nil, attributes: nil, currency: nil, name: nil, type: nil)
             end
 
             sig do
@@ -631,7 +601,7 @@ module FinchAPI
                     attributes: T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployerContribution::Attributes),
                     currency: T.nilable(String),
                     name: T.nilable(String),
-                    type: T.nilable(Symbol)
+                    type: T.nilable(FinchAPI::Models::HRIS::BenefitType::OrSymbol)
                   }
                 )
             end
@@ -646,27 +616,29 @@ module FinchAPI
                   )
                 )
               end
-              def metadata
-              end
+              attr_reader :metadata
 
               sig do
                 params(
-                  _: FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployerContribution::Attributes::Metadata
-                )
-                  .returns(
-                    FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployerContribution::Attributes::Metadata
+                  metadata: T.any(
+                    FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployerContribution::Attributes::Metadata,
+                    FinchAPI::Util::AnyHash
                   )
+                )
+                  .void
               end
-              def metadata=(_)
-              end
+              attr_writer :metadata
 
               sig do
                 params(
-                  metadata: FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployerContribution::Attributes::Metadata
+                  metadata: T.any(
+                    FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::EmployerContribution::Attributes::Metadata,
+                    FinchAPI::Util::AnyHash
+                  )
                 )
-                  .void
+                  .returns(T.attached_class)
               end
-              def initialize(metadata: nil)
+              def self.new(metadata: nil)
               end
 
               sig do
@@ -681,16 +653,17 @@ module FinchAPI
               end
 
               class Metadata < FinchAPI::BaseModel
+                # 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.anything])) }
-                def metadata
-                end
-
-                sig { params(_: T::Hash[Symbol, T.anything]).returns(T::Hash[Symbol, T.anything]) }
-                def metadata=(_)
-                end
+                attr_reader :metadata
 
                 sig { params(metadata: T::Hash[Symbol, T.anything]).void }
-                def initialize(metadata: nil)
+                attr_writer :metadata
+
+                sig { params(metadata: T::Hash[Symbol, T.anything]).returns(T.attached_class) }
+                def self.new(metadata: nil)
                 end
 
                 sig { override.returns({metadata: T::Hash[Symbol, T.anything]}) }
@@ -700,81 +673,87 @@ module FinchAPI
             end
           end
 
-          class PaymentMethod < FinchAPI::Enum
-            abstract!
+          # The payment method.
+          module PaymentMethod
+            extend FinchAPI::Enum
+
+            TaggedSymbol =
+              T.type_alias { T.all(Symbol, FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::PaymentMethod) }
+            OrSymbol =
+              T.type_alias { T.any(Symbol, FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::PaymentMethod::TaggedSymbol) }
 
-            CHECK = T.let(:check, T.nilable(Symbol))
-            DIRECT_DEPOSIT = T.let(:direct_deposit, T.nilable(Symbol))
+            CHECK =
+              T.let(:check, FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::PaymentMethod::TaggedSymbol)
+            DIRECT_DEPOSIT =
+              T.let(
+                :direct_deposit,
+                FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::PaymentMethod::TaggedSymbol
+              )
 
-            sig { override.returns(T::Array[Symbol]) }
+            sig do
+              override
+                .returns(
+                  T::Array[FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::PaymentMethod::TaggedSymbol]
+                )
+            end
             def self.values
             end
           end
 
           class Tax < FinchAPI::BaseModel
+            # The tax amount in cents.
             sig { returns(T.nilable(Integer)) }
-            def amount
-            end
-
-            sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-            def amount=(_)
-            end
+            attr_accessor :amount
 
             sig { returns(T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax::Attributes)) }
-            def attributes
-            end
+            attr_reader :attributes
 
             sig do
-              params(_: T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax::Attributes))
-                .returns(T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax::Attributes))
-            end
-            def attributes=(_)
+              params(
+                attributes: T.nilable(
+                  T.any(
+                    FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax::Attributes,
+                    FinchAPI::Util::AnyHash
+                  )
+                )
+              )
+                .void
             end
+            attr_writer :attributes
 
+            # The currency code.
             sig { returns(T.nilable(String)) }
-            def currency
-            end
-
-            sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-            def currency=(_)
-            end
+            attr_accessor :currency
 
+            # `true` if the amount is paid by the employers.
             sig { returns(T.nilable(T::Boolean)) }
-            def employer
-            end
-
-            sig { params(_: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
-            def employer=(_)
-            end
+            attr_accessor :employer
 
+            # The exact name of tax from the pay statement.
             sig { returns(T.nilable(String)) }
-            def name
-            end
-
-            sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-            def name=(_)
-            end
-
-            sig { returns(T.nilable(Symbol)) }
-            def type
-            end
+            attr_accessor :name
 
-            sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-            def type=(_)
-            end
+            # The type of taxes.
+            sig { returns(T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax::Type::OrSymbol)) }
+            attr_accessor :type
 
             sig do
               params(
                 amount: T.nilable(Integer),
-                attributes: T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax::Attributes),
+                attributes: T.nilable(
+                  T.any(
+                    FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax::Attributes,
+                    FinchAPI::Util::AnyHash
+                  )
+                ),
                 currency: T.nilable(String),
                 employer: T.nilable(T::Boolean),
                 name: T.nilable(String),
-                type: T.nilable(Symbol)
+                type: T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax::Type::OrSymbol)
               )
-                .void
+                .returns(T.attached_class)
             end
-            def initialize(amount: nil, attributes: nil, currency: nil, employer: nil, name: nil, type: nil)
+            def self.new(amount: nil, attributes: nil, currency: nil, employer: nil, name: nil, type: nil)
             end
 
             sig do
@@ -786,7 +765,7 @@ module FinchAPI
                     currency: T.nilable(String),
                     employer: T.nilable(T::Boolean),
                     name: T.nilable(String),
-                    type: T.nilable(Symbol)
+                    type: T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax::Type::OrSymbol)
                   }
                 )
             end
@@ -799,21 +778,29 @@ module FinchAPI
                   T.nilable(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax::Attributes::Metadata)
                 )
               end
-              def metadata
-              end
+              attr_reader :metadata
 
               sig do
-                params(_: FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax::Attributes::Metadata)
-                  .returns(FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax::Attributes::Metadata)
-              end
-              def metadata=(_)
+                params(
+                  metadata: T.any(
+                    FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax::Attributes::Metadata,
+                    FinchAPI::Util::AnyHash
+                  )
+                )
+                  .void
               end
+              attr_writer :metadata
 
               sig do
-                params(metadata: FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax::Attributes::Metadata)
-                  .void
+                params(
+                  metadata: T.any(
+                    FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax::Attributes::Metadata,
+                    FinchAPI::Util::AnyHash
+                  )
+                )
+                  .returns(T.attached_class)
               end
-              def initialize(metadata: nil)
+              def self.new(metadata: nil)
               end
 
               sig do
@@ -826,16 +813,17 @@ module FinchAPI
               end
 
               class Metadata < FinchAPI::BaseModel
+                # 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.anything])) }
-                def metadata
-                end
-
-                sig { params(_: T::Hash[Symbol, T.anything]).returns(T::Hash[Symbol, T.anything]) }
-                def metadata=(_)
-                end
+                attr_reader :metadata
 
                 sig { params(metadata: T::Hash[Symbol, T.anything]).void }
-                def initialize(metadata: nil)
+                attr_writer :metadata
+
+                sig { params(metadata: T::Hash[Symbol, T.anything]).returns(T.attached_class) }
+                def self.new(metadata: nil)
                 end
 
                 sig { override.returns({metadata: T::Hash[Symbol, T.anything]}) }
@@ -844,28 +832,56 @@ module FinchAPI
               end
             end
 
-            class Type < FinchAPI::Enum
-              abstract!
+            # The type of taxes.
+            module Type
+              extend FinchAPI::Enum
 
-              STATE = T.let(:state, T.nilable(Symbol))
-              FEDERAL = T.let(:federal, T.nilable(Symbol))
-              LOCAL = T.let(:local, T.nilable(Symbol))
-              FICA = T.let(:fica, T.nilable(Symbol))
+              TaggedSymbol =
+                T.type_alias { T.all(Symbol, FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax::Type) }
+              OrSymbol =
+                T.type_alias { T.any(Symbol, FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax::Type::TaggedSymbol) }
 
-              sig { override.returns(T::Array[Symbol]) }
+              STATE =
+                T.let(:state, FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax::Type::TaggedSymbol)
+              FEDERAL =
+                T.let(:federal, FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax::Type::TaggedSymbol)
+              LOCAL =
+                T.let(:local, FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax::Type::TaggedSymbol)
+              FICA =
+                T.let(:fica, FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax::Type::TaggedSymbol)
+
+              sig do
+                override
+                  .returns(T::Array[FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Tax::Type::TaggedSymbol])
+              end
               def self.values
               end
             end
           end
 
-          class Type < FinchAPI::Enum
-            abstract!
+          # The type of the payment associated with the pay statement.
+          module Type
+            extend FinchAPI::Enum
 
-            REGULAR_PAYROLL = T.let(:regular_payroll, T.nilable(Symbol))
-            OFF_CYCLE_PAYROLL = T.let(:off_cycle_payroll, T.nilable(Symbol))
-            ONE_TIME_PAYMENT = T.let(:one_time_payment, T.nilable(Symbol))
+            TaggedSymbol =
+              T.type_alias { T.all(Symbol, FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Type) }
+            OrSymbol =
+              T.type_alias { T.any(Symbol, FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Type::TaggedSymbol) }
+
+            REGULAR_PAYROLL =
+              T.let(:regular_payroll, FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Type::TaggedSymbol)
+            OFF_CYCLE_PAYROLL =
+              T.let(
+                :off_cycle_payroll,
+                FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Type::TaggedSymbol
+              )
+            ONE_TIME_PAYMENT =
+              T.let(:one_time_payment, FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Type::TaggedSymbol)
 
-            sig { override.returns(T::Array[Symbol]) }
+            sig do
+              override
+                .returns(T::Array[FinchAPI::Models::Sandbox::PaymentCreateParams::PayStatement::Type::TaggedSymbol])
+            end
             def self.values
             end
           end