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

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

@@ -5,34 +5,32 @@ module FinchAPI
     module HRIS
       class PayStatementResponse < FinchAPI::BaseModel
         sig { returns(T.nilable(FinchAPI::Models::HRIS::PayStatementResponseBody)) }
-        def body
-        end
+        attr_reader :body
 
-        sig do
-          params(_: FinchAPI::Models::HRIS::PayStatementResponseBody)
-            .returns(FinchAPI::Models::HRIS::PayStatementResponseBody)
-        end
-        def body=(_)
-        end
+        sig { params(body: T.any(FinchAPI::Models::HRIS::PayStatementResponseBody, FinchAPI::Util::AnyHash)).void }
+        attr_writer :body
 
         sig { returns(T.nilable(Integer)) }
-        def code
-        end
+        attr_reader :code
 
-        sig { params(_: Integer).returns(Integer) }
-        def code=(_)
-        end
+        sig { params(code: Integer).void }
+        attr_writer :code
 
         sig { returns(T.nilable(String)) }
-        def payment_id
-        end
+        attr_reader :payment_id
 
-        sig { params(_: String).returns(String) }
-        def payment_id=(_)
-        end
+        sig { params(payment_id: String).void }
+        attr_writer :payment_id
 
-        sig { params(body: FinchAPI::Models::HRIS::PayStatementResponseBody, code: Integer, payment_id: String).void }
-        def initialize(body: nil, code: nil, payment_id: nil)
+        sig do
+          params(
+            body: T.any(FinchAPI::Models::HRIS::PayStatementResponseBody, FinchAPI::Util::AnyHash),
+            code: Integer,
+            payment_id: String
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(body: nil, code: nil, payment_id: nil)
         end
 
         sig do

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

@@ -5,29 +5,26 @@ module FinchAPI
     module HRIS
       class PayStatementResponseBody < FinchAPI::BaseModel
         sig { returns(T.nilable(FinchAPI::Models::Paging)) }
-        def paging
-        end
+        attr_reader :paging
 
-        sig { params(_: FinchAPI::Models::Paging).returns(FinchAPI::Models::Paging) }
-        def paging=(_)
-        end
+        sig { params(paging: T.any(FinchAPI::Models::Paging, FinchAPI::Util::AnyHash)).void }
+        attr_writer :paging
 
+        # The array of pay statements for the current payment.
         sig { returns(T.nilable(T::Array[FinchAPI::Models::HRIS::PayStatement])) }
-        def pay_statements
-        end
+        attr_reader :pay_statements
 
-        sig do
-          params(_: T::Array[FinchAPI::Models::HRIS::PayStatement])
-            .returns(T::Array[FinchAPI::Models::HRIS::PayStatement])
-        end
-        def pay_statements=(_)
-        end
+        sig { params(pay_statements: T::Array[T.any(FinchAPI::Models::HRIS::PayStatement, FinchAPI::Util::AnyHash)]).void }
+        attr_writer :pay_statements
 
         sig do
-          params(paging: FinchAPI::Models::Paging, pay_statements: T::Array[FinchAPI::Models::HRIS::PayStatement])
-            .void
+          params(
+            paging: T.any(FinchAPI::Models::Paging, FinchAPI::Util::AnyHash),
+            pay_statements: T::Array[T.any(FinchAPI::Models::HRIS::PayStatement, FinchAPI::Util::AnyHash)]
+          )
+            .returns(T.attached_class)
         end
-        def initialize(paging: nil, pay_statements: nil)
+        def self.new(paging: nil, pay_statements: nil)
         end
 
         sig do

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

@@ -7,25 +7,18 @@ module FinchAPI
         extend FinchAPI::RequestParameters::Converter
         include FinchAPI::RequestParameters
 
+        # The array of batch requests.
         sig { returns(T::Array[FinchAPI::Models::HRIS::PayStatementRetrieveManyParams::Request]) }
-        def requests
-        end
-
-        sig do
-          params(_: T::Array[FinchAPI::Models::HRIS::PayStatementRetrieveManyParams::Request])
-            .returns(T::Array[FinchAPI::Models::HRIS::PayStatementRetrieveManyParams::Request])
-        end
-        def requests=(_)
-        end
+        attr_accessor :requests
 
         sig do
           params(
-            requests: T::Array[FinchAPI::Models::HRIS::PayStatementRetrieveManyParams::Request],
-            request_options: T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])
+            requests: T::Array[T.any(FinchAPI::Models::HRIS::PayStatementRetrieveManyParams::Request, FinchAPI::Util::AnyHash)],
+            request_options: T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash)
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(requests:, request_options: {})
+        def self.new(requests:, request_options: {})
         end
 
         sig do
