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

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

@@ -4,135 +4,86 @@ module FinchAPI
   module Models
     module HRIS
       class Individual < FinchAPI::BaseModel
+        # A stable Finch `id` (UUID v4) for an individual in the company.
         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(String)) }
-        def dob
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def dob=(_)
-        end
+        attr_accessor :dob
 
         sig { returns(T.nilable(T::Array[FinchAPI::Models::HRIS::Individual::Email])) }
-        def emails
-        end
-
-        sig do
-          params(_: T.nilable(T::Array[FinchAPI::Models::HRIS::Individual::Email]))
-            .returns(T.nilable(T::Array[FinchAPI::Models::HRIS::Individual::Email]))
-        end
-        def emails=(_)
-        end
+        attr_accessor :emails
 
+        # Social Security Number of the individual in **encrypted** format. This field is
+        #   only available with the `ssn` scope enabled and the
+        #   `options: { include: ['ssn'] }` param set in the body.
         sig { returns(T.nilable(String)) }
-        def encrypted_ssn
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def encrypted_ssn=(_)
-        end
-
-        sig { returns(T.nilable(Symbol)) }
-        def ethnicity
-        end
+        attr_accessor :encrypted_ssn
 
-        sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-        def ethnicity=(_)
-        end
+        # The EEOC-defined ethnicity of the individual.
+        sig { returns(T.nilable(FinchAPI::Models::HRIS::Individual::Ethnicity::TaggedSymbol)) }
+        attr_accessor :ethnicity
 
+        # The legal first name of the individual.
         sig { returns(T.nilable(String)) }
-        def first_name
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def first_name=(_)
-        end
-
-        sig { returns(T.nilable(Symbol)) }
-        def gender
-        end
+        attr_accessor :first_name
 
-        sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-        def gender=(_)
-        end
+        # The gender of the individual.
+        sig { returns(T.nilable(FinchAPI::Models::HRIS::Individual::Gender::TaggedSymbol)) }
+        attr_accessor :gender
 
+        # The legal last name of the individual.
         sig { returns(T.nilable(String)) }
-        def last_name
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def last_name=(_)
-        end
+        attr_accessor :last_name
 
+        # The legal middle name of the individual.
         sig { returns(T.nilable(String)) }
-        def middle_name
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def middle_name=(_)
-        end
+        attr_accessor :middle_name
 
         sig { returns(T.nilable(T::Array[T.nilable(FinchAPI::Models::HRIS::Individual::PhoneNumber)])) }
-        def phone_numbers
-        end
-
-        sig do
-          params(_: T.nilable(T::Array[T.nilable(FinchAPI::Models::HRIS::Individual::PhoneNumber)]))
-            .returns(T.nilable(T::Array[T.nilable(FinchAPI::Models::HRIS::Individual::PhoneNumber)]))
-        end
-        def phone_numbers=(_)
-        end
+        attr_accessor :phone_numbers
 
+        # The preferred name of the individual.
         sig { returns(T.nilable(String)) }
-        def preferred_name
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def preferred_name=(_)
-        end
+        attr_accessor :preferred_name
 
         sig { returns(T.nilable(FinchAPI::Models::Location)) }
-        def residence
-        end
+        attr_reader :residence
 
-        sig { params(_: T.nilable(FinchAPI::Models::Location)).returns(T.nilable(FinchAPI::Models::Location)) }
-        def residence=(_)
-        end
+        sig { params(residence: T.nilable(T.any(FinchAPI::Models::Location, FinchAPI::Util::AnyHash))).void }
+        attr_writer :residence
 
+        # Social Security Number of the individual. This field is only available with the
+        #   `ssn` scope enabled and the `options: { include: ['ssn'] }` param set in the
+        #   body.
+        #   [Click here to learn more about enabling the SSN field](/developer-resources/Enable-SSN-Field).
         sig { returns(T.nilable(String)) }
