vitable-connect 0.1.0

data/rbi/vitable_connect/models/employee_retrieve_params.rbi

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

data/rbi/vitable_connect/models/employee_retrieve_response.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module VitableConnect
+  module Models
+    class EmployeeRetrieveResponse < VitableConnect::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            VitableConnect::Models::EmployeeRetrieveResponse,
+            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

data/rbi/vitable_connect/models/employer.rbi

@@ -0,0 +1,205 @@
+# typed: strong
+
+module VitableConnect
+  module Models
+    class Employer < VitableConnect::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(VitableConnect::Employer, VitableConnect::Internal::AnyHash)
+        end
+
+      # Whether the employer is currently active in the system
+      sig { returns(T::Boolean) }
+      attr_accessor :active
+
+      # Nested address within EmployerSerializer.
+      sig { returns(VitableConnect::Employer::Address) }
+      attr_reader :address
+
+      sig { params(address: VitableConnect::Employer::Address::OrHash).void }
+      attr_writer :address
+
+      # Timestamp when the employer was created
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      # Legal business name for compliance and tax purposes
+      sig { returns(String) }
+      attr_accessor :legal_name
+
+      # Display name of the employer
+      sig { returns(String) }
+      attr_accessor :name
+
+      # Timestamp when the employer was last updated
+      sig { returns(Time) }
+      attr_accessor :updated_at
+
+      # Email address for billing and communications
+      sig { returns(T.nilable(String)) }
+      attr_accessor :email
+
+      # Employer phone number (E.164 format recommended)
+      sig { returns(T.nilable(String)) }
+      attr_accessor :phone_number
+
+      # Partner-assigned reference ID for the employer
+      sig { returns(T.nilable(String)) }
+      attr_accessor :reference_id
+
+      # Unique employer identifier with 'empr\_' prefix
+      sig { returns(String) }
+      attr_accessor :id
+
+      # Employer Identification Number (masked in responses)
+      sig { returns(T.nilable(String)) }
+      attr_accessor :ein
+
+      # ID of the benefit eligibility policy (epol\_\*), if assigned
+      sig { returns(T.nilable(String)) }
+      attr_accessor :eligibility_policy_id
+
+      # ID of the parent organization (org\_\*)
+      sig { returns(T.nilable(String)) }
+      attr_accessor :organization_id
+
+      # Serializer for Employer entity in public API responses.
+      sig do
+        params(
+          id: String,
+          active: T::Boolean,
+          address: VitableConnect::Employer::Address::OrHash,
+          created_at: Time,
+          ein: T.nilable(String),
+          eligibility_policy_id: T.nilable(String),
+          legal_name: String,
+          name: String,
+          organization_id: T.nilable(String),
+          updated_at: Time,
+          email: T.nilable(String),
+          phone_number: T.nilable(String),
+          reference_id: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique employer identifier with 'empr\_' prefix
+        id:,
+        # Whether the employer is currently active in the system
+        active:,
+        # Nested address within EmployerSerializer.
+        address:,
+        # Timestamp when the employer was created
+        created_at:,
+        # Employer Identification Number (masked in responses)
+        ein:,
+        # ID of the benefit eligibility policy (epol\_\*), if assigned
+        eligibility_policy_id:,
+        # Legal business name for compliance and tax purposes
+        legal_name:,
+        # Display name of the employer
+        name:,
+        # ID of the parent organization (org\_\*)
+        organization_id:,
+        # Timestamp when the employer was last updated
+        updated_at:,
+        # Email address for billing and communications
+        email: nil,
+        # Employer phone number (E.164 format recommended)
+        phone_number: nil,
+        # Partner-assigned reference ID for the employer
+        reference_id: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            active: T::Boolean,
+            address: VitableConnect::Employer::Address,
+            created_at: Time,
+            ein: T.nilable(String),
+            eligibility_policy_id: T.nilable(String),
+            legal_name: String,
+            name: String,
+            organization_id: T.nilable(String),
+            updated_at: Time,
+            email: T.nilable(String),
+            phone_number: T.nilable(String),
+            reference_id: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Address < VitableConnect::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              VitableConnect::Employer::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
+
+        # Nested address within EmployerSerializer.
+        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/employer_create_benefit_eligibility_policy_params.rbi

@@ -0,0 +1,64 @@
+# typed: strong
+
+module VitableConnect
+  module Models
+    class EmployerCreateBenefitEligibilityPolicyParams < VitableConnect::Internal::Type::BaseModel
+      extend VitableConnect::Internal::Type::RequestParameters::Converter
+      include VitableConnect::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            VitableConnect::EmployerCreateBenefitEligibilityPolicyParams,
+            VitableConnect::Internal::AnyHash
+          )
+        end
+
+      # Unique employer identifier (empr\_\*)
+      sig { returns(String) }
+      attr_accessor :employer_id
+
+      # Which employee classifications are eligible. One of: full_time, part_time, all
+      sig { returns(String) }
+      attr_accessor :classification
+
+      # Waiting period before eligibility. One of: first_of_following_month, 30_days,
+      # 60_days, none
+      sig { returns(String) }
+      attr_accessor :waiting_period
+
+      sig do
+        params(
+          employer_id: String,
+          classification: String,
+          waiting_period: String,
+          request_options: VitableConnect::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique employer identifier (empr\_\*)
+        employer_id:,
+        # Which employee classifications are eligible. One of: full_time, part_time, all
+        classification:,
+        # Waiting period before eligibility. One of: first_of_following_month, 30_days,
+        # 60_days, none
+        waiting_period:,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            employer_id: String,
+            classification: String,
+            waiting_period: String,
+            request_options: VitableConnect::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/vitable_connect/models/employer_create_params.rbi

@@ -0,0 +1,169 @@
+# typed: strong
+
+module VitableConnect
+  module Models
+    class EmployerCreateParams < VitableConnect::Internal::Type::BaseModel
+      extend VitableConnect::Internal::Type::RequestParameters::Converter
+      include VitableConnect::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            VitableConnect::EmployerCreateParams,
+            VitableConnect::Internal::AnyHash
+          )
+        end
+
+      # Employer address
+      sig { returns(VitableConnect::EmployerCreateParams::Address) }
+      attr_reader :address
+
+      sig do
+        params(
+          address: VitableConnect::EmployerCreateParams::Address::OrHash
+        ).void
+      end
+      attr_writer :address
+
+      # Employer Identification Number (format: XX-XXXXXXX)
+      sig { returns(String) }
+      attr_accessor :ein
+
+      # Email address for billing and communications
+      sig { returns(String) }
+      attr_accessor :email
+
+      # Legal business name
+      sig { returns(String) }
+      attr_accessor :legal_name
+
+      # Employer display name
+      sig { returns(String) }
+      attr_accessor :name
+
+      # Employer phone number (10-digit US format, e.g. 5551234567)
+      sig { returns(T.nilable(String)) }
+      attr_accessor :phone_number
+
+      # External reference ID for this employer
+      sig { returns(T.nilable(String)) }
+      attr_accessor :reference_id
+
+      sig do
+        params(
+          address: VitableConnect::EmployerCreateParams::Address::OrHash,
+          ein: String,
+          email: String,
+          legal_name: String,
+          name: String,
+          phone_number: T.nilable(String),
+          reference_id: T.nilable(String),
+          request_options: VitableConnect::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Employer address
+        address:,
+        # Employer Identification Number (format: XX-XXXXXXX)
+        ein:,
+        # Email address for billing and communications
+        email:,
+        # Legal business name
+        legal_name:,
+        # Employer display name
+        name:,
+        # Employer phone number (10-digit US format, e.g. 5551234567)
+        phone_number: nil,
+        # External reference ID for this employer
+        reference_id: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            address: VitableConnect::EmployerCreateParams::Address,
+            ein: String,
+            email: String,
+            legal_name: String,
+            name: String,
+            phone_number: T.nilable(String),
+            reference_id: T.nilable(String),
+            request_options: VitableConnect::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Address < VitableConnect::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              VitableConnect::EmployerCreateParams::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
+        sig { returns(String) }
+        attr_accessor :state
+
+        # ZIP code
+        sig { returns(String) }
+        attr_accessor :zipcode
+
+        # Secondary street address
+        sig { returns(T.nilable(String)) }
+        attr_accessor :address_line_2
+
+        # Employer 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
+          state:,
+          # ZIP code
+          zipcode:,
+          # Secondary street address
+          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/employer_list_employees_params.rbi

@@ -0,0 +1,68 @@
+# typed: strong
+
+module VitableConnect
+  module Models
+    class EmployerListEmployeesParams < VitableConnect::Internal::Type::BaseModel
+      extend VitableConnect::Internal::Type::RequestParameters::Converter
+      include VitableConnect::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            VitableConnect::EmployerListEmployeesParams,
+            VitableConnect::Internal::AnyHash
+          )
+        end
+
+      # Unique employer identifier (empr\_\*)
+      sig { returns(String) }
+      attr_accessor :employer_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(
+          employer_id: String,
+          limit: Integer,
+          page: Integer,
+          request_options: VitableConnect::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique employer identifier (empr\_\*)
+        employer_id:,
+        # Items per page (default: 20, max: 100)
+        limit: nil,
+        # Page number (default: 1)
+        page: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            employer_id: String,
+            limit: Integer,
+            page: Integer,
+            request_options: VitableConnect::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/vitable_connect/models/employer_list_params.rbi

@@ -0,0 +1,60 @@
+# typed: strong
+
+module VitableConnect
+  module Models
+    class EmployerListParams < VitableConnect::Internal::Type::BaseModel
+      extend VitableConnect::Internal::Type::RequestParameters::Converter
+      include VitableConnect::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            VitableConnect::EmployerListParams,
+            VitableConnect::Internal::AnyHash
+          )
+        end
+
+      # 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(
+          limit: Integer,
+          page: Integer,
+          request_options: VitableConnect::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Items per page (default: 20, max: 100)
+        limit: nil,
+        # Page number (default: 1)
+        page: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            limit: Integer,
+            page: Integer,
+            request_options: VitableConnect::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/vitable_connect/models/employer_response.rbi

@@ -0,0 +1,36 @@
+# typed: strong
+
+module VitableConnect
+  module Models
+    class EmployerResponse < VitableConnect::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            VitableConnect::EmployerResponse,
+            VitableConnect::Internal::AnyHash
+          )
+        end
+
+      # Serializer for Employer entity in public API responses.
+      sig { returns(VitableConnect::Employer) }
+      attr_reader :data
+
+      sig { params(data: VitableConnect::Employer::OrHash).void }
+      attr_writer :data
+
+      # Response containing a single employer resource.
+      sig do
+        params(data: VitableConnect::Employer::OrHash).returns(T.attached_class)
+      end
+      def self.new(
+        # Serializer for Employer entity in public API responses.
+        data:
+      )
+      end
+
+      sig { override.returns({ data: VitableConnect::Employer }) }
+      def to_hash
+      end
+    end
+  end
+end