finch-api 0.1.0.pre.alpha.13 → 0.1.0.pre.alpha.14

data/rbi/finch_api/models/hris/employment_data_response.rbi

@@ -4,41 +4,60 @@ module FinchAPI
   module Models
     module HRIS
       class EmploymentDataResponse < FinchAPI::Internal::Type::BaseModel
-        sig { returns(T.nilable(FinchAPI::Models::HRIS::EmploymentData)) }
-        attr_reader :body
+        OrHash =
+          T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
 
-        sig { params(body: T.any(FinchAPI::Models::HRIS::EmploymentData, FinchAPI::Internal::AnyHash)).void }
-        attr_writer :body
-
-        sig { returns(T.nilable(Integer)) }
-        attr_reader :code
+        sig do
+          returns(
+            T.any(
+              FinchAPI::HRIS::EmploymentData::UnionMember0,
+              FinchAPI::HRIS::EmploymentData::BatchError
+            )
+          )
+        end
+        attr_accessor :body
 
-        sig { params(code: Integer).void }
-        attr_writer :code
+        sig { returns(Integer) }
+        attr_accessor :code
 
         # 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 do
           params(
-            body: T.any(FinchAPI::Models::HRIS::EmploymentData, FinchAPI::Internal::AnyHash),
+            body:
+              T.any(
+                FinchAPI::HRIS::EmploymentData::UnionMember0::OrHash,
+                FinchAPI::HRIS::EmploymentData::BatchError::OrHash
+              ),
             code: Integer,
             individual_id: String
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
         end
         def self.new(
-          body: nil,
-          code: nil,
+          body:,
+          code:,
           # A stable Finch `id` (UUID v4) for an individual in the company.
-          individual_id: nil
-        ); end
-        sig { override.returns({body: FinchAPI::Models::HRIS::EmploymentData, code: Integer, individual_id: String}) }
-        def to_hash; end
+          individual_id:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              body:
+                T.any(
+                  FinchAPI::HRIS::EmploymentData::UnionMember0,
+                  FinchAPI::HRIS::EmploymentData::BatchError
+                ),
+              code: Integer,
+              individual_id: String
+            }
+          )
+        end
+        def to_hash
+        end
       end
     end
   end

data/rbi/finch_api/models/hris/employment_retrieve_many_params.rbi

@@ -7,34 +7,49 @@ module FinchAPI
         extend FinchAPI::Internal::Type::RequestParameters::Converter
         include FinchAPI::Internal::Type::RequestParameters
 
+        OrHash =
+          T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
         # The array of batch requests.
-        sig { returns(T::Array[FinchAPI::Models::HRIS::EmploymentRetrieveManyParams::Request]) }
+        sig do
+          returns(
+            T::Array[FinchAPI::HRIS::EmploymentRetrieveManyParams::Request]
+          )
+        end
         attr_accessor :requests
 
         sig do
           params(
-            requests: T::Array[T.any(FinchAPI::Models::HRIS::EmploymentRetrieveManyParams::Request, FinchAPI::Internal::AnyHash)],
-            request_options: T.any(FinchAPI::RequestOptions, FinchAPI::Internal::AnyHash)
-          )
-            .returns(T.attached_class)
+            requests:
+              T::Array[
+                FinchAPI::HRIS::EmploymentRetrieveManyParams::Request::OrHash
+              ],
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(T.attached_class)
         end
         def self.new(
           # The array of batch requests.
           requests:,
           request_options: {}
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                requests: T::Array[FinchAPI::Models::HRIS::EmploymentRetrieveManyParams::Request],
-                request_options: FinchAPI::RequestOptions
-              }
-            )
+          override.returns(
+            {
+              requests:
+                T::Array[FinchAPI::HRIS::EmploymentRetrieveManyParams::Request],
+              request_options: FinchAPI::RequestOptions
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
 
         class Request < FinchAPI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
           # A stable Finch `id` (UUID v4) for an individual in the company. There is no
           # limit to the number of `individual_id` to send per request. It is preferantial
           # to send all ids in a single request for Finch to optimize provider rate-limits.
@@ -47,9 +62,12 @@ module FinchAPI
             # limit to the number of `individual_id` to send per request. It is preferantial
             # to send all ids in a single request for Finch to optimize provider rate-limits.
             individual_id:
-          ); end
-          sig { override.returns({individual_id: String}) }
-          def to_hash; end
+          )
+          end
+
+          sig { override.returns({ individual_id: String }) }
+          def to_hash
+          end
         end
       end
     end