-        def ssn
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def ssn=(_)
-        end
+        attr_accessor :ssn
 
         sig do
           params(
             id: String,
             dob: T.nilable(String),
-            emails: T.nilable(T::Array[FinchAPI::Models::HRIS::Individual::Email]),
+            emails: T.nilable(T::Array[T.any(FinchAPI::Models::HRIS::Individual::Email, FinchAPI::Util::AnyHash)]),
             encrypted_ssn: T.nilable(String),
-            ethnicity: T.nilable(Symbol),
+            ethnicity: T.nilable(FinchAPI::Models::HRIS::Individual::Ethnicity::OrSymbol),
             first_name: T.nilable(String),
-            gender: T.nilable(Symbol),
+            gender: T.nilable(FinchAPI::Models::HRIS::Individual::Gender::OrSymbol),
             last_name: T.nilable(String),
             middle_name: T.nilable(String),
-            phone_numbers: T.nilable(T::Array[T.nilable(FinchAPI::Models::HRIS::Individual::PhoneNumber)]),
+            phone_numbers: T.nilable(
+              T::Array[T.nilable(T.any(FinchAPI::Models::HRIS::Individual::PhoneNumber, FinchAPI::Util::AnyHash))]
+            ),
             preferred_name: T.nilable(String),
-            residence: T.nilable(FinchAPI::Models::Location),
+            residence: T.nilable(T.any(FinchAPI::Models::Location, FinchAPI::Util::AnyHash)),
             ssn: T.nilable(String)
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(
+        def self.new(
           id: nil,
           dob: nil,
           emails: nil,
@@ -157,9 +108,9 @@ module FinchAPI
                 dob: T.nilable(String),
                 emails: T.nilable(T::Array[FinchAPI::Models::HRIS::Individual::Email]),
                 encrypted_ssn: T.nilable(String),
-                ethnicity: T.nilable(Symbol),
+                ethnicity: T.nilable(FinchAPI::Models::HRIS::Individual::Ethnicity::TaggedSymbol),
                 first_name: T.nilable(String),
-                gender: T.nilable(Symbol),
+                gender: T.nilable(FinchAPI::Models::HRIS::Individual::Gender::TaggedSymbol),
                 last_name: T.nilable(String),
                 middle_name: T.nilable(String),
                 phone_numbers: T.nilable(T::Array[T.nilable(FinchAPI::Models::HRIS::Individual::PhoneNumber)]),
@@ -174,103 +125,127 @@ module FinchAPI
 
         class Email < FinchAPI::BaseModel
           sig { returns(T.nilable(String)) }
-          def data
-          end
+          attr_reader :data
 
-          sig { params(_: String).returns(String) }
-          def data=(_)
-          end
+          sig { params(data: String).void }
+          attr_writer :data
 
-          sig { returns(T.nilable(Symbol)) }
-          def type
-          end
+          sig { returns(T.nilable(FinchAPI::Models::HRIS::Individual::Email::Type::TaggedSymbol)) }
+          attr_accessor :type
 
-          sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-          def type=(_)
+          sig do
+            params(data: String, type: T.nilable(FinchAPI::Models::HRIS::Individual::Email::Type::OrSymbol))
+              .returns(T.attached_class)
           end
-
-          sig { params(data: String, type: T.nilable(Symbol)).void }
-          def initialize(data: nil, type: nil)
+          def self.new(data: nil, type: nil)
           end
 
-          sig { override.returns({data: String, type: T.nilable(Symbol)}) }
+          sig do
+            override
+              .returns({data: String, type: T.nilable(FinchAPI::Models::HRIS::Individual::Email::Type::TaggedSymbol)})
+          end
           def to_hash
           end
 
-          class Type < FinchAPI::Enum
-            abstract!
+          module Type
+            extend FinchAPI::Enum
 
-            WORK = T.let(:work, T.nilable(Symbol))
-            PERSONAL = T.let(:personal, T.nilable(Symbol))
+            TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::Individual::Email::Type) }
+            OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::HRIS::Individual::Email::Type::TaggedSymbol) }
 
-            sig { override.returns(T::Array[Symbol]) }
+            WORK = T.let(:work, FinchAPI::Models::HRIS::Individual::Email::Type::TaggedSymbol)
+            PERSONAL = T.let(:personal, FinchAPI::Models::HRIS::Individual::Email::Type::TaggedSymbol)
+
+            sig { override.returns(T::Array[FinchAPI::Models::HRIS::Individual::Email::Type::TaggedSymbol]) }
             def self.values
             end
           end
         end
 
