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

data/rbi/finch_api/models/hris/individual_in_directory.rbi

@@ -4,19 +4,26 @@ module FinchAPI
   module Models
     module HRIS
       class IndividualInDirectory < 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.
         sig { returns(String) }
         attr_accessor :id
 
         # The department object.
-        sig { returns(T.nilable(FinchAPI::Models::HRIS::IndividualInDirectory::Department)) }
+        sig do
+          returns(T.nilable(FinchAPI::HRIS::IndividualInDirectory::Department))
+        end
         attr_reader :department
 
         sig do
           params(
-            department: T.nilable(T.any(FinchAPI::Models::HRIS::IndividualInDirectory::Department, FinchAPI::Internal::AnyHash))
-          )
-            .void
+            department:
+              T.nilable(
+                FinchAPI::HRIS::IndividualInDirectory::Department::OrHash
+              )
+          ).void
         end
         attr_writer :department
 
@@ -33,14 +40,16 @@ module FinchAPI
         attr_accessor :last_name
 
         # The manager object.
-        sig { returns(T.nilable(FinchAPI::Models::HRIS::IndividualInDirectory::Manager)) }
+        sig do
+          returns(T.nilable(FinchAPI::HRIS::IndividualInDirectory::Manager))
+        end
         attr_reader :manager
 
         sig do
           params(
-            manager: T.nilable(T.any(FinchAPI::Models::HRIS::IndividualInDirectory::Manager, FinchAPI::Internal::AnyHash))
-          )
-            .void
+            manager:
+              T.nilable(FinchAPI::HRIS::IndividualInDirectory::Manager::OrHash)
+          ).void
         end
         attr_writer :manager
 
@@ -51,14 +60,17 @@ module FinchAPI
         sig do
           params(
             id: String,
-            department: T.nilable(T.any(FinchAPI::Models::HRIS::IndividualInDirectory::Department, FinchAPI::Internal::AnyHash)),
+            department:
+              T.nilable(
+                FinchAPI::HRIS::IndividualInDirectory::Department::OrHash
+              ),
             first_name: T.nilable(String),
             is_active: T.nilable(T::Boolean),
             last_name: T.nilable(String),
-            manager: T.nilable(T.any(FinchAPI::Models::HRIS::IndividualInDirectory::Manager, FinchAPI::Internal::AnyHash)),
+            manager:
+              T.nilable(FinchAPI::HRIS::IndividualInDirectory::Manager::OrHash),
             middle_name: T.nilable(String)
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
         end
         def self.new(
           # A stable Finch `id` (UUID v4) for an individual in the company.
@@ -75,24 +87,31 @@ module FinchAPI
           manager:,
           # The legal middle name of the individual.
           middle_name:
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                id: String,
-                department: T.nilable(FinchAPI::Models::HRIS::IndividualInDirectory::Department),
-                first_name: T.nilable(String),
-                is_active: T.nilable(T::Boolean),
-                last_name: T.nilable(String),
-                manager: T.nilable(FinchAPI::Models::HRIS::IndividualInDirectory::Manager),
-                middle_name: T.nilable(String)
-              }
-            )
+          override.returns(
+            {
+              id: String,
+              department:
+                T.nilable(FinchAPI::HRIS::IndividualInDirectory::Department),
+              first_name: T.nilable(String),
+              is_active: T.nilable(T::Boolean),
+              last_name: T.nilable(String),
+              manager:
+                T.nilable(FinchAPI::HRIS::IndividualInDirectory::Manager),
+              middle_name: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
 
         class Department < FinchAPI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
           # The name of the department.
           sig { returns(T.nilable(String)) }
           attr_accessor :name
@@ -102,12 +121,18 @@ module FinchAPI
           def self.new(
             # The name of the department.
             name: nil
-          ); end
-          sig { override.returns({name: T.nilable(String)}) }
-          def to_hash; end
+          )
+          end
+
+          sig { override.returns({ name: T.nilable(String) }) }
+          def to_hash
+          end
         end
 
         class Manager < 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.
           sig { returns(String) }
           attr_accessor :id
@@ -117,9 +142,12 @@ module FinchAPI
           def self.new(
             # A stable Finch `id` (UUID v4) for an individual in the company.
             id:
-          ); end
-          sig { override.returns({id: String}) }
-          def to_hash; end
+          )
+          end
+
+          sig { override.returns({ id: String }) }
+          def to_hash
+          end
         end
       end
     end

data/rbi/finch_api/models/hris/individual_response.rbi

@@ -4,9 +4,15 @@ module FinchAPI
   module Models
     module HRIS
       class IndividualResponse < FinchAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
         sig do
           returns(
-            T.any(FinchAPI::Models::HRIS::Individual::UnionMember0, FinchAPI::Models::HRIS::Individual::BatchError)
+            T.any(
+              FinchAPI::HRIS::Individual::UnionMember0,
+              FinchAPI::HRIS::Individual::BatchError
+            )
           )
         end
         attr_accessor :body