@@ -41,32 +34,26 @@ module FinchAPI
         end
 
         class Request < FinchAPI::BaseModel
+          # A stable Finch `id` (UUID v4) for a payment.
           sig { returns(String) }
-          def payment_id
-          end
-
-          sig { params(_: String).returns(String) }
-          def payment_id=(_)
-          end
+          attr_accessor :payment_id
 
+          # Number of pay statements to return (defaults to all).
           sig { returns(T.nilable(Integer)) }
-          def limit
-          end
+          attr_reader :limit
 
-          sig { params(_: Integer).returns(Integer) }
-          def limit=(_)
-          end
+          sig { params(limit: Integer).void }
+          attr_writer :limit
 
+          # Index to start from.
           sig { returns(T.nilable(Integer)) }
-          def offset
-          end
+          attr_reader :offset
 
-          sig { params(_: Integer).returns(Integer) }
-          def offset=(_)
-          end
+          sig { params(offset: Integer).void }
+          attr_writer :offset
 
-          sig { params(payment_id: String, limit: Integer, offset: Integer).void }
-          def initialize(payment_id:, limit: nil, offset: nil)
+          sig { params(payment_id: String, limit: Integer, offset: Integer).returns(T.attached_class) }
+          def self.new(payment_id:, limit: nil, offset: nil)
           end
 
           sig { override.returns({payment_id: String, limit: Integer, offset: Integer}) }

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

@@ -4,123 +4,89 @@ module FinchAPI
   module Models
     module HRIS
       class Payment < FinchAPI::BaseModel
+        # The unique id for the payment.
         sig { returns(T.nilable(String)) }
-        def id
-        end
+        attr_reader :id
 
-        sig { params(_: String).returns(String) }
-        def id=(_)
-        end
+        sig { params(id: String).void }
+        attr_writer :id
 
         sig { returns(T.nilable(FinchAPI::Models::Money)) }
-        def company_debit
-        end
+        attr_reader :company_debit
 
-        sig { params(_: T.nilable(FinchAPI::Models::Money)).returns(T.nilable(FinchAPI::Models::Money)) }
-        def company_debit=(_)
-        end
+        sig { params(company_debit: T.nilable(T.any(FinchAPI::Models::Money, FinchAPI::Util::AnyHash))).void }
+        attr_writer :company_debit
 
         sig { returns(T.nilable(String)) }
-        def debit_date
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def debit_date=(_)
-        end
+        attr_accessor :debit_date
 
         sig { returns(T.nilable(FinchAPI::Models::Money)) }
-        def employee_taxes
-        end
+        attr_reader :employee_taxes
 
-        sig { params(_: T.nilable(FinchAPI::Models::Money)).returns(T.nilable(FinchAPI::Models::Money)) }
-        def employee_taxes=(_)
-        end
+        sig { params(employee_taxes: T.nilable(T.any(FinchAPI::Models::Money, FinchAPI::Util::AnyHash))).void }
+        attr_writer :employee_taxes
 
         sig { returns(T.nilable(FinchAPI::Models::Money)) }
-        def employer_taxes
-        end
+        attr_reader :employer_taxes
 
-        sig { params(_: T.nilable(FinchAPI::Models::Money)).returns(T.nilable(FinchAPI::Models::Money)) }
-        def employer_taxes=(_)
-        end
+        sig { params(employer_taxes: T.nilable(T.any(FinchAPI::Models::Money, FinchAPI::Util::AnyHash))).void }
+        attr_writer :employer_taxes
 
         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
 
+        # Array of every individual on this payment.
         sig { returns(T.nilable(T::Array[String])) }
-        def individual_ids
-        end
-
-        sig { params(_: T.nilable(T::Array[String])).returns(T.nilable(T::Array[String])) }
-        def individual_ids=(_)
-        end
+        attr_accessor :individual_ids
 
         sig { returns(T.nilable(FinchAPI::Models::Money)) }
-        def net_pay
-        end
+        attr_reader :net_pay
 
-        sig { params(_: T.nilable(FinchAPI::Models::Money)).returns(T.nilable(FinchAPI::Models::Money)) }
-        def net_pay=(_)
-        end
+        sig { params(net_pay: T.nilable(T.any(FinchAPI::Models::Money, FinchAPI::Util::AnyHash))).void }
+        attr_writer :net_pay
 
         sig { returns(T.nilable(String)) }
-        def pay_date
-        end
+        attr_accessor :pay_date
 
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def pay_date=(_)
-        end
-
-        sig { returns(T.nilable(T::Array[Symbol])) }
-        def pay_frequencies
-        end
-
-        sig { params(_: T.nilable(T::Array[Symbol])).returns(T.nilable(T::Array[Symbol])) }
-        def pay_frequencies=(_)
-        end
+        # List of pay frequencies associated with this payment.
+        sig { returns(T.nilable(T::Array[FinchAPI::Models::HRIS::Payment::PayFrequency::TaggedSymbol])) }
+        attr_accessor :pay_frequencies
 