-        class Ethnicity < FinchAPI::Enum
-          abstract!
-
-          ASIAN = T.let(:asian, T.nilable(Symbol))
-          WHITE = T.let(:white, T.nilable(Symbol))
-          BLACK_OR_AFRICAN_AMERICAN = T.let(:black_or_african_american, T.nilable(Symbol))
-          NATIVE_HAWAIIAN_OR_PACIFIC_ISLANDER = T.let(:native_hawaiian_or_pacific_islander, T.nilable(Symbol))
-          AMERICAN_INDIAN_OR_ALASKA_NATIVE = T.let(:american_indian_or_alaska_native, T.nilable(Symbol))
-          HISPANIC_OR_LATINO = T.let(:hispanic_or_latino, T.nilable(Symbol))
-          TWO_OR_MORE_RACES = T.let(:two_or_more_races, T.nilable(Symbol))
-          DECLINE_TO_SPECIFY = T.let(:decline_to_specify, T.nilable(Symbol))
-
-          sig { override.returns(T::Array[Symbol]) }
+        # The EEOC-defined ethnicity of the individual.
+        module Ethnicity
+          extend FinchAPI::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::Individual::Ethnicity) }
+          OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::HRIS::Individual::Ethnicity::TaggedSymbol) }
+
+          ASIAN = T.let(:asian, FinchAPI::Models::HRIS::Individual::Ethnicity::TaggedSymbol)
+          WHITE = T.let(:white, FinchAPI::Models::HRIS::Individual::Ethnicity::TaggedSymbol)
+          BLACK_OR_AFRICAN_AMERICAN =
+            T.let(:black_or_african_american, FinchAPI::Models::HRIS::Individual::Ethnicity::TaggedSymbol)
+          NATIVE_HAWAIIAN_OR_PACIFIC_ISLANDER =
+            T.let(:native_hawaiian_or_pacific_islander, FinchAPI::Models::HRIS::Individual::Ethnicity::TaggedSymbol)
+          AMERICAN_INDIAN_OR_ALASKA_NATIVE =
+            T.let(:american_indian_or_alaska_native, FinchAPI::Models::HRIS::Individual::Ethnicity::TaggedSymbol)
+          HISPANIC_OR_LATINO =
+            T.let(:hispanic_or_latino, FinchAPI::Models::HRIS::Individual::Ethnicity::TaggedSymbol)
+          TWO_OR_MORE_RACES =
+            T.let(:two_or_more_races, FinchAPI::Models::HRIS::Individual::Ethnicity::TaggedSymbol)
+          DECLINE_TO_SPECIFY =
+            T.let(:decline_to_specify, FinchAPI::Models::HRIS::Individual::Ethnicity::TaggedSymbol)
+
+          sig { override.returns(T::Array[FinchAPI::Models::HRIS::Individual::Ethnicity::TaggedSymbol]) }
           def self.values
           end
         end
 
-        class Gender < FinchAPI::Enum
-          abstract!
+        # The gender of the individual.
+        module Gender
+          extend FinchAPI::Enum
 
-          FEMALE = T.let(:female, T.nilable(Symbol))
-          MALE = T.let(:male, T.nilable(Symbol))
-          OTHER = T.let(:other, T.nilable(Symbol))
-          DECLINE_TO_SPECIFY = T.let(:decline_to_specify, T.nilable(Symbol))
+          TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::Individual::Gender) }
+          OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::HRIS::Individual::Gender::TaggedSymbol) }
 
-          sig { override.returns(T::Array[Symbol]) }
+          FEMALE = T.let(:female, FinchAPI::Models::HRIS::Individual::Gender::TaggedSymbol)
+          MALE = T.let(:male, FinchAPI::Models::HRIS::Individual::Gender::TaggedSymbol)
+          OTHER = T.let(:other, FinchAPI::Models::HRIS::Individual::Gender::TaggedSymbol)
+          DECLINE_TO_SPECIFY = T.let(:decline_to_specify, FinchAPI::Models::HRIS::Individual::Gender::TaggedSymbol)
+
+          sig { override.returns(T::Array[FinchAPI::Models::HRIS::Individual::Gender::TaggedSymbol]) }
           def self.values
           end
         end
 
         class PhoneNumber < FinchAPI::BaseModel
           sig { returns(T.nilable(String)) }
