vitable-connect 0.4.0 → 0.6.0

data/rbi/vitable_connect/models/auth_issue_access_token_response.rbi

@@ -97,14 +97,20 @@ module VitableConnect
 
         # - `employer` - employer
         # - `employee` - employee
-        sig { returns(VitableConnect::Type::TaggedSymbol) }
+        sig do
+          returns(
+            VitableConnect::Models::AuthIssueAccessTokenResponse::BoundEntity::Type::TaggedSymbol
+          )
+        end
         attr_accessor :type
 
         # Entity the token is bound to, if any
         sig do
-          params(id: String, type: VitableConnect::Type::OrSymbol).returns(
-            T.attached_class
-          )
+          params(
+            id: String,
+            type:
+              VitableConnect::Models::AuthIssueAccessTokenResponse::BoundEntity::Type::OrSymbol
+          ).returns(T.attached_class)
         end
         def self.new(
           # Prefixed entity ID the token is bound to (empr*\* or empl*\*)
@@ -117,11 +123,51 @@ module VitableConnect
 
         sig do
           override.returns(
-            { id: String, type: VitableConnect::Type::TaggedSymbol }
+            {
+              id: String,
+              type:
+                VitableConnect::Models::AuthIssueAccessTokenResponse::BoundEntity::Type::TaggedSymbol
+            }
           )
         end
         def to_hash
         end
+
+        # - `employer` - employer
+        # - `employee` - employee
+        module Type
+          extend VitableConnect::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                VitableConnect::Models::AuthIssueAccessTokenResponse::BoundEntity::Type
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          EMPLOYER =
+            T.let(
+              :employer,
+              VitableConnect::Models::AuthIssueAccessTokenResponse::BoundEntity::Type::TaggedSymbol
+            )
+          EMPLOYEE =
+            T.let(
+              :employee,
+              VitableConnect::Models::AuthIssueAccessTokenResponse::BoundEntity::Type::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                VitableConnect::Models::AuthIssueAccessTokenResponse::BoundEntity::Type::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
       end
     end
   end

data/rbi/vitable_connect/models/employee.rbi

@@ -25,6 +25,15 @@ module VitableConnect
       sig { returns(String) }
       attr_accessor :email
 
+      # - `Full Time` - Full Time
+      # - `Part Time` - Part Time
+      # - `Temporary` - Temporary
+      # - `Intern` - Intern
+      # - `Seasonal` - Seasonal
+      # - `Individual Contractor` - Individual Contractor
+      sig { returns(VitableConnect::EmployeeClass::TaggedSymbol) }
+      attr_accessor :employee_class
+
       # Employee's legal first name
       sig { returns(String) }
       attr_accessor :first_name
@@ -48,27 +57,14 @@ module VitableConnect
       end
       attr_writer :address
 
-      # - `Full Time` - Full Time
-      # - `Part Time` - Part Time
-      # - `Temporary` - Temporary
-      # - `Intern` - Intern
-      # - `Seasonal` - Seasonal
-      # - `Individual Contractor` - Individual Contractor
-      sig { returns(T.nilable(VitableConnect::EmployeeClass::TaggedSymbol)) }
-      attr_accessor :employee_class
+      # Name of the employer this employment is with
+      sig { returns(T.nilable(String)) }
+      attr_accessor :employer_name
 
       # Gender identity, if provided
       sig { returns(T.nilable(String)) }
       attr_accessor :gender
 
-      # Employee's hire date with the employer
-      sig { returns(T.nilable(Date)) }
-      attr_accessor :hire_date
-
-      # Phone number (10-digit US domestic string)
-      sig { returns(T.nilable(String)) }
-      attr_accessor :phone
-
       # Partner-assigned reference ID for the employee
       sig { returns(T.nilable(String)) }
       attr_accessor :reference_id
@@ -85,31 +81,66 @@ module VitableConnect
       sig { returns(String) }
       attr_accessor :id
 
+      # Date the employee's current classification took effect
+      sig { returns(Date) }
+      attr_accessor :classification_effective_date
+
+      # - `Salary` - Salary
+      # - `Hourly` - Hourly
+      sig do
+        returns(
+          T.nilable(VitableConnect::Employee::CompensationType::TaggedSymbol)
+        )
+      end
+      attr_accessor :compensation_type
+
+      # Date the employee's current compensation type took effect
+      sig { returns(Date) }
+      attr_accessor :compensation_type_effective_date
+
+      # Unique identifier of the employer this employment is with (empr\_\*)
+      sig { returns(String) }
+      attr_accessor :employer_id
+
       # Unique member identifier with 'mbr\_' prefix
       sig { returns(String) }
       attr_accessor :member_id
 
+      # Phone number (10-digit US domestic string)
+      sig { returns(T.nilable(String)) }
+      attr_accessor :phone
+
+      # Employee's start date with the employer
+      sig { returns(Date) }
+      attr_accessor :start_date
+
       # Employee status (active or terminated)
-      sig { returns(String) }
+      sig { returns(VitableConnect::Employee::Status::TaggedSymbol) }
       attr_accessor :status
 
       sig do
         params(
           id: String,
+          classification_effective_date: Date,
+          compensation_type:
+            T.nilable(VitableConnect::Employee::CompensationType::OrSymbol),
+          compensation_type_effective_date: Date,
           created_at: Time,
           date_of_birth: Date,
           deductions: T::Array[VitableConnect::Employee::Deduction::OrHash],
           email: String,
+          employee_class: VitableConnect::EmployeeClass::OrSymbol,
+          employer_id: String,
           first_name: String,
           last_name: String,
           member_id: String,
-          status: String,
+          phone: T.nilable(String),
+          start_date: Date,
+          status: VitableConnect::Employee::Status::OrSymbol,
           updated_at: Time,
           address: T.nilable(VitableConnect::Employee::Address::OrHash),
-          employee_class: T.nilable(VitableConnect::EmployeeClass::OrSymbol),
+          employer_name: T.nilable(String),
           gender: T.nilable(String),
-          hire_date: T.nilable(Date),
-          phone: T.nilable(String),
           reference_id: T.nilable(String),
           suffix: T.nilable(String),
           termination_date: T.nilable(Date)
@@ -118,6 +149,13 @@ module VitableConnect
       def self.new(
         # Unique employee identifier with 'empl\_' prefix
         id:,
+        # Date the employee's current classification took effect
+        classification_effective_date:,
+        # - `Salary` - Salary
+        # - `Hourly` - Hourly
+        compensation_type:,
+        # Date the employee's current compensation type took effect
+        compensation_type_effective_date:,
         # Timestamp when the employee was created
         created_at:,
         # Date of birth (YYYY-MM-DD)
@@ -127,31 +165,35 @@ module VitableConnect
         deductions:,
         # Email address
         email:,
+        # - `Full Time` - Full Time
+        # - `Part Time` - Part Time
+        # - `Temporary` - Temporary
+        # - `Intern` - Intern
+        # - `Seasonal` - Seasonal
+        # - `Individual Contractor` - Individual Contractor
+        employee_class:,
+        # Unique identifier of the employer this employment is with (empr\_\*)
+        employer_id:,
         # Employee's legal first name
         first_name:,
         # Employee's legal last name
         last_name:,
         # Unique member identifier with 'mbr\_' prefix
         member_id:,
+        # Phone number (10-digit US domestic string)
+        phone:,
+        # Employee's start date with the employer
+        start_date:,
         # Employee status (active or terminated)
         status:,
         # Timestamp when the employee was last updated
         updated_at:,
         # Employee's residential address
         address: nil,
-        # - `Full Time` - Full Time
-        # - `Part Time` - Part Time
-        # - `Temporary` - Temporary
-        # - `Intern` - Intern
-        # - `Seasonal` - Seasonal
-        # - `Individual Contractor` - Individual Contractor
-        employee_class: nil,
+        # Name of the employer this employment is with
+        employer_name: nil,
         # Gender identity, if provided
         gender: nil,
-        # Employee's hire date with the employer
-        hire_date: nil,
-        # Phone number (10-digit US domestic string)
-        phone: nil,
         # Partner-assigned reference ID for the employee
         reference_id: nil,
         # Name suffix (e.g., Jr., Sr., III)
@@ -165,21 +207,28 @@ module VitableConnect
         override.returns(
           {
             id: String,
+            classification_effective_date: Date,
+            compensation_type:
+              T.nilable(
+                VitableConnect::Employee::CompensationType::TaggedSymbol
+              ),
+            compensation_type_effective_date: Date,
             created_at: Time,
             date_of_birth: Date,
             deductions: T::Array[VitableConnect::Employee::Deduction],
             email: String,
+            employee_class: VitableConnect::EmployeeClass::TaggedSymbol,
+            employer_id: String,
             first_name: String,
             last_name: String,
             member_id: String,
-            status: String,
+            phone: T.nilable(String),
+            start_date: Date,
+            status: VitableConnect::Employee::Status::TaggedSymbol,
             updated_at: Time,
             address: T.nilable(VitableConnect::Employee::Address),
-            employee_class:
-              T.nilable(VitableConnect::EmployeeClass::TaggedSymbol),
+            employer_name: T.nilable(String),
             gender: T.nilable(String),
-            hire_date: T.nilable(Date),
-            phone: T.nilable(String),
             reference_id: T.nilable(String),
             suffix: T.nilable(String),
             termination_date: T.nilable(Date)
@@ -189,6 +238,37 @@ module VitableConnect
       def to_hash
       end
 
+      # - `Salary` - Salary
+      # - `Hourly` - Hourly
+      module CompensationType
+        extend VitableConnect::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, VitableConnect::Employee::CompensationType)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        SALARY =
+          T.let(
+            :Salary,
+            VitableConnect::Employee::CompensationType::TaggedSymbol
+          )
+        HOURLY =
+          T.let(
+            :Hourly,
+            VitableConnect::Employee::CompensationType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[VitableConnect::Employee::CompensationType::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
       class Deduction < VitableConnect::Internal::Type::BaseModel
         OrHash =
           T.type_alias do
@@ -378,6 +458,27 @@ module VitableConnect
         end
       end
 
+      # Employee status (active or terminated)
+      module Status
+        extend VitableConnect::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, VitableConnect::Employee::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ACTIVE = T.let(:active, VitableConnect::Employee::Status::TaggedSymbol)
+        TERMINATED =
+          T.let(:terminated, VitableConnect::Employee::Status::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[VitableConnect::Employee::Status::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
       class Address < VitableConnect::Internal::Type::BaseModel
         OrHash =
           T.type_alias do

data/rbi/vitable_connect/models/employee_update_params.rbi

@@ -0,0 +1,323 @@
+# typed: strong
+
+module VitableConnect
+  module Models
+    class EmployeeUpdateParams < VitableConnect::Internal::Type::BaseModel
+      extend VitableConnect::Internal::Type::RequestParameters::Converter
+      include VitableConnect::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            VitableConnect::EmployeeUpdateParams,
+            VitableConnect::Internal::AnyHash
+          )
+        end
+
+      # Unique employee identifier (empl\_\*)
+      sig { returns(String) }
+      attr_accessor :employee_id
+
+      # Past or present date applied to each tracked employment field included in this
+      # request
+      sig { returns(Date) }
+      attr_accessor :effective_date
+
+      # Employee's residential address
+      sig { returns(T.nilable(VitableConnect::EmployeeUpdateParams::Address)) }
+      attr_reader :address
+
+      sig do
+        params(
+          address:
+            T.nilable(VitableConnect::EmployeeUpdateParams::Address::OrHash)
+        ).void
+      end
+      attr_writer :address
+
+      # - `Salary` - Salary
+      # - `Hourly` - Hourly
+      sig do
+        returns(
+          T.nilable(
+            VitableConnect::EmployeeUpdateParams::CompensationType::OrSymbol
+          )
+        )
+      end
+      attr_accessor :compensation_type
+
+      # Email address
+      sig { returns(T.nilable(String)) }
+      attr_accessor :email
+
+      # - `Full Time` - Full Time
+      # - `Part Time` - Part Time
+      # - `Temporary` - Temporary
+      # - `Intern` - Intern
+      # - `Seasonal` - Seasonal
+      # - `Individual Contractor` - Individual Contractor
+      sig { returns(T.nilable(VitableConnect::EmployeeClass::OrSymbol)) }
+      attr_accessor :employee_class
+
+      # - `Male` - Male
+      # - `Female` - Female
+      # - `Transgender` - Transgender
+      # - `Non-binary` - Non-binary
+      # - `Prefer not to respond` - Prefer not to respond
+      sig do
+        returns(
+          T.nilable(VitableConnect::EmployeeUpdateParams::Gender::OrSymbol)
+        )
+      end
+      attr_accessor :gender
+
+      # Phone number
+      sig { returns(T.nilable(String)) }
+      attr_accessor :phone
+
+      # Employment start date
+      sig { returns(T.nilable(Date)) }
+      attr_accessor :start_date
+
+      sig do
+        params(
+          employee_id: String,
+          effective_date: Date,
+          address:
+            T.nilable(VitableConnect::EmployeeUpdateParams::Address::OrHash),
+          compensation_type:
+            T.nilable(
+              VitableConnect::EmployeeUpdateParams::CompensationType::OrSymbol
+            ),
+          email: T.nilable(String),
+          employee_class: T.nilable(VitableConnect::EmployeeClass::OrSymbol),
+          gender:
+            T.nilable(VitableConnect::EmployeeUpdateParams::Gender::OrSymbol),
+          phone: T.nilable(String),
+          start_date: T.nilable(Date),
+          request_options: VitableConnect::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique employee identifier (empl\_\*)
+        employee_id:,
+        # Past or present date applied to each tracked employment field included in this
+        # request
+        effective_date:,
+        # Employee's residential address
+        address: nil,
+        # - `Salary` - Salary
+        # - `Hourly` - Hourly
+        compensation_type: nil,
+        # Email address
+        email: nil,
+        # - `Full Time` - Full Time
+        # - `Part Time` - Part Time
+        # - `Temporary` - Temporary
+        # - `Intern` - Intern
+        # - `Seasonal` - Seasonal
+        # - `Individual Contractor` - Individual Contractor
+        employee_class: nil,
+        # - `Male` - Male
+        # - `Female` - Female
+        # - `Transgender` - Transgender
+        # - `Non-binary` - Non-binary
+        # - `Prefer not to respond` - Prefer not to respond
+        gender: nil,
+        # Phone number
+        phone: nil,
+        # Employment start date
+        start_date: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            employee_id: String,
+            effective_date: Date,
+            address: T.nilable(VitableConnect::EmployeeUpdateParams::Address),
+            compensation_type:
+              T.nilable(
+                VitableConnect::EmployeeUpdateParams::CompensationType::OrSymbol
+              ),
+            email: T.nilable(String),
+            employee_class: T.nilable(VitableConnect::EmployeeClass::OrSymbol),
+            gender:
+              T.nilable(VitableConnect::EmployeeUpdateParams::Gender::OrSymbol),
+            phone: T.nilable(String),
+            start_date: T.nilable(Date),
+            request_options: VitableConnect::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Address < VitableConnect::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              VitableConnect::EmployeeUpdateParams::Address,
+              VitableConnect::Internal::AnyHash
+            )
+          end
+
+        # City name
+        sig { returns(String) }
+        attr_accessor :city
+
+        # Two-letter state code
+        sig { returns(String) }
+        attr_accessor :state
+
+        # Primary street address
+        sig { returns(String) }
+        attr_accessor :street_1
+
+        # ZIP code
+        sig { returns(String) }
+        attr_accessor :zip_code
+
+        # Country code
+        sig { returns(T.nilable(String)) }
+        attr_reader :country
+
+        sig { params(country: String).void }
+        attr_writer :country
+
+        # Secondary street address
+        sig { returns(T.nilable(String)) }
+        attr_accessor :street_2
+
+        # Employee's residential address
+        sig do
+          params(
+            city: String,
+            state: String,
+            street_1: String,
+            zip_code: String,
+            country: String,
+            street_2: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # City name
+          city:,
+          # Two-letter state code
+          state:,
+          # Primary street address
+          street_1:,
+          # ZIP code
+          zip_code:,
+          # Country code
+          country: nil,
+          # Secondary street address
+          street_2: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              city: String,
+              state: String,
+              street_1: String,
+              zip_code: String,
+              country: String,
+              street_2: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      # - `Salary` - Salary
+      # - `Hourly` - Hourly
+      module CompensationType
+        extend VitableConnect::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(
+              Symbol,
+              VitableConnect::EmployeeUpdateParams::CompensationType
+            )
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        SALARY =
+          T.let(
+            :Salary,
+            VitableConnect::EmployeeUpdateParams::CompensationType::TaggedSymbol
+          )
+        HOURLY =
+          T.let(
+            :Hourly,
+            VitableConnect::EmployeeUpdateParams::CompensationType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              VitableConnect::EmployeeUpdateParams::CompensationType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # - `Male` - Male
+      # - `Female` - Female
+      # - `Transgender` - Transgender
+      # - `Non-binary` - Non-binary
+      # - `Prefer not to respond` - Prefer not to respond
+      module Gender
+        extend VitableConnect::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, VitableConnect::EmployeeUpdateParams::Gender)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        MALE =
+          T.let(
+            :Male,
+            VitableConnect::EmployeeUpdateParams::Gender::TaggedSymbol
+          )
+        FEMALE =
+          T.let(
+            :Female,
+            VitableConnect::EmployeeUpdateParams::Gender::TaggedSymbol
+          )
+        TRANSGENDER =
+          T.let(
+            :Transgender,
+            VitableConnect::EmployeeUpdateParams::Gender::TaggedSymbol
+          )
+        NON_BINARY =
+          T.let(
+            :"Non-binary",
+            VitableConnect::EmployeeUpdateParams::Gender::TaggedSymbol
+          )
+        PREFER_NOT_TO_RESPOND =
+          T.let(
+            :"Prefer not to respond",
+            VitableConnect::EmployeeUpdateParams::Gender::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[VitableConnect::EmployeeUpdateParams::Gender::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/vitable_connect/models/employee_update_response.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module VitableConnect
+  module Models
+    class EmployeeUpdateResponse < VitableConnect::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            VitableConnect::Models::EmployeeUpdateResponse,
+            VitableConnect::Internal::AnyHash
+          )
+        end
+
+      sig { returns(VitableConnect::Employee) }
+      attr_reader :data
+
+      sig { params(data: VitableConnect::Employee::OrHash).void }
+      attr_writer :data
+
+      # Response containing a single employee resource.
+      sig do
+        params(data: VitableConnect::Employee::OrHash).returns(T.attached_class)
+      end
+      def self.new(data:)
+      end
+
+      sig { override.returns({ data: VitableConnect::Employee }) }
+      def to_hash
+      end
+    end
+  end
+end