+        # Array of the Finch id (uuidv4) of every pay group associated with this payment.
         sig { returns(T.nilable(T::Array[String])) }
-        def pay_group_ids
-        end
-
-        sig { params(_: T.nilable(T::Array[String])).returns(T.nilable(T::Array[String])) }
-        def pay_group_ids=(_)
-        end
+        attr_accessor :pay_group_ids
 
+        # The pay period object.
         sig { returns(T.nilable(FinchAPI::Models::HRIS::Payment::PayPeriod)) }
-        def pay_period
-        end
+        attr_reader :pay_period
 
         sig do
-          params(_: T.nilable(FinchAPI::Models::HRIS::Payment::PayPeriod))
-            .returns(T.nilable(FinchAPI::Models::HRIS::Payment::PayPeriod))
-        end
-        def pay_period=(_)
+          params(pay_period: T.nilable(T.any(FinchAPI::Models::HRIS::Payment::PayPeriod, FinchAPI::Util::AnyHash)))
+            .void
         end
+        attr_writer :pay_period
 
         sig do
           params(
             id: String,
-            company_debit: T.nilable(FinchAPI::Models::Money),
+            company_debit: T.nilable(T.any(FinchAPI::Models::Money, FinchAPI::Util::AnyHash)),
             debit_date: T.nilable(String),
-            employee_taxes: T.nilable(FinchAPI::Models::Money),
-            employer_taxes: T.nilable(FinchAPI::Models::Money),
-            gross_pay: T.nilable(FinchAPI::Models::Money),
+            employee_taxes: T.nilable(T.any(FinchAPI::Models::Money, FinchAPI::Util::AnyHash)),
+            employer_taxes: T.nilable(T.any(FinchAPI::Models::Money, FinchAPI::Util::AnyHash)),
+            gross_pay: T.nilable(T.any(FinchAPI::Models::Money, FinchAPI::Util::AnyHash)),
             individual_ids: T.nilable(T::Array[String]),
-            net_pay: T.nilable(FinchAPI::Models::Money),
+            net_pay: T.nilable(T.any(FinchAPI::Models::Money, FinchAPI::Util::AnyHash)),
             pay_date: T.nilable(String),
-            pay_frequencies: T.nilable(T::Array[Symbol]),
+            pay_frequencies: T.nilable(T::Array[FinchAPI::Models::HRIS::Payment::PayFrequency::OrSymbol]),
             pay_group_ids: T.nilable(T::Array[String]),
-            pay_period: T.nilable(FinchAPI::Models::HRIS::Payment::PayPeriod)
+            pay_period: T.nilable(T.any(FinchAPI::Models::HRIS::Payment::PayPeriod, FinchAPI::Util::AnyHash))
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(
+        def self.new(
           id: nil,
           company_debit: nil,
           debit_date: nil,
@@ -149,7 +115,7 @@ module FinchAPI
                 individual_ids: T.nilable(T::Array[String]),
                 net_pay: T.nilable(FinchAPI::Models::Money),
                 pay_date: T.nilable(String),
-                pay_frequencies: T.nilable(T::Array[Symbol]),
+                pay_frequencies: T.nilable(T::Array[FinchAPI::Models::HRIS::Payment::PayFrequency::TaggedSymbol]),
                 pay_group_ids: T.nilable(T::Array[String]),
                 pay_period: T.nilable(FinchAPI::Models::HRIS::Payment::PayPeriod)
               }
@@ -158,43 +124,37 @@ module FinchAPI
         def to_hash
         end
 
-        class PayFrequency < FinchAPI::Enum
-          abstract!
+        module PayFrequency
+          extend FinchAPI::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::Payment::PayFrequency) }
+          OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::HRIS::Payment::PayFrequency::TaggedSymbol) }
 