-          def data
-          end
+          attr_accessor :data
 
-          sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-          def data=(_)
-          end
+          sig { returns(T.nilable(FinchAPI::Models::HRIS::Individual::PhoneNumber::Type::TaggedSymbol)) }
+          attr_accessor :type
 
-          sig { returns(T.nilable(Symbol)) }
-          def type
+          sig do
+            params(
+              data: T.nilable(String),
+              type: T.nilable(FinchAPI::Models::HRIS::Individual::PhoneNumber::Type::OrSymbol)
+            )
+              .returns(T.attached_class)
           end
-
-          sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-          def type=(_)
+          def self.new(data: nil, type: nil)
           end
 
-          sig { params(data: T.nilable(String), type: T.nilable(Symbol)).void }
-          def initialize(data: nil, type: nil)
+          sig do
+            override
+              .returns(
+                {
+                  data: T.nilable(String),
+                  type: T.nilable(FinchAPI::Models::HRIS::Individual::PhoneNumber::Type::TaggedSymbol)
+                }
+              )
           end
-
-          sig { override.returns({data: T.nilable(String), type: T.nilable(Symbol)}) }
           def to_hash
           end
 
-          class Type < FinchAPI::Enum
-            abstract!
+          module Type
+            extend FinchAPI::Enum
+
+            TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::Individual::PhoneNumber::Type) }
+            OrSymbol =
+              T.type_alias { T.any(Symbol, FinchAPI::Models::HRIS::Individual::PhoneNumber::Type::TaggedSymbol) }
 
-            WORK = T.let(:work, T.nilable(Symbol))
-            PERSONAL = T.let(:personal, T.nilable(Symbol))
+            WORK = T.let(:work, FinchAPI::Models::HRIS::Individual::PhoneNumber::Type::TaggedSymbol)
+            PERSONAL = T.let(:personal, FinchAPI::Models::HRIS::Individual::PhoneNumber::Type::TaggedSymbol)
 
-            sig { override.returns(T::Array[Symbol]) }
+            sig { override.returns(T::Array[FinchAPI::Models::HRIS::Individual::PhoneNumber::Type::TaggedSymbol]) }
             def self.values
             end
           end

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

@@ -4,89 +4,66 @@ module FinchAPI
   module Models
     module HRIS
       class IndividualInDirectory < FinchAPI::BaseModel
+        # A stable Finch id (UUID v4) for an individual in the company.
         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
 
+        # The department object.
         sig { returns(T.nilable(FinchAPI::Models::HRIS::IndividualInDirectory::Department)) }
-        def department
-        end
+        attr_reader :department
 
         sig do
-          params(_: T.nilable(FinchAPI::Models::HRIS::IndividualInDirectory::Department))
-            .returns(T.nilable(FinchAPI::Models::HRIS::IndividualInDirectory::Department))
-        end
-        def department=(_)
+          params(
+            department: T.nilable(T.any(FinchAPI::Models::HRIS::IndividualInDirectory::Department, FinchAPI::Util::AnyHash))
+          )
+            .void
         end
+        attr_writer :department
 
+        # The legal first name of the individual.
         sig { returns(T.nilable(String)) }
-        def first_name
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def first_name=(_)
-        end
+        attr_accessor :first_name
 
+        # `true` if the individual is an active employee or contractor at the company.
         sig { returns(T.nilable(T::Boolean)) }
