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

data/rbi/finch_api/models/hris/pay_statement_data_sync_in_progress.rbi

@@ -0,0 +1,188 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module HRIS
+      class PayStatementDataSyncInProgress < FinchAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              FinchAPI::HRIS::PayStatementDataSyncInProgress,
+              FinchAPI::Internal::AnyHash
+            )
+          end
+
+        sig do
+          returns(
+            FinchAPI::HRIS::PayStatementDataSyncInProgress::Code::TaggedFloat
+          )
+        end
+        attr_accessor :code
+
+        sig do
+          returns(
+            FinchAPI::HRIS::PayStatementDataSyncInProgress::FinchCode::TaggedSymbol
+          )
+        end
+        attr_accessor :finch_code
+
+        sig do
+          returns(
+            FinchAPI::HRIS::PayStatementDataSyncInProgress::Message::TaggedSymbol
+          )
+        end
+        attr_accessor :message
+
+        sig do
+          returns(
+            FinchAPI::HRIS::PayStatementDataSyncInProgress::Name::TaggedSymbol
+          )
+        end
+        attr_accessor :name
+
+        sig do
+          params(
+            code: FinchAPI::HRIS::PayStatementDataSyncInProgress::Code::OrFloat,
+            finch_code:
+              FinchAPI::HRIS::PayStatementDataSyncInProgress::FinchCode::OrSymbol,
+            message:
+              FinchAPI::HRIS::PayStatementDataSyncInProgress::Message::OrSymbol,
+            name: FinchAPI::HRIS::PayStatementDataSyncInProgress::Name::OrSymbol
+          ).returns(T.attached_class)
+        end
+        def self.new(code:, finch_code:, message:, name:)
+        end
+
+        sig do
+          override.returns(
+            {
+              code:
+                FinchAPI::HRIS::PayStatementDataSyncInProgress::Code::TaggedFloat,
+              finch_code:
+                FinchAPI::HRIS::PayStatementDataSyncInProgress::FinchCode::TaggedSymbol,
+              message:
+                FinchAPI::HRIS::PayStatementDataSyncInProgress::Message::TaggedSymbol,
+              name:
+                FinchAPI::HRIS::PayStatementDataSyncInProgress::Name::TaggedSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Code
+          extend FinchAPI::Internal::Type::Enum
+
+          TaggedFloat =
+            T.type_alias do
+              T.all(Float, FinchAPI::HRIS::PayStatementDataSyncInProgress::Code)
+            end
+          OrFloat = T.type_alias { Float }
+
+          CODE_202 =
+            T.let(
+              202,
+              FinchAPI::HRIS::PayStatementDataSyncInProgress::Code::TaggedFloat
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                FinchAPI::HRIS::PayStatementDataSyncInProgress::Code::TaggedFloat
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        module FinchCode
+          extend FinchAPI::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                FinchAPI::HRIS::PayStatementDataSyncInProgress::FinchCode
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          DATA_SYNC_IN_PROGRESS =
+            T.let(
+              :data_sync_in_progress,
+              FinchAPI::HRIS::PayStatementDataSyncInProgress::FinchCode::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                FinchAPI::HRIS::PayStatementDataSyncInProgress::FinchCode::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        module Message
+          extend FinchAPI::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                FinchAPI::HRIS::PayStatementDataSyncInProgress::Message
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          THE_PAY_STATEMENTS_FOR_THIS_PAYMENT_ARE_BEING_FETCHED_PLEASE_CHECK_BACK_LATER =
+            T.let(
+              :"The pay statements for this payment are being fetched. Please check back later.",
+              FinchAPI::HRIS::PayStatementDataSyncInProgress::Message::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                FinchAPI::HRIS::PayStatementDataSyncInProgress::Message::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        module Name
+          extend FinchAPI::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                FinchAPI::HRIS::PayStatementDataSyncInProgress::Name
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          ACCEPTED =
+            T.let(
+              :accepted,
+              FinchAPI::HRIS::PayStatementDataSyncInProgress::Name::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                FinchAPI::HRIS::PayStatementDataSyncInProgress::Name::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/finch_api/models/hris/pay_statement_response.rbi

@@ -12,40 +12,34 @@ module FinchAPI
             )
           end
 
-        sig { returns(T.nilable(FinchAPI::HRIS::PayStatementResponseBody)) }
-        attr_reader :body
+        sig { returns(FinchAPI::HRIS::PayStatementResponse::Body::Variants) }
+        attr_accessor :body
 
-        sig do
-          params(body: FinchAPI::HRIS::PayStatementResponseBody::OrHash).void
-        end
-        attr_writer :body
-
-        sig { returns(T.nilable(Integer)) }
-        attr_reader :code
+        sig { returns(Integer) }
+        attr_accessor :code
 
-        sig { params(code: Integer).void }
-        attr_writer :code
-
-        sig { returns(T.nilable(String)) }
-        attr_reader :payment_id
-
-        sig { params(payment_id: String).void }
-        attr_writer :payment_id
+        sig { returns(String) }
+        attr_accessor :payment_id
 
         sig do
           params(
-            body: FinchAPI::HRIS::PayStatementResponseBody::OrHash,
+            body:
+              T.any(
+                FinchAPI::HRIS::PayStatementResponseBody::OrHash,
+                FinchAPI::HRIS::PayStatementResponse::Body::BatchError::OrHash,
+                FinchAPI::HRIS::PayStatementDataSyncInProgress::OrHash
+              ),
             code: Integer,
             payment_id: String
           ).returns(T.attached_class)
         end
-        def self.new(body: nil, code: nil, payment_id: nil)
+        def self.new(body:, code:, payment_id:)
         end
 
         sig do
           override.returns(
             {
-              body: FinchAPI::HRIS::PayStatementResponseBody,
+              body: FinchAPI::HRIS::PayStatementResponse::Body::Variants,
               code: Integer,
               payment_id: String
             }
@@ -53,6 +47,76 @@ module FinchAPI
         end
         def to_hash
         end
+
+        module Body
+          extend FinchAPI::Internal::Type::Union
+
+          Variants =
+            T.type_alias do
+              T.any(
+                FinchAPI::HRIS::PayStatementResponseBody,
+                FinchAPI::HRIS::PayStatementResponse::Body::BatchError,
+                FinchAPI::HRIS::PayStatementDataSyncInProgress
+              )
+            end
+
+          class BatchError < FinchAPI::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  FinchAPI::HRIS::PayStatementResponse::Body::BatchError,
+                  FinchAPI::Internal::AnyHash
+                )
+              end
+
+            sig { returns(Float) }
+            attr_accessor :code
+
+            sig { returns(String) }
+            attr_accessor :message
+
+            sig { returns(String) }
+            attr_accessor :name
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :finch_code
+
+            sig { params(finch_code: String).void }
+            attr_writer :finch_code
+
+            sig do
+              params(
+                code: Float,
+                message: String,
+                name: String,
+                finch_code: String
+              ).returns(T.attached_class)
+            end
+            def self.new(code:, message:, name:, finch_code: nil)
+            end
+
+            sig do
+              override.returns(
+                {
+                  code: Float,
+                  message: String,
+                  name: String,
+                  finch_code: String
+                }
+              )
+            end
+            def to_hash
+            end
+          end
+
+          sig do
+            override.returns(
+              T::Array[FinchAPI::HRIS::PayStatementResponse::Body::Variants]
+            )
+          end
+          def self.variants
+          end
+        end
       end
     end
   end

data/rbi/finch_api/models/hris/pay_statement_response_body.rbi

@@ -12,46 +12,74 @@ module FinchAPI
             )
           end
 
-        sig { returns(T.nilable(FinchAPI::Paging)) }
+        sig { returns(FinchAPI::HRIS::PayStatementResponseBody::Paging) }
         attr_reader :paging
 
-        sig { params(paging: FinchAPI::Paging::OrHash).void }
-        attr_writer :paging
-
-        # The array of pay statements for the current payment.
-        sig { returns(T.nilable(T::Array[FinchAPI::HRIS::PayStatement])) }
-        attr_reader :pay_statements
-
         sig do
           params(
-            pay_statements: T::Array[FinchAPI::HRIS::PayStatement::OrHash]
+            paging: FinchAPI::HRIS::PayStatementResponseBody::Paging::OrHash
           ).void
         end
-        attr_writer :pay_statements
+        attr_writer :paging
+
+        sig { returns(T::Array[FinchAPI::HRIS::PayStatement]) }
+        attr_accessor :pay_statements
 
         sig do
           params(
-            paging: FinchAPI::Paging::OrHash,
+            paging: FinchAPI::HRIS::PayStatementResponseBody::Paging::OrHash,
             pay_statements: T::Array[FinchAPI::HRIS::PayStatement::OrHash]
           ).returns(T.attached_class)
         end
-        def self.new(
-          paging: nil,
-          # The array of pay statements for the current payment.
-          pay_statements: nil
-        )
+        def self.new(paging:, pay_statements:)
         end
 
         sig do
           override.returns(
             {
-              paging: FinchAPI::Paging,
+              paging: FinchAPI::HRIS::PayStatementResponseBody::Paging,
               pay_statements: T::Array[FinchAPI::HRIS::PayStatement]
             }
           )
         end
         def to_hash
         end
+
+        class Paging < FinchAPI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                FinchAPI::HRIS::PayStatementResponseBody::Paging,
+                FinchAPI::Internal::AnyHash
+              )
+            end
+
+          # The current start index of the returned list of elements
+          sig { returns(Integer) }
+          attr_accessor :offset
+
+          # The total number of elements for the entire query (not just the given page)
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :count
+
+          sig { params(count: Integer).void }
+          attr_writer :count
+
+          sig do
+            params(offset: Integer, count: Integer).returns(T.attached_class)
+          end
+          def self.new(
+            # The current start index of the returned list of elements
+            offset:,
+            # The total number of elements for the entire query (not just the given page)
+            count: nil
+          )
+          end
+
+          sig { override.returns({ offset: Integer, count: Integer }) }
+          def to_hash
+          end
+        end
       end
     end
   end

data/rbi/finch_api/models/hris/payment.rbi

@@ -10,11 +10,8 @@ module FinchAPI
           end
 
         # The unique id for the payment.
-        sig { returns(T.nilable(String)) }
-        attr_reader :id
-
-        sig { params(id: String).void }
-        attr_writer :id
+        sig { returns(String) }
+        attr_accessor :id
 
         sig { returns(T.nilable(FinchAPI::Money)) }
         attr_reader :company_debit
@@ -102,22 +99,22 @@ module FinchAPI
         end
         def self.new(
           # The unique id for the payment.
-          id: nil,
-          company_debit: nil,
-          debit_date: nil,
-          employee_taxes: nil,
-          employer_taxes: nil,
-          gross_pay: nil,
+          id:,
+          company_debit:,
+          debit_date:,
+          employee_taxes:,
+          employer_taxes:,
+          gross_pay:,
           # Array of every individual on this payment.
-          individual_ids: nil,
-          net_pay: nil,
-          pay_date: nil,
+          individual_ids:,
+          net_pay:,
+          pay_date:,
           # List of pay frequencies associated with this payment.
-          pay_frequencies: nil,
+          pay_frequencies:,
           # Array of the Finch id (uuidv4) of every pay group associated with this payment.
-          pay_group_ids: nil,
+          pay_group_ids:,
           # The pay period object.
-          pay_period: nil
+          pay_period:
         )
         end
 
@@ -159,34 +156,34 @@ module FinchAPI
               :annually,
               FinchAPI::HRIS::Payment::PayFrequency::TaggedSymbol
             )
-          SEMI_ANNUALLY =
+          BI_WEEKLY =
             T.let(
-              :semi_annually,
+              :bi_weekly,
               FinchAPI::HRIS::Payment::PayFrequency::TaggedSymbol
             )
+          DAILY =
+            T.let(:daily, FinchAPI::HRIS::Payment::PayFrequency::TaggedSymbol)
+          MONTHLY =
+            T.let(:monthly, FinchAPI::HRIS::Payment::PayFrequency::TaggedSymbol)
+          OTHER =
+            T.let(:other, FinchAPI::HRIS::Payment::PayFrequency::TaggedSymbol)
           QUARTERLY =
             T.let(
               :quarterly,
               FinchAPI::HRIS::Payment::PayFrequency::TaggedSymbol
             )
-          MONTHLY =
-            T.let(:monthly, FinchAPI::HRIS::Payment::PayFrequency::TaggedSymbol)
-          SEMI_MONTHLY =
+          SEMI_ANNUALLY =
             T.let(
-              :semi_monthly,
+              :semi_annually,
               FinchAPI::HRIS::Payment::PayFrequency::TaggedSymbol
             )
-          BI_WEEKLY =
+          SEMI_MONTHLY =
             T.let(
-              :bi_weekly,
+              :semi_monthly,
               FinchAPI::HRIS::Payment::PayFrequency::TaggedSymbol
             )
           WEEKLY =
             T.let(:weekly, FinchAPI::HRIS::Payment::PayFrequency::TaggedSymbol)
-          DAILY =
-            T.let(:daily, FinchAPI::HRIS::Payment::PayFrequency::TaggedSymbol)
-          OTHER =
-            T.let(:other, FinchAPI::HRIS::Payment::PayFrequency::TaggedSymbol)
 
           sig do
             override.returns(
@@ -219,7 +216,7 @@ module FinchAPI
               start_date: T.nilable(String)
             ).returns(T.attached_class)
           end
-          def self.new(end_date: nil, start_date: nil)
+          def self.new(end_date:, start_date:)
           end
 
           sig do

data/rbi/finch_api/models/hris/supported_benefit.rbi

@@ -25,7 +25,7 @@ module FinchAPI
             T.nilable(
               T::Array[
                 T.nilable(
-                  FinchAPI::HRIS::SupportedBenefit::CompanyContribution::OrSymbol
+                  FinchAPI::HRIS::SupportedBenefit::CompanyContribution::TaggedSymbol
                 )
               ]
             )
@@ -43,7 +43,7 @@ module FinchAPI
             T.nilable(
               T::Array[
                 T.nilable(
-                  FinchAPI::HRIS::SupportedBenefit::EmployeeDeduction::OrSymbol
+                  FinchAPI::HRIS::SupportedBenefit::EmployeeDeduction::TaggedSymbol
                 )
               ]
             )
@@ -55,7 +55,9 @@ module FinchAPI
         sig do
           returns(
             T.nilable(
-              T::Array[T.nilable(FinchAPI::HRIS::BenefitFrequency::OrSymbol)]
+              T::Array[
+                T.nilable(FinchAPI::HRIS::BenefitFrequency::TaggedSymbol)
+              ]
             )
           )
         end
@@ -76,7 +78,7 @@ module FinchAPI
             T.nilable(
               T::Array[
                 T.nilable(
-                  FinchAPI::HRIS::SupportedBenefit::HsaContributionLimit::OrSymbol
+                  FinchAPI::HRIS::SupportedBenefit::HsaContributionLimit::TaggedSymbol
                 )
               ]
             )
@@ -147,7 +149,7 @@ module FinchAPI
                 T.nilable(
                   T::Array[
                     T.nilable(
-                      FinchAPI::HRIS::SupportedBenefit::CompanyContribution::OrSymbol
+                      FinchAPI::HRIS::SupportedBenefit::CompanyContribution::TaggedSymbol
                     )
                   ]
                 ),
@@ -156,17 +158,19 @@ module FinchAPI
                 T.nilable(
                   T::Array[
                     T.nilable(
-                      FinchAPI::HRIS::SupportedBenefit::EmployeeDeduction::OrSymbol
+                      FinchAPI::HRIS::SupportedBenefit::EmployeeDeduction::TaggedSymbol
                     )
                   ]
                 ),
               frequencies:
-                T::Array[T.nilable(FinchAPI::HRIS::BenefitFrequency::OrSymbol)],
+                T::Array[
+                  T.nilable(FinchAPI::HRIS::BenefitFrequency::TaggedSymbol)
+                ],
               hsa_contribution_limit:
                 T.nilable(
                   T::Array[
                     T.nilable(
-                      FinchAPI::HRIS::SupportedBenefit::HsaContributionLimit::OrSymbol
+                      FinchAPI::HRIS::SupportedBenefit::HsaContributionLimit::TaggedSymbol
                     )
                   ]
                 )

data/rbi/finch_api/models/income.rbi

@@ -15,7 +15,7 @@ module FinchAPI
       attr_accessor :currency
 
       # The date the income amount went into effect.
-      sig { returns(T.nilable(String)) }
+      sig { returns(T.nilable(Date)) }
       attr_accessor :effective_date
 
       # The income unit of payment. Options: `yearly`, `quarterly`, `monthly`,
@@ -30,7 +30,7 @@ module FinchAPI
         params(
           amount: T.nilable(Integer),
           currency: T.nilable(String),
-          effective_date: T.nilable(String),
+          effective_date: T.nilable(Date),
           unit: T.nilable(FinchAPI::Income::Unit::OrSymbol)
         ).returns(T.attached_class)
       end
@@ -52,7 +52,7 @@ module FinchAPI
           {
             amount: T.nilable(Integer),
             currency: T.nilable(String),
-            effective_date: T.nilable(String),
+            effective_date: T.nilable(Date),
             unit: T.nilable(FinchAPI::Income::Unit::OrSymbol)
           }
         )

data/rbi/finch_api/models/money.rbi

@@ -10,11 +10,8 @@ module FinchAPI
       sig { returns(T.nilable(Integer)) }
       attr_accessor :amount
 
-      sig { returns(T.nilable(String)) }
-      attr_reader :currency
-
-      sig { params(currency: String).void }
-      attr_writer :currency
+      sig { returns(String) }
+      attr_accessor :currency
 
       sig do
         params(amount: T.nilable(Integer), currency: String).returns(
@@ -23,8 +20,8 @@ module FinchAPI
       end
       def self.new(
         # Amount for money object (in cents)
-        amount: nil,
-        currency: nil
+        amount:,
+        currency:
       )
       end