finch-api 0.1.0.pre.alpha.29 → 0.1.0.pre.alpha.31

data/rbi/finch_api/models/hris/document_response.rbi

@@ -10,11 +10,8 @@ module FinchAPI
           end
 
         # A stable Finch id for the document.
-        sig { returns(T.nilable(String)) }
-        attr_reader :id
-
-        sig { params(id: String).void }
-        attr_writer :id
+        sig { returns(String) }
+        attr_accessor :id
 
         # The ID of the individual associated with the document. This will be null for
         # employer-level documents.
@@ -22,28 +19,16 @@ module FinchAPI
         attr_accessor :individual_id
 
         # The type of document.
-        sig do
-          returns(
-            T.nilable(FinchAPI::HRIS::DocumentResponse::Type::TaggedSymbol)
-          )
-        end
-        attr_reader :type
-
-        sig do
-          params(type: FinchAPI::HRIS::DocumentResponse::Type::OrSymbol).void
-        end
-        attr_writer :type
+        sig { returns(FinchAPI::HRIS::DocumentResponse::Type::TaggedSymbol) }
+        attr_accessor :type
 
         # A URL to access the document. Format:
         # `https://api.tryfinch.com/employer/documents/:document_id`.
-        sig { returns(T.nilable(String)) }
-        attr_reader :url
-
-        sig { params(url: String).void }
-        attr_writer :url
+        sig { returns(String) }
+        attr_accessor :url
 
         # The year the document applies to, if available.
-        sig { returns(T.nilable(Float)) }
+        sig { returns(Float) }
         attr_accessor :year
 
         sig do
@@ -52,22 +37,22 @@ module FinchAPI
             individual_id: T.nilable(String),
             type: FinchAPI::HRIS::DocumentResponse::Type::OrSymbol,
             url: String,
-            year: T.nilable(Float)
+            year: Float
           ).returns(T.attached_class)
         end
         def self.new(
           # A stable Finch id for the document.
-          id: nil,
+          id:,
           # The ID of the individual associated with the document. This will be null for
           # employer-level documents.
-          individual_id: nil,
+          individual_id:,
           # The type of document.
-          type: nil,
+          type:,
           # A URL to access the document. Format:
           # `https://api.tryfinch.com/employer/documents/:document_id`.
-          url: nil,
+          url:,
           # The year the document applies to, if available.
-          year: nil
+          year:
         )
         end
 
@@ -78,7 +63,7 @@ module FinchAPI
               individual_id: T.nilable(String),
               type: FinchAPI::HRIS::DocumentResponse::Type::TaggedSymbol,
               url: String,
-              year: T.nilable(Float)
+              year: Float
             }
           )
         end

data/rbi/finch_api/models/hris/document_retreive_params.rbi

@@ -15,15 +15,34 @@ module FinchAPI
             )
           end
 
+        # The entity IDs to specify which entities' data to access.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :entity_ids
+
+        sig { params(entity_ids: T::Array[String]).void }
+        attr_writer :entity_ids
+
         sig do
-          params(request_options: FinchAPI::RequestOptions::OrHash).returns(
-            T.attached_class
-          )
+          params(
+            entity_ids: T::Array[String],
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(T.attached_class)
         end
-        def self.new(request_options: {})
+        def self.new(
+          # The entity IDs to specify which entities' data to access.
+          entity_ids: nil,
+          request_options: {}
+        )
         end
 
-        sig { override.returns({ request_options: FinchAPI::RequestOptions }) }
+        sig do
+          override.returns(
+            {
+              entity_ids: T::Array[String],
+              request_options: FinchAPI::RequestOptions
+            }
+          )
+        end
         def to_hash
         end
       end

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

@@ -23,18 +23,28 @@ module FinchAPI
         end
         attr_accessor :requests
 
+        # The entity IDs to specify which entities' data to access.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :entity_ids
+
+        sig { params(entity_ids: T::Array[String]).void }
+        attr_writer :entity_ids
+
         sig do
           params(
             requests:
               T::Array[
                 FinchAPI::HRIS::EmploymentRetrieveManyParams::Request::OrHash
               ],
+            entity_ids: T::Array[String],
             request_options: FinchAPI::RequestOptions::OrHash
           ).returns(T.attached_class)
         end
         def self.new(
           # The array of batch requests.
           requests:,
+          # The entity IDs to specify which entities' data to access.
+          entity_ids: nil,
           request_options: {}
         )
         end
@@ -44,6 +54,7 @@ module FinchAPI
             {
               requests:
                 T::Array[FinchAPI::HRIS::EmploymentRetrieveManyParams::Request],
+              entity_ids: T::Array[String],
               request_options: FinchAPI::RequestOptions
             }
           )

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