-          ANNUALLY = :annually
-          SEMI_ANNUALLY = :semi_annually
-          QUARTERLY = :quarterly
-          MONTHLY = :monthly
-          SEMI_MONTHLY = :semi_monthly
-          BI_WEEKLY = :bi_weekly
-          WEEKLY = :weekly
-          DAILY = :daily
-          OTHER = :other
+          ANNUALLY = T.let(:annually, FinchAPI::Models::HRIS::Payment::PayFrequency::TaggedSymbol)
+          SEMI_ANNUALLY = T.let(:semi_annually, FinchAPI::Models::HRIS::Payment::PayFrequency::TaggedSymbol)
+          QUARTERLY = T.let(:quarterly, FinchAPI::Models::HRIS::Payment::PayFrequency::TaggedSymbol)
+          MONTHLY = T.let(:monthly, FinchAPI::Models::HRIS::Payment::PayFrequency::TaggedSymbol)
+          SEMI_MONTHLY = T.let(:semi_monthly, FinchAPI::Models::HRIS::Payment::PayFrequency::TaggedSymbol)
+          BI_WEEKLY = T.let(:bi_weekly, FinchAPI::Models::HRIS::Payment::PayFrequency::TaggedSymbol)
+          WEEKLY = T.let(:weekly, FinchAPI::Models::HRIS::Payment::PayFrequency::TaggedSymbol)
+          DAILY = T.let(:daily, FinchAPI::Models::HRIS::Payment::PayFrequency::TaggedSymbol)
+          OTHER = T.let(:other, FinchAPI::Models::HRIS::Payment::PayFrequency::TaggedSymbol)
 
-          sig { override.returns(T::Array[Symbol]) }
+          sig { override.returns(T::Array[FinchAPI::Models::HRIS::Payment::PayFrequency::TaggedSymbol]) }
           def self.values
           end
         end
 
         class PayPeriod < FinchAPI::BaseModel
           sig { returns(T.nilable(String)) }
-          def end_date
-          end
-
-          sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-          def end_date=(_)
-          end
+          attr_accessor :end_date
 
           sig { returns(T.nilable(String)) }
-          def start_date
-          end
-
-          sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-          def start_date=(_)
-          end
+          attr_accessor :start_date
 
-          sig { params(end_date: T.nilable(String), start_date: T.nilable(String)).void }
-          def initialize(end_date: nil, start_date: nil)
+          # The pay period object.
+          sig { params(end_date: T.nilable(String), start_date: T.nilable(String)).returns(T.attached_class) }
+          def self.new(end_date: nil, start_date: nil)
           end
 
           sig { override.returns({end_date: T.nilable(String), start_date: T.nilable(String)}) }

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

@@ -7,31 +7,25 @@ module FinchAPI
         extend FinchAPI::RequestParameters::Converter
         include FinchAPI::RequestParameters
 
+        # The end date to retrieve payments by a company (inclusive) in `YYYY-MM-DD`
+        #   format.
         sig { returns(Date) }
-        def end_date
-        end
-
-        sig { params(_: Date).returns(Date) }
-        def end_date=(_)
-        end
+        attr_accessor :end_date
 
+        # The start date to retrieve payments by a company (inclusive) in `YYYY-MM-DD`
+        #   format.
         sig { returns(Date) }
-        def start_date
-        end
-
-        sig { params(_: Date).returns(Date) }
-        def start_date=(_)
-        end
+        attr_accessor :start_date
 
         sig do
           params(
             end_date: Date,
             start_date: Date,
-            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:, start_date:, request_options: {})
+        def self.new(end_date:, start_date:, request_options: {})
         end
 
         sig do

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

@@ -5,29 +5,25 @@ module FinchAPI
     module HRIS
       class SupportPerBenefitType < FinchAPI::BaseModel
         sig { returns(T.nilable(FinchAPI::Models::OperationSupportMatrix)) }
-        def company_benefits
-        end
+        attr_reader :company_benefits
 
-        sig { params(_: FinchAPI::Models::OperationSupportMatrix).returns(FinchAPI::Models::OperationSupportMatrix) }
-        def company_benefits=(_)
-        end
+        sig { params(company_benefits: T.any(FinchAPI::Models::OperationSupportMatrix, FinchAPI::Util::AnyHash)).void }
+        attr_writer :company_benefits
 
         sig { returns(T.nilable(FinchAPI::Models::OperationSupportMatrix)) }
-        def individual_benefits
-        end
+        attr_reader :individual_benefits
 
-        sig { params(_: FinchAPI::Models::OperationSupportMatrix).returns(FinchAPI::Models::OperationSupportMatrix) }
-        def individual_benefits=(_)
-        end
+        sig { params(individual_benefits: T.any(FinchAPI::Models::OperationSupportMatrix, FinchAPI::Util::AnyHash)).void }
+        attr_writer :individual_benefits
 
         sig do
           params(
-            company_benefits: FinchAPI::Models::OperationSupportMatrix,
-            individual_benefits: FinchAPI::Models::OperationSupportMatrix
+            company_benefits: T.any(FinchAPI::Models::OperationSupportMatrix, FinchAPI::Util::AnyHash),
+            individual_benefits: T.any(FinchAPI::Models::OperationSupportMatrix, FinchAPI::Util::AnyHash)
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(company_benefits: nil, individual_benefits: nil)
+        def self.new(company_benefits: nil, individual_benefits: nil)
         end
 
         sig do