-        def is_active
-        end
-
-        sig { params(_: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
-        def is_active=(_)
-        end
+        attr_accessor :is_active
 
+        # The legal last name of the individual.
         sig { returns(T.nilable(String)) }
-        def last_name
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def last_name=(_)
-        end
+        attr_accessor :last_name
 
+        # The manager object.
         sig { returns(T.nilable(FinchAPI::Models::HRIS::IndividualInDirectory::Manager)) }
-        def manager
-        end
+        attr_reader :manager
 
         sig do
-          params(_: T.nilable(FinchAPI::Models::HRIS::IndividualInDirectory::Manager))
-            .returns(T.nilable(FinchAPI::Models::HRIS::IndividualInDirectory::Manager))
-        end
-        def manager=(_)
+          params(
+            manager: T.nilable(T.any(FinchAPI::Models::HRIS::IndividualInDirectory::Manager, FinchAPI::Util::AnyHash))
+          )
+            .void
         end
+        attr_writer :manager
 
+        # The legal middle name of the individual.
         sig { returns(T.nilable(String)) }
-        def middle_name
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def middle_name=(_)
-        end
+        attr_accessor :middle_name
 
         sig do
           params(
             id: String,
-            department: T.nilable(FinchAPI::Models::HRIS::IndividualInDirectory::Department),
+            department: T.nilable(T.any(FinchAPI::Models::HRIS::IndividualInDirectory::Department, FinchAPI::Util::AnyHash)),
             first_name: T.nilable(String),
             is_active: T.nilable(T::Boolean),
             last_name: T.nilable(String),
-            manager: T.nilable(FinchAPI::Models::HRIS::IndividualInDirectory::Manager),
+            manager: T.nilable(T.any(FinchAPI::Models::HRIS::IndividualInDirectory::Manager, FinchAPI::Util::AnyHash)),
             middle_name: T.nilable(String)
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(
-          id: nil,
-          department: nil,
-          first_name: nil,
-          is_active: nil,
-          last_name: nil,
-          manager: nil,
-          middle_name: nil
-        )
+        def self.new(id: nil, department: nil, first_name: nil, is_active: nil, last_name: nil, manager: nil, middle_name: nil)
         end
 
         sig do
@@ -107,16 +84,13 @@ module FinchAPI
         end
 
         class Department < FinchAPI::BaseModel
+          # The name of the department.
           sig { returns(T.nilable(String)) }
-          def name
-          end
-
-          sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-          def name=(_)
-          end
+          attr_accessor :name
 
-          sig { params(name: T.nilable(String)).void }
-          def initialize(name: nil)
+          # The department object.
+          sig { params(name: T.nilable(String)).returns(T.attached_class) }
+          def self.new(name: nil)
           end
 
           sig { override.returns({name: T.nilable(String)}) }
@@ -125,16 +99,16 @@ module FinchAPI
         end
 
         class Manager < FinchAPI::BaseModel
+          # A stable Finch `id` (UUID v4) for an individual in the company.
           sig { returns(T.nilable(String)) }
-          def id
-          end
-
-          sig { params(_: String).returns(String) }
-          def id=(_)
-          end
+          attr_reader :id
 
           sig { params(id: String).void }
-          def initialize(id: nil)
+          attr_writer :id
+
+          # The manager object.
+          sig { params(id: String).returns(T.attached_class) }
+          def self.new(id: nil)
           end
 
           sig { override.returns({id: String}) }

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

@@ -5,31 +5,32 @@ module FinchAPI
     module HRIS
       class IndividualResponse < FinchAPI::BaseModel
         sig { returns(T.nilable(FinchAPI::Models::HRIS::Individual)) }
-        def body
-        end
+        attr_reader :body
 
-        sig { params(_: FinchAPI::Models::HRIS::Individual).returns(FinchAPI::Models::HRIS::Individual) }
-        def body=(_)
-        end
+        sig { params(body: T.any(FinchAPI::Models::HRIS::Individual, 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 individual_id
-        end
+        attr_reader :individual_id
 
-        sig { params(_: String).returns(String) }
-        def individual_id=(_)
-        end
+        sig { params(individual_id: String).void }
+        attr_writer :individual_id
 
-        sig { params(body: FinchAPI::Models::HRIS::Individual, code: Integer, individual_id: String).void }
-        def initialize(body: nil, code: nil, individual_id: nil)
+        sig do
+          params(
+            body: T.any(FinchAPI::Models::HRIS::Individual, FinchAPI::Util::AnyHash),
+            code: Integer,
+            individual_id: String
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(body: nil, code: nil, individual_id: nil)
         end
 
         sig { override.returns({body: FinchAPI::Models::HRIS::Individual, code: Integer, individual_id: String}) }