@@ -15,6 +15,13 @@ module FinchAPI
             )
           end
 
+        # The entity IDs to specify which entities' data to access.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :entity_ids
+
+        sig { params(entity_ids: T::Array[String]).void }
+        attr_writer :entity_ids
+
         sig do
           returns(
             T.nilable(FinchAPI::HRIS::IndividualRetrieveManyParams::Options)
@@ -53,6 +60,7 @@ module FinchAPI
 
         sig do
           params(
+            entity_ids: T::Array[String],
             options:
               T.nilable(
                 FinchAPI::HRIS::IndividualRetrieveManyParams::Options::OrHash
@@ -64,12 +72,19 @@ module FinchAPI
             request_options: FinchAPI::RequestOptions::OrHash
           ).returns(T.attached_class)
         end
-        def self.new(options: nil, requests: nil, request_options: {})
+        def self.new(
+          # The entity IDs to specify which entities' data to access.
+          entity_ids: nil,
+          options: nil,
+          requests: nil,
+          request_options: {}
+        )
         end
 
         sig do
           override.returns(
             {
+              entity_ids: T::Array[String],
               options:
                 T.nilable(
                   FinchAPI::HRIS::IndividualRetrieveManyParams::Options

data/rbi/finch_api/models/hris/pay_statement.rbi

@@ -22,11 +22,7 @@ module FinchAPI
         # The array of deductions objects associated with this pay statement.
         sig do
           returns(
-            T.nilable(
-              T::Array[
-                T.nilable(FinchAPI::HRIS::PayStatement::EmployeeDeduction)
-              ]
-            )
+            T.nilable(T::Array[FinchAPI::HRIS::PayStatement::EmployeeDeduction])
           )
         end
         attr_accessor :employee_deductions
@@ -34,9 +30,7 @@ module FinchAPI
         sig do
           returns(
             T.nilable(
-              T::Array[
-                T.nilable(FinchAPI::HRIS::PayStatement::EmployerContribution)
-              ]
+              T::Array[FinchAPI::HRIS::PayStatement::EmployerContribution]
             )
           )
         end
@@ -67,11 +61,7 @@ module FinchAPI
         attr_accessor :payment_method
 
         # The array of taxes objects associated with this pay statement.
-        sig do
-          returns(
-            T.nilable(T::Array[T.nilable(FinchAPI::HRIS::PayStatement::Tax)])
-          )
-        end
+        sig { returns(T.nilable(T::Array[FinchAPI::HRIS::PayStatement::Tax])) }
         attr_accessor :taxes
 
         # The number of hours worked for this pay period
@@ -95,17 +85,13 @@ module FinchAPI
             employee_deductions:
               T.nilable(
                 T::Array[
-                  T.nilable(
-                    FinchAPI::HRIS::PayStatement::EmployeeDeduction::OrHash
-                  )
+                  FinchAPI::HRIS::PayStatement::EmployeeDeduction::OrHash
                 ]
               ),
             employer_contributions:
               T.nilable(
                 T::Array[
-                  T.nilable(
-                    FinchAPI::HRIS::PayStatement::EmployerContribution::OrHash
-                  )
+                  FinchAPI::HRIS::PayStatement::EmployerContribution::OrHash
                 ]
               ),
             gross_pay: T.nilable(FinchAPI::Money::OrHash),
@@ -114,9 +100,7 @@ module FinchAPI
             payment_method:
               T.nilable(FinchAPI::HRIS::PayStatement::PaymentMethod::OrSymbol),
             taxes:
-              T.nilable(
-                T::Array[T.nilable(FinchAPI::HRIS::PayStatement::Tax::OrHash)]
-              ),
+              T.nilable(T::Array[FinchAPI::HRIS::PayStatement::Tax::OrHash]),
             total_hours: T.nilable(Float),
             type: T.nilable(FinchAPI::HRIS::PayStatement::Type::OrSymbol)
           ).returns(T.attached_class)
@@ -151,17 +135,11 @@ module FinchAPI
                 ),
               employee_deductions:
                 T.nilable(
-                  T::Array[
-                    T.nilable(FinchAPI::HRIS::PayStatement::EmployeeDeduction)
-                  ]
+                  T::Array[FinchAPI::HRIS::PayStatement::EmployeeDeduction]
                 ),
               employer_contributions:
                 T.nilable(
-                  T::Array[
-                    T.nilable(
-                      FinchAPI::HRIS::PayStatement::EmployerContribution
-                    )
-                  ]
+                  T::Array[FinchAPI::HRIS::PayStatement::EmployerContribution]
                 ),
               gross_pay: T.nilable(FinchAPI::Money),
               individual_id: String,
@@ -170,10 +148,7 @@ module FinchAPI
                 T.nilable(
                   FinchAPI::HRIS::PayStatement::PaymentMethod::TaggedSymbol
                 ),
-              taxes:
-                T.nilable(
-                  T::Array[T.nilable(FinchAPI::HRIS::PayStatement::Tax)]
-                ),
+              taxes: T.nilable(T::Array[FinchAPI::HRIS::PayStatement::Tax]),
               total_hours: T.nilable(Float),
               type: T.nilable(FinchAPI::HRIS::PayStatement::Type::TaggedSymbol)
             }
@@ -382,77 +357,32 @@ module FinchAPI
                 )
               end
 
-            sig do
-              returns(
-                FinchAPI::HRIS::PayStatement::Earning::Attributes::Metadata
-              )
-            end
-            attr_reader :metadata
-
-            sig do
-              params(
-                metadata:
-                  FinchAPI::HRIS::PayStatement::Earning::Attributes::Metadata::OrHash
-              ).void
-            end
-            attr_writer :metadata
+            # 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::Hash[Symbol, T.nilable(T.anything)]) }
+            attr_accessor :metadata
 
             sig do
-              params(
-                metadata:
-                  FinchAPI::HRIS::PayStatement::Earning::Attributes::Metadata::OrHash
-              ).returns(T.attached_class)
+              params(metadata: T::Hash[Symbol, T.nilable(T.anything)]).returns(
+                T.attached_class
+              )
             end
-            def self.new(metadata:)
+            def self.new(
+              # 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.).
+              metadata:
+            )
             end
 
             sig do
               override.returns(
-                {
-                  metadata:
-                    FinchAPI::HRIS::PayStatement::Earning::Attributes::Metadata
-                }
+                { metadata: T::Hash[Symbol, T.nilable(T.anything)] }
               )
             end
             def to_hash
             end
-
-            class Metadata < FinchAPI::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    FinchAPI::HRIS::PayStatement::Earning::Attributes::Metadata,
-                    FinchAPI::Internal::AnyHash
-                  )
-                end
-
-              # 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::Hash[Symbol, T.nilable(T.anything)]) }
-              attr_accessor :metadata
-
-              sig do
-                params(
-                  metadata: T::Hash[Symbol, T.nilable(T.anything)]
-                ).returns(T.attached_class)
-              end
-              def self.new(
-                # 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.).
-                metadata:
-              )
-              end
-
-              sig do
-                override.returns(
-                  { metadata: T::Hash[Symbol, T.nilable(T.anything)] }
-                )
-              end
-              def to_hash
-              end
-            end
           end
         end
 
