vitable-connect 0.1.0

data/rbi/vitable_connect/models/auth_issue_access_token_response.rbi

@@ -0,0 +1,128 @@
+# typed: strong
+
+module VitableConnect
+  module Models
+    class AuthIssueAccessTokenResponse < VitableConnect::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            VitableConnect::Models::AuthIssueAccessTokenResponse,
+            VitableConnect::Internal::AnyHash
+          )
+        end
+
+      # The issued access token (vit*at*\*)
+      sig { returns(String) }
+      attr_accessor :access_token
+
+      # Token lifetime in seconds
+      sig { returns(Integer) }
+      attr_accessor :expires_in
+
+      # Token type, always 'Bearer'
+      sig { returns(String) }
+      attr_accessor :token_type
+
+      # Entity the token is bound to, if any
+      sig do
+        returns(
+          T.nilable(
+            VitableConnect::Models::AuthIssueAccessTokenResponse::BoundEntity
+          )
+        )
+      end
+      attr_reader :bound_entity
+
+      sig do
+        params(
+          bound_entity:
+            T.nilable(
+              VitableConnect::Models::AuthIssueAccessTokenResponse::BoundEntity::OrHash
+            )
+        ).void
+      end
+      attr_writer :bound_entity
+
+      sig do
+        params(
+          access_token: String,
+          expires_in: Integer,
+          token_type: String,
+          bound_entity:
+            T.nilable(
+              VitableConnect::Models::AuthIssueAccessTokenResponse::BoundEntity::OrHash
+            )
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The issued access token (vit*at*\*)
+        access_token:,
+        # Token lifetime in seconds
+        expires_in:,
+        # Token type, always 'Bearer'
+        token_type:,
+        # Entity the token is bound to, if any
+        bound_entity: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            access_token: String,
+            expires_in: Integer,
+            token_type: String,
+            bound_entity:
+              T.nilable(
+                VitableConnect::Models::AuthIssueAccessTokenResponse::BoundEntity
+              )
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class BoundEntity < VitableConnect::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              VitableConnect::Models::AuthIssueAccessTokenResponse::BoundEntity,
+              VitableConnect::Internal::AnyHash
+            )
+          end
+
+        # Prefixed entity ID the token is bound to (empr*\* or empl*\*)
+        sig { returns(String) }
+        attr_accessor :id
+
+        # - `employer` - employer
+        # - `employee` - employee
+        sig { returns(VitableConnect::Type::TaggedSymbol) }
+        attr_accessor :type
+
+        # Entity the token is bound to, if any
+        sig do
+          params(id: String, type: VitableConnect::Type::OrSymbol).returns(
+            T.attached_class
+          )
+        end
+        def self.new(
+          # Prefixed entity ID the token is bound to (empr*\* or empl*\*)
+          id:,
+          # - `employer` - employer
+          # - `employee` - employee
+          type:
+        )
+        end
+
+        sig do
+          override.returns(
+            { id: String, type: VitableConnect::Type::TaggedSymbol }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/vitable_connect/models/benefit_eligibility_policy.rbi

@@ -0,0 +1,74 @@
+# typed: strong
+
+module VitableConnect
+  module Models
+    class BenefitEligibilityPolicy < VitableConnect::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            VitableConnect::BenefitEligibilityPolicy,
+            VitableConnect::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T::Boolean) }
+      attr_accessor :active
+
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      sig { returns(Time) }
+      attr_accessor :updated_at
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(String) }
+      attr_accessor :classification
+
+      sig { returns(String) }
+      attr_accessor :employer_id
+
+      sig { returns(String) }
+      attr_accessor :waiting_period
+
+      sig do
+        params(
+          id: String,
+          active: T::Boolean,
+          classification: String,
+          created_at: Time,
+          employer_id: String,
+          updated_at: Time,
+          waiting_period: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        active:,
+        classification:,
+        created_at:,
+        employer_id:,
+        updated_at:,
+        waiting_period:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            active: T::Boolean,
+            classification: String,
+            created_at: Time,
+            employer_id: String,
+            updated_at: Time,
+            waiting_period: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/vitable_connect/models/benefit_eligibility_policy_response.rbi

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

data/rbi/vitable_connect/models/benefit_eligibility_policy_retrieve_params.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module VitableConnect
+  module Models
+    class BenefitEligibilityPolicyRetrieveParams < VitableConnect::Internal::Type::BaseModel
+      extend VitableConnect::Internal::Type::RequestParameters::Converter
+      include VitableConnect::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            VitableConnect::BenefitEligibilityPolicyRetrieveParams,
+            VitableConnect::Internal::AnyHash
+          )
+        end
+
+      # Unique benefit eligibility policy identifier (epol\_\*)
+      sig { returns(String) }
+      attr_accessor :policy_id
+
+      sig do
+        params(
+          policy_id: String,
+          request_options: VitableConnect::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique benefit eligibility policy identifier (epol\_\*)
+        policy_id:,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          { policy_id: String, request_options: VitableConnect::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/vitable_connect/models/employee.rbi

@@ -0,0 +1,316 @@
+# typed: strong
+
+module VitableConnect
+  module Models
+    class Employee < VitableConnect::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(VitableConnect::Employee, VitableConnect::Internal::AnyHash)
+        end
+
+      # Timestamp when the employee was created
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      # Date of birth (YYYY-MM-DD)
+      sig { returns(Date) }
+      attr_accessor :date_of_birth
+
+      # Email address
+      sig { returns(String) }
+      attr_accessor :email
+
+      # Benefit enrollments for this employee
+      sig { returns(T::Array[VitableConnect::Employee::Enrollment]) }
+      attr_accessor :enrollments
+
+      # Employee's legal first name
+      sig { returns(String) }
+      attr_accessor :first_name
+
+      # Employee's legal last name
+      sig { returns(String) }
+      attr_accessor :last_name
+
+      # Timestamp when the employee was last updated
+      sig { returns(Time) }
+      attr_accessor :updated_at
+
+      # Employee's residential address
+      sig { returns(T.nilable(VitableConnect::Employee::Address)) }
+      attr_reader :address
+
+      sig do
+        params(
+          address: T.nilable(VitableConnect::Employee::Address::OrHash)
+        ).void
+      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
+
+      # 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
+
+      # Name suffix (e.g., Jr., Sr., III)
+      sig { returns(T.nilable(String)) }
+      attr_accessor :suffix
+
+      # Employee's termination date, if terminated
+      sig { returns(T.nilable(Date)) }
+      attr_accessor :termination_date
+
+      # Unique employee identifier with 'empl\_' prefix
+      sig { returns(String) }
+      attr_accessor :id
+
+      # Unique member identifier with 'mbr\_' prefix
+      sig { returns(String) }
+      attr_accessor :member_id
+
+      # Employee status (active or terminated)
+      sig { returns(String) }
+      attr_accessor :status
+
+      sig do
+        params(
+          id: String,
+          created_at: Time,
+          date_of_birth: Date,
+          email: String,
+          enrollments: T::Array[VitableConnect::Employee::Enrollment::OrHash],
+          first_name: String,
+          last_name: String,
+          member_id: String,
+          status: String,
+          updated_at: Time,
+          address: T.nilable(VitableConnect::Employee::Address::OrHash),
+          employee_class: T.nilable(VitableConnect::EmployeeClass::OrSymbol),
+          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)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique employee identifier with 'empl\_' prefix
+        id:,
+        # Timestamp when the employee was created
+        created_at:,
+        # Date of birth (YYYY-MM-DD)
+        date_of_birth:,
+        # Email address
+        email:,
+        # Benefit enrollments for this employee
+        enrollments:,
+        # Employee's legal first name
+        first_name:,
+        # Employee's legal last name
+        last_name:,
+        # Unique member identifier with 'mbr\_' prefix
+        member_id:,
+        # 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,
+        # 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)
+        suffix: nil,
+        # Employee's termination date, if terminated
+        termination_date: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            created_at: Time,
+            date_of_birth: Date,
+            email: String,
+            enrollments: T::Array[VitableConnect::Employee::Enrollment],
+            first_name: String,
+            last_name: String,
+            member_id: String,
+            status: String,
+            updated_at: Time,
+            address: T.nilable(VitableConnect::Employee::Address),
+            employee_class:
+              T.nilable(VitableConnect::EmployeeClass::TaggedSymbol),
+            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)
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Enrollment < VitableConnect::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              VitableConnect::Employee::Enrollment,
+              VitableConnect::Internal::AnyHash
+            )
+          end
+
+        # - `pending` - Pending
+        # - `enrolled` - Enrolled
+        # - `waived` - Waived
+        # - `inactive` - Inactive
+        sig { returns(VitableConnect::EnrollmentStatus::TaggedSymbol) }
+        attr_accessor :status
+
+        # Timestamp when the enrollment decision was made
+        sig { returns(T.nilable(Time)) }
+        attr_accessor :answered_at
+
+        # Unique enrollment identifier with 'enrl\_' prefix
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig do
+          params(
+            id: String,
+            status: VitableConnect::EnrollmentStatus::OrSymbol,
+            answered_at: T.nilable(Time)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Unique enrollment identifier with 'enrl\_' prefix
+          id:,
+          # - `pending` - Pending
+          # - `enrolled` - Enrolled
+          # - `waived` - Waived
+          # - `inactive` - Inactive
+          status:,
+          # Timestamp when the enrollment decision was made
+          answered_at: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              status: VitableConnect::EnrollmentStatus::TaggedSymbol,
+              answered_at: T.nilable(Time)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      class Address < VitableConnect::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              VitableConnect::Employee::Address,
+              VitableConnect::Internal::AnyHash
+            )
+          end
+
+        # Primary street address
+        sig { returns(String) }
+        attr_accessor :address_line_1
+
+        # City name
+        sig { returns(String) }
+        attr_accessor :city
+
+        # Two-letter state code (e.g., CA, NY)
+        sig { returns(String) }
+        attr_accessor :state
+
+        # ZIP code (5 or 9 digit)
+        sig { returns(String) }
+        attr_accessor :zipcode
+
+        # Secondary street address (apt, suite, etc.)
+        sig { returns(T.nilable(String)) }
+        attr_accessor :address_line_2
+
+        # Employee's residential address
+        sig do
+          params(
+            address_line_1: String,
+            city: String,
+            state: String,
+            zipcode: String,
+            address_line_2: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Primary street address
+          address_line_1:,
+          # City name
+          city:,
+          # Two-letter state code (e.g., CA, NY)
+          state:,
+          # ZIP code (5 or 9 digit)
+          zipcode:,
+          # Secondary street address (apt, suite, etc.)
+          address_line_2: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              address_line_1: String,
+              city: String,
+              state: String,
+              zipcode: String,
+              address_line_2: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/vitable_connect/models/employee_class.rbi

@@ -0,0 +1,38 @@
+# typed: strong
+
+module VitableConnect
+  module Models
+    # - `Full Time` - Full Time
+    # - `Part Time` - Part Time
+    # - `Temporary` - Temporary
+    # - `Intern` - Intern
+    # - `Seasonal` - Seasonal
+    # - `Individual Contractor` - Individual Contractor
+    module EmployeeClass
+      extend VitableConnect::Internal::Type::Enum
+
+      TaggedSymbol =
+        T.type_alias { T.all(Symbol, VitableConnect::EmployeeClass) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      FULL_TIME =
+        T.let(:"Full Time", VitableConnect::EmployeeClass::TaggedSymbol)
+      PART_TIME =
+        T.let(:"Part Time", VitableConnect::EmployeeClass::TaggedSymbol)
+      TEMPORARY = T.let(:Temporary, VitableConnect::EmployeeClass::TaggedSymbol)
+      INTERN = T.let(:Intern, VitableConnect::EmployeeClass::TaggedSymbol)
+      SEASONAL = T.let(:Seasonal, VitableConnect::EmployeeClass::TaggedSymbol)
+      INDIVIDUAL_CONTRACTOR =
+        T.let(
+          :"Individual Contractor",
+          VitableConnect::EmployeeClass::TaggedSymbol
+        )
+
+      sig do
+        override.returns(T::Array[VitableConnect::EmployeeClass::TaggedSymbol])
+      end
+      def self.values
+      end
+    end
+  end
+end

data/rbi/vitable_connect/models/employee_list_enrollments_params.rbi

@@ -0,0 +1,68 @@
+# typed: strong
+
+module VitableConnect
+  module Models
+    class EmployeeListEnrollmentsParams < VitableConnect::Internal::Type::BaseModel
+      extend VitableConnect::Internal::Type::RequestParameters::Converter
+      include VitableConnect::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            VitableConnect::EmployeeListEnrollmentsParams,
+            VitableConnect::Internal::AnyHash
+          )
+        end
+
+      # Unique employee identifier (empl\_\*)
+      sig { returns(String) }
+      attr_accessor :employee_id
+
+      # Items per page (default: 20, max: 100)
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :limit
+
+      sig { params(limit: Integer).void }
+      attr_writer :limit
+
+      # Page number (default: 1)
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :page
+
+      sig { params(page: Integer).void }
+      attr_writer :page
+
+      sig do
+        params(
+          employee_id: String,
+          limit: Integer,
+          page: Integer,
+          request_options: VitableConnect::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique employee identifier (empl\_\*)
+        employee_id:,
+        # Items per page (default: 20, max: 100)
+        limit: nil,
+        # Page number (default: 1)
+        page: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            employee_id: String,
+            limit: Integer,
+            page: Integer,
+            request_options: VitableConnect::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end