@@ -19,29 +25,33 @@ module FinchAPI
 
         sig do
           params(
-            body: T.any(
-              FinchAPI::Models::HRIS::Individual::UnionMember0,
-              FinchAPI::Internal::AnyHash,
-              FinchAPI::Models::HRIS::Individual::BatchError
-            ),
+            body:
+              T.any(
+                FinchAPI::HRIS::Individual::UnionMember0::OrHash,
+                FinchAPI::HRIS::Individual::BatchError::OrHash
+              ),
             code: Integer,
             individual_id: String
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
+        end
+        def self.new(body:, code:, individual_id:)
         end
-        def self.new(body:, code:, individual_id:); end
 
         sig do
-          override
-            .returns(
-              {
-                body: T.any(FinchAPI::Models::HRIS::Individual::UnionMember0, FinchAPI::Models::HRIS::Individual::BatchError),
-                code: Integer,
-                individual_id: String
-              }
-            )
+          override.returns(
+            {
+              body:
+                T.any(
+                  FinchAPI::HRIS::Individual::UnionMember0,
+                  FinchAPI::HRIS::Individual::BatchError
+                ),
+              code: Integer,
+              individual_id: String
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
       end
     end
   end

data/rbi/finch_api/models/hris/individual_retrieve_many_params.rbi

@@ -7,55 +7,81 @@ module FinchAPI
         extend FinchAPI::Internal::Type::RequestParameters::Converter
         include FinchAPI::Internal::Type::RequestParameters
 
-        sig { returns(T.nilable(FinchAPI::Models::HRIS::IndividualRetrieveManyParams::Options)) }
+        OrHash =
+          T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
+        sig do
+          returns(
+            T.nilable(FinchAPI::HRIS::IndividualRetrieveManyParams::Options)
+          )
+        end
         attr_reader :options
 
         sig do
           params(
-            options: T.nilable(
-              T.any(FinchAPI::Models::HRIS::IndividualRetrieveManyParams::Options, FinchAPI::Internal::AnyHash)
-            )
-          )
-            .void
+            options:
+              T.nilable(
+                FinchAPI::HRIS::IndividualRetrieveManyParams::Options::OrHash
+              )
+          ).void
         end
         attr_writer :options
 
-        sig { returns(T.nilable(T::Array[FinchAPI::Models::HRIS::IndividualRetrieveManyParams::Request])) }
+        sig do
+          returns(
+            T.nilable(
+              T::Array[FinchAPI::HRIS::IndividualRetrieveManyParams::Request]
+            )
+          )
+        end
         attr_reader :requests
 
         sig do
           params(
-            requests: T::Array[T.any(FinchAPI::Models::HRIS::IndividualRetrieveManyParams::Request, FinchAPI::Internal::AnyHash)]
-          )
-            .void
+            requests:
+              T::Array[
+                FinchAPI::HRIS::IndividualRetrieveManyParams::Request::OrHash
+              ]
+          ).void
         end
         attr_writer :requests
 
         sig do
           params(
-            options: T.nilable(
-              T.any(FinchAPI::Models::HRIS::IndividualRetrieveManyParams::Options, FinchAPI::Internal::AnyHash)
-            ),
-            requests: T::Array[T.any(FinchAPI::Models::HRIS::IndividualRetrieveManyParams::Request, FinchAPI::Internal::AnyHash)],
-            request_options: T.any(FinchAPI::RequestOptions, FinchAPI::Internal::AnyHash)
-          )
-            .returns(T.attached_class)
+            options:
+              T.nilable(
+                FinchAPI::HRIS::IndividualRetrieveManyParams::Options::OrHash
+              ),
+            requests:
+              T::Array[
+                FinchAPI::HRIS::IndividualRetrieveManyParams::Request::OrHash
+              ],
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(options: nil, requests: nil, request_options: {})
         end
-        def self.new(options: nil, requests: nil, request_options: {}); end
 
         sig do
-          override
-            .returns(
-              {
-                options: T.nilable(FinchAPI::Models::HRIS::IndividualRetrieveManyParams::Options),
-                requests: T::Array[FinchAPI::Models::HRIS::IndividualRetrieveManyParams::Request],
-                request_options: FinchAPI::RequestOptions
-              }
-            )
+          override.returns(
+            {
+              options:
+                T.nilable(
+                  FinchAPI::HRIS::IndividualRetrieveManyParams::Options
+                ),
+              requests:
+                T::Array[FinchAPI::HRIS::IndividualRetrieveManyParams::Request],
+              request_options: FinchAPI::RequestOptions
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
 
         class Options < FinchAPI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
           sig { returns(T.nilable(T::Array[String])) }
           attr_reader :include
 
@@ -63,13 +89,18 @@ module FinchAPI
           attr_writer :include
 
           sig { params(include: T::Array[String]).returns(T.attached_class) }
-          def self.new(include: nil); end
+          def self.new(include: nil)
+          end
 
-          sig { override.returns({include: T::Array[String]}) }
-          def to_hash; end
+          sig { override.returns({ include: T::Array[String] }) }
+          def to_hash
+          end
         end
 
         class Request < FinchAPI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
           sig { returns(T.nilable(String)) }
           attr_reader :individual_id
 
@@ -77,10 +108,12 @@ module FinchAPI
           attr_writer :individual_id
 
           sig { params(individual_id: String).returns(T.attached_class) }
-          def self.new(individual_id: nil); end
+          def self.new(individual_id: nil)
+          end
 
-          sig { override.returns({individual_id: String}) }
-          def to_hash; end
+          sig { override.returns({ individual_id: String }) }
+          def to_hash
+          end
         end
       end
     end