@@ -559,77 +489,32 @@ module FinchAPI
                 )
               end
 
-            sig do
-              returns(
-                FinchAPI::HRIS::PayStatement::EmployeeDeduction::Attributes::Metadata
-              )
-            end
-            attr_reader :metadata
-
-            sig do
-              params(
-                metadata:
-                  FinchAPI::HRIS::PayStatement::EmployeeDeduction::Attributes::Metadata::OrHash
-              ).void
-            end
-            attr_writer :metadata
+            # 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::Hash[Symbol, T.nilable(T.anything)]) }
+            attr_accessor :metadata
 
             sig do
-              params(
-                metadata:
-                  FinchAPI::HRIS::PayStatement::EmployeeDeduction::Attributes::Metadata::OrHash
-              ).returns(T.attached_class)
+              params(metadata: T::Hash[Symbol, T.nilable(T.anything)]).returns(
+                T.attached_class
+              )
             end
-            def self.new(metadata:)
+            def self.new(
+              # 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.).
+              metadata:
+            )
             end
 
             sig do
               override.returns(
-                {
-                  metadata:
-                    FinchAPI::HRIS::PayStatement::EmployeeDeduction::Attributes::Metadata
-                }
+                { metadata: T::Hash[Symbol, T.nilable(T.anything)] }
               )
             end
             def to_hash
             end
-
-            class Metadata < FinchAPI::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    FinchAPI::HRIS::PayStatement::EmployeeDeduction::Attributes::Metadata,
-                    FinchAPI::Internal::AnyHash
-                  )
-                end
-
-              # 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::Hash[Symbol, T.nilable(T.anything)]) }
-              attr_accessor :metadata
-
-              sig do
-                params(
-                  metadata: T::Hash[Symbol, T.nilable(T.anything)]
-                ).returns(T.attached_class)
-              end
-              def self.new(
-                # 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.).
-                metadata:
-              )
-              end
-
-              sig do
-                override.returns(
-                  { metadata: T::Hash[Symbol, T.nilable(T.anything)] }
-                )
-              end
-              def to_hash
-              end
-            end
           end
         end
 
@@ -728,77 +613,32 @@ module FinchAPI
                 )
               end
 
-            sig do
-              returns(
-                FinchAPI::HRIS::PayStatement::EmployerContribution::Attributes::Metadata
-              )
-            end
-            attr_reader :metadata
-
-            sig do
-              params(
-                metadata:
-                  FinchAPI::HRIS::PayStatement::EmployerContribution::Attributes::Metadata::OrHash
-              ).void
-            end
-            attr_writer :metadata
+            # 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::Hash[Symbol, T.nilable(T.anything)]) }
+            attr_accessor :metadata
 
             sig do
-              params(
-                metadata:
-                  FinchAPI::HRIS::PayStatement::EmployerContribution::Attributes::Metadata::OrHash
-              ).returns(T.attached_class)
+              params(metadata: T::Hash[Symbol, T.nilable(T.anything)]).returns(
+                T.attached_class
+              )
             end
-            def self.new(metadata:)
+            def self.new(
+              # 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.).
+              metadata:
+            )
             end
 
             sig do
               override.returns(
-                {
-                  metadata:
-                    FinchAPI::HRIS::PayStatement::EmployerContribution::Attributes::Metadata
-                }
+                { metadata: T::Hash[Symbol, T.nilable(T.anything)] }
               )
             end
             def to_hash
             end
-
-            class Metadata < FinchAPI::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    FinchAPI::HRIS::PayStatement::EmployerContribution::Attributes::Metadata,
-                    FinchAPI::Internal::AnyHash
-                  )
-                end
-
-              # 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::Hash[Symbol, T.nilable(T.anything)]) }
-              attr_accessor :metadata
-
-              sig do
-                params(
-                  metadata: T::Hash[Symbol, T.nilable(T.anything)]
-                ).returns(T.attached_class)
-              end
-              def self.new(
-                # 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.).
-                metadata:
-              )
-              end
-
-              sig do
-                override.returns(
-                  { metadata: T::Hash[Symbol, T.nilable(T.anything)] }
-                )
-              end
-              def to_hash
-              end
-            end
           end
         end
 
@@ -980,75 +820,32 @@ module FinchAPI
                 )
               end
 
-            sig do
-              returns(FinchAPI::HRIS::PayStatement::Tax::Attributes::Metadata)
-            end
-            attr_reader :metadata
+            # 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::Hash[Symbol, T.nilable(T.anything)]) }
+            attr_accessor :metadata
 
             sig do
-              params(
-                metadata:
-                  FinchAPI::HRIS::PayStatement::Tax::Attributes::Metadata::OrHash
-              ).void
-            end
-            attr_writer :metadata
-
-            sig do
-              params(
-                metadata:
-                  FinchAPI::HRIS::PayStatement::Tax::Attributes::Metadata::OrHash
-              ).returns(T.attached_class)
+              params(metadata: T::Hash[Symbol, T.nilable(T.anything)]).returns(
+                T.attached_class
+              )
             end
-            def self.new(metadata:)
+            def self.new(
+              # 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.).
+              metadata:
+            )
             end
 
             sig do
               override.returns(
-                {
-                  metadata:
-                    FinchAPI::HRIS::PayStatement::Tax::Attributes::Metadata
-                }
+                { metadata: T::Hash[Symbol, T.nilable(T.anything)] }
               )
             end
             def to_hash
             end
-
-            class Metadata < FinchAPI::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    FinchAPI::HRIS::PayStatement::Tax::Attributes::Metadata,
-                    FinchAPI::Internal::AnyHash
-                  )
-                end
-
-              # 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::Hash[Symbol, T.nilable(T.anything)]) }
-              attr_accessor :metadata
-
-              sig do
-                params(
-                  metadata: T::Hash[Symbol, T.nilable(T.anything)]
-                ).returns(T.attached_class)
-              end
-              def self.new(
-                # 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.).
-                metadata:
-              )
-              end
-
-              sig do
-                override.returns(
-                  { metadata: T::Hash[Symbol, T.nilable(T.anything)] }
-                )
-              end
-              def to_hash
-              end
-            end
           end
         end