hvp-shared 3.0.1 → 3.2.0

package/dist/constants/collaborator.constants.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Collaborator Constants and Enums
+ *
+ * Shared enums used by both backend and frontend for collaborator management.
+ */
+/**
+ * Web Application Roles
+ *
+ * Defines user roles for authorization and access control.
+ * Used in JWT tokens, middleware, and UI role-based rendering.
+ */
+export declare enum WebAppRole {
+    admin = "Administrador",
+    manager = "Gerente",
+    collaborator = "Colaborador",
+    user = "User",
+    guest = "Invitado"
+}
+/**
+ * Educational Degree
+ *
+ * Academic level of collaborators for HR records.
+ */
+export declare enum Degree {
+    HighSchool = "Bachillerato",
+    UniversityStudent = "Estudiante universitario",
+    BachelorComplete = "Licenciatura completa",
+    Graduated = "Titulado",
+    Masters = "Maestr\u00EDa",
+    Doctorate = "Doctorado",
+    Other = "Otros"
+}
+/**
+ * Gender
+ *
+ * Gender identification for HR and demographic records.
+ */
+export declare enum Gender {
+    Male = "Masculino",
+    Female = "Femenino",
+    Other = "Otro"
+}

package/dist/constants/collaborator.constants.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * Collaborator Constants and Enums
+ *
+ * Shared enums used by both backend and frontend for collaborator management.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gender = exports.Degree = exports.WebAppRole = void 0;
+/**
+ * Web Application Roles
+ *
+ * Defines user roles for authorization and access control.
+ * Used in JWT tokens, middleware, and UI role-based rendering.
+ */
+var WebAppRole;
+(function (WebAppRole) {
+    WebAppRole["admin"] = "Administrador";
+    WebAppRole["manager"] = "Gerente";
+    WebAppRole["collaborator"] = "Colaborador";
+    WebAppRole["user"] = "User";
+    WebAppRole["guest"] = "Invitado";
+})(WebAppRole || (exports.WebAppRole = WebAppRole = {}));
+/**
+ * Educational Degree
+ *
+ * Academic level of collaborators for HR records.
+ */
+var Degree;
+(function (Degree) {
+    Degree["HighSchool"] = "Bachillerato";
+    Degree["UniversityStudent"] = "Estudiante universitario";
+    Degree["BachelorComplete"] = "Licenciatura completa";
+    Degree["Graduated"] = "Titulado";
+    Degree["Masters"] = "Maestr\u00EDa";
+    Degree["Doctorate"] = "Doctorado";
+    Degree["Other"] = "Otros";
+})(Degree || (exports.Degree = Degree = {}));
+/**
+ * Gender
+ *
+ * Gender identification for HR and demographic records.
+ */
+var Gender;
+(function (Gender) {
+    Gender["Male"] = "Masculino";
+    Gender["Female"] = "Femenino";
+    Gender["Other"] = "Otro";
+})(Gender || (exports.Gender = Gender = {}));

package/dist/constants/index.d.ts

@@ -3,3 +3,4 @@
  */
 export * from './mexican-states';
 export * from './sat-catalogs';
+export * from './collaborator.constants';

package/dist/constants/index.js

@@ -19,3 +19,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 __exportStar(require("./mexican-states"), exports);
 __exportStar(require("./sat-catalogs"), exports);
+__exportStar(require("./collaborator.constants"), exports);

package/dist/contracts/collaborator/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Collaborator API Contracts
+ * Request and Response types for Collaborator endpoints
+ */
+export * from './responses';

package/dist/contracts/collaborator/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Collaborator API Contracts
+ * Request and Response types for Collaborator endpoints
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./responses"), exports);
+// export * from './requests';  // TODO: Create when needed

package/dist/contracts/collaborator/responses.d.ts

@@ -0,0 +1,106 @@
+import { WebAppRole } from '../../constants/collaborator.constants';
+import { AddressValidationProps } from '../../validation/address.validation';
+/**
+ * Public Collaborator Response
+ *
+ * Minimal data for public endpoints (no authentication required).
+ * Used for: Public website, service listings, team pages.
+ *
+ * @example GET /api/collaborators/public
+ */
+export interface PublicCollaboratorResponse {
+    id: string;
+    col_code: string;
+    first_name: string;
+    last_name: string;
+    photoURL?: string;
+    role: WebAppRole;
+    isActive: boolean;
+}
+/**
+ * Collaborator View Response
+ *
+ * Extended data for authenticated collaborators viewing other collaborators.
+ * Excludes sensitive information (fiscal data, salary, banking).
+ *
+ * Used for: Collaborators viewing team members, scheduling, contact info.
+ *
+ * @example GET /api/collaborators/:id (authenticated collaborator)
+ */
+export interface CollaboratorViewResponse {
+    id: string;
+    col_code: string;
+    first_name: string;
+    last_name: string;
+    email?: string;
+    phone?: string;
+    photoURL?: string;
+    birthDate?: Date;
+    role: WebAppRole;
+    isActive: boolean;
+    isDisplayedWeb: boolean;
+    isRegistered: boolean;
+    job?: string;
+    branch?: string;
+    hireDate?: Date;
+    address?: AddressValidationProps;
+    facebook?: string;
+    instagram?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+/**
+ * Admin Collaborator Response
+ *
+ * Complete data including all sensitive information.
+ * Only for admin users.
+ *
+ * Used for: Admin dashboard, payroll management, HR operations, CFDI generation.
+ *
+ * @example GET /api/collaborators/:id (admin authenticated)
+ */
+export interface AdminCollaboratorResponse {
+    id: string;
+    col_code: string;
+    first_name: string;
+    last_name: string;
+    second_last_name?: string;
+    email?: string;
+    phone?: string;
+    photoURL?: string;
+    birthDate?: Date;
+    role: WebAppRole;
+    isActive: boolean;
+    isDisplayedWeb: boolean;
+    isRegistered: boolean;
+    registeredDate?: Date;
+    job?: string;
+    branch?: string;
+    hireDate?: Date;
+    endDate?: Date;
+    address?: AddressValidationProps;
+    facebook?: string;
+    instagram?: string;
+    rfcCode?: string;
+    curp?: string;
+    imssNumber?: string;
+    useFiscalAddressSameAsMain: boolean;
+    fiscalAddress?: AddressValidationProps;
+    taxZipCode?: string;
+    contractType?: string;
+    regimeType?: string;
+    fiscalRegime?: string;
+    bank?: string;
+    bankAccount?: string;
+    baseSalary?: number;
+    dailySalary?: number;
+    accessCode?: string;
+    createdBy?: string;
+    updatedBy?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+/**
+ * Union type for all collaborator response types
+ */
+export type CollaboratorResponse = PublicCollaboratorResponse | CollaboratorViewResponse | AdminCollaboratorResponse;

package/dist/contracts/collaborator/responses.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/contracts/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * API Contracts
+ * Request and Response types for all API endpoints
+ */
+export * from './collaborator';

package/dist/contracts/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * API Contracts
+ * Request and Response types for all API endpoints
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./collaborator"), exports);

package/dist/index.d.ts

@@ -4,5 +4,6 @@
  */
 export * from './types';
 export * from './constants';
+export * from './contracts';
 export * from './validation';
 export { debugLog } from './utils/debug-logger';

package/dist/index.js

@@ -21,6 +21,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.debugLog = void 0;
 __exportStar(require("./types"), exports);
 __exportStar(require("./constants"), exports);
+__exportStar(require("./contracts"), exports);
 __exportStar(require("./validation"), exports);
 var debug_logger_1 = require("./utils/debug-logger");
 Object.defineProperty(exports, "debugLog", { enumerable: true, get: function () { return debug_logger_1.debugLog; } });

package/dist/types/collaborator-fiscal.types.d.ts

@@ -0,0 +1,70 @@
+import { SATContractTypeCode, SATFiscalRegimeCode, SATRegimeTypeCode } from '../constants/sat-catalogs';
+import { AddressValidationProps } from '../validation/address.validation';
+/**
+ * Collaborator Fiscal Data
+ *
+ * Fiscal/tax information required for CFDI payroll stamping in Mexico.
+ * These fields are needed to generate compliant electronic payroll invoices (CFDI Nómina).
+ *
+ * @see SAT CFDI Nómina 4.0 specification
+ */
+export interface CollaboratorFiscalData {
+    /**
+     * RFC - Registro Federal de Contribuyentes
+     * Mexican tax ID (12-13 characters)
+     */
+    rfcCode?: string;
+    /**
+     * CURP - Clave Única de Registro de Población
+     * Unique population registry code (18 characters)
+     */
+    curp?: string;
+    /**
+     * NSS/IMSS Number - Número de Seguro Social
+     * Mexican social security number (11 digits)
+     */
+    imssNumber?: string;
+    /**
+     * Flag indicating if fiscal address is the same as main address
+     * When true, fiscalAddress should be null/undefined
+     */
+    useFiscalAddressSameAsMain: boolean;
+    /**
+     * Fiscal address (only when useFiscalAddressSameAsMain is false)
+     * Used for tax purposes and CFDI generation
+     */
+    fiscalAddress?: AddressValidationProps;
+    /**
+     * Tax zip code (c_CodigoPostal)
+     * Must match SAT catalog
+     */
+    taxZipCode?: string;
+    /**
+     * Contract type (c_TipoContrato)
+     * SAT catalog code for employment contract type
+     */
+    contractType?: SATContractTypeCode;
+    /**
+     * Regime type (c_TipoRegimen)
+     * SAT catalog code for employment regime
+     */
+    regimeType?: SATRegimeTypeCode;
+    /**
+     * Fiscal regime (c_RegimenFiscal)
+     * SAT catalog code for worker's fiscal regime
+     */
+    fiscalRegime?: SATFiscalRegimeCode;
+    /**
+     * Bank name for payroll deposits
+     */
+    bank?: string;
+    /**
+     * Bank account number (CLABE)
+     */
+    bankAccount?: string;
+}
+/**
+ * Partial fiscal data for updates
+ * All fields optional for partial updates
+ */
+export type PartialCollaboratorFiscalData = Partial<CollaboratorFiscalData>;

package/dist/types/collaborator-fiscal.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Type Definitions
+ * Shared TypeScript interfaces and types
+ */
+export * from './api-response.types';
+export * from './company-settings.types';
+export * from './collaborator-fiscal.types';

package/dist/types/index.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * Type Definitions
+ * Shared TypeScript interfaces and types
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api-response.types"), exports);
+__exportStar(require("./company-settings.types"), exports);
+__exportStar(require("./collaborator-fiscal.types"), exports);

package/dist/validation/address.validation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/validation/address.validation.test.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const address_validation_1 = require("./address.validation");
+describe('validateAddress', () => {
+    const validAddress = {
+        street: 'Calle 10',
+        exteriorNumber: '123',
+        interiorNumber: 'A',
+        neighborhood: 'Centro',
+        city: 'Mérida',
+        state: 'YUC',
+        zipCode: '97000',
+        country: 'México'
+    };
+    describe('valid addresses', () => {
+        it('should accept valid complete address', () => {
+            const result = (0, address_validation_1.validateAddress)(validAddress);
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+        it('should accept address without interior number', () => {
+            const { interiorNumber, ...addressWithoutInterior } = validAddress;
+            const result = (0, address_validation_1.validateAddress)(addressWithoutInterior);
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept country "Mexico" without accent', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, country: 'Mexico' });
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept country in uppercase', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, country: 'MÉXICO' });
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept address with whitespace (trimmed)', () => {
+            const result = (0, address_validation_1.validateAddress)({
+                ...validAddress,
+                street: '  Calle 10  ',
+                city: '  Mérida  '
+            });
+            expect(result.isValid).toBe(true);
+        });
+    });
+    describe('required fields', () => {
+        it('should reject missing street', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, street: '' });
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Calle es requerida');
+        });
+        it('should reject missing exterior number', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, exteriorNumber: '' });
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Número exterior es requerido');
+        });
+        it('should reject missing neighborhood', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, neighborhood: '' });
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Colonia es requerida');
+        });
+        it('should reject missing city', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, city: '' });
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Ciudad es requerida');
+        });
+        it('should reject missing postal code', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, zipCode: '' });
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Código postal es requerido');
+        });
+        it('should reject missing state', () => {
+            const { state, ...addressWithoutState } = validAddress;
+            const result = (0, address_validation_1.validateAddress)(addressWithoutState);
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Estado es requerido');
+        });
+        it('should reject missing country', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, country: '' });
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('País es requerido');
+        });
+    });
+    describe('postal code validation', () => {
+        it('should reject postal code with less than 5 digits', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, zipCode: '9700' });
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('5 dígitos');
+        });
+        it('should reject postal code with more than 5 digits', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, zipCode: '970001' });
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('5 dígitos');
+        });
+        it('should reject postal code with letters', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, zipCode: '9700A' });
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('5 dígitos');
+        });
+    });
+    describe('state code validation', () => {
+        it('should accept all valid Mexican state codes', () => {
+            // SAT Federal Entity codes (c_Estado) - used for CFDI compliance
+            const validStates = [
+                'AGU', 'BCN', 'BCS', 'CAM', 'CHP', 'CHH', 'COA', 'COL', 'DIF',
+                'DUR', 'GUA', 'GRO', 'HID', 'JAL', 'MEX', 'MIC', 'MOR', 'NAY',
+                'NLE', 'OAX', 'PUE', 'QUE', 'ROO', 'SLP', 'SIN', 'SON', 'TAB',
+                'TAM', 'TLA', 'VER', 'YUC', 'ZAC'
+            ];
+            validStates.forEach(state => {
+                const result = (0, address_validation_1.validateAddress)({ ...validAddress, state: state });
+                expect(result.isValid).toBe(true);
+            });
+        });
+        it('should reject invalid state code', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, state: 'INVALID' });
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Código de estado inválido');
+        });
+    });
+    describe('country validation', () => {
+        it('should reject non-Mexican country', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, country: 'USA' });
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('México');
+        });
+        it('should reject other countries', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, country: 'Canada' });
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('México');
+        });
+    });
+});
+describe('POSTAL_CODE_PATTERN', () => {
+    it('should match valid 5-digit postal code', () => {
+        expect(address_validation_1.POSTAL_CODE_PATTERN.test('97000')).toBe(true);
+    });
+    it('should match postal code starting with 0', () => {
+        expect(address_validation_1.POSTAL_CODE_PATTERN.test('01000')).toBe(true);
+    });
+    it('should not match 4-digit code', () => {
+        expect(address_validation_1.POSTAL_CODE_PATTERN.test('9700')).toBe(false);
+    });
+    it('should not match 6-digit code', () => {
+        expect(address_validation_1.POSTAL_CODE_PATTERN.test('970001')).toBe(false);
+    });
+});

package/dist/validation/curp.validation.d.ts

@@ -0,0 +1,30 @@
+import { ValidationResult } from './rfc.validation';
+/**
+ * Validates CURP (Clave Única de Registro de Población) format
+ *
+ * CURP is the Mexican unique population registry code.
+ * Format: 18 characters (e.g., GARC850101HDFRRL09)
+ * - 4 letters: surname initial + surname vowel + name initial + name letter
+ * - 6 digits: birth date YYMMDD
+ * - 1 letter: sex (H/M)
+ * - 2 letters: state code
+ * - 3 alphanumeric: consonants + check digit
+ *
+ * Note: This performs basic format validation only.
+ *
+ * @param value - CURP to validate
+ * @returns ValidationResult with isValid flag and optional error message
+ */
+export declare function validateCURP(value: string | null | undefined): ValidationResult;
+/**
+ * Normalizes CURP to uppercase and trimmed
+ *
+ * @param value - CURP to normalize
+ * @returns Normalized CURP
+ */
+export declare function normalizeCURP(value: string): string;
+/**
+ * Regex pattern for CURP validation
+ * Can be used directly in form libraries that accept regex
+ */
+export declare const CURP_PATTERN: RegExp;

package/dist/validation/curp.validation.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CURP_PATTERN = void 0;
+exports.validateCURP = validateCURP;
+exports.normalizeCURP = normalizeCURP;
+/**
+ * Validates CURP (Clave Única de Registro de Población) format
+ *
+ * CURP is the Mexican unique population registry code.
+ * Format: 18 characters (e.g., GARC850101HDFRRL09)
+ * - 4 letters: surname initial + surname vowel + name initial + name letter
+ * - 6 digits: birth date YYMMDD
+ * - 1 letter: sex (H/M)
+ * - 2 letters: state code
+ * - 3 alphanumeric: consonants + check digit
+ *
+ * Note: This performs basic format validation only.
+ *
+ * @param value - CURP to validate
+ * @returns ValidationResult with isValid flag and optional error message
+ */
+function validateCURP(value) {
+    if (!value || !value.trim()) {
+        return { isValid: false, error: 'CURP es requerido' };
+    }
+    const normalized = value.toUpperCase().trim();
+    // CURP format: 18 alphanumeric characters
+    const curpPattern = /^[A-Z]{4}\d{6}[HM][A-Z]{5}[0-9A-Z]\d$/;
+    if (!curpPattern.test(normalized)) {
+        return { isValid: false, error: 'CURP inválido. Debe tener 18 caracteres (ej: GARC850101HDFRRL09)' };
+    }
+    // Validate length
+    if (normalized.length !== 18) {
+        return { isValid: false, error: 'CURP debe tener exactamente 18 caracteres' };
+    }
+    return { isValid: true };
+}
+/**
+ * Normalizes CURP to uppercase and trimmed
+ *
+ * @param value - CURP to normalize
+ * @returns Normalized CURP
+ */
+function normalizeCURP(value) {
+    return value.toUpperCase().trim();
+}
+/**
+ * Regex pattern for CURP validation
+ * Can be used directly in form libraries that accept regex
+ */
+exports.CURP_PATTERN = /^[A-Z]{4}\d{6}[HM][A-Z]{5}[0-9A-Z]\d$/;

package/dist/validation/curp.validation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/validation/curp.validation.test.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const curp_validation_1 = require("./curp.validation");
+describe('validateCURP', () => {
+    describe('valid CURPs', () => {
+        it('should accept valid CURP with male sex', () => {
+            const result = (0, curp_validation_1.validateCURP)('GARC850101HDFRRL09');
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+        it('should accept valid CURP with female sex', () => {
+            const result = (0, curp_validation_1.validateCURP)('MELR930224MDFRNS08');
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+        it('should accept lowercase CURP (normalized)', () => {
+            const result = (0, curp_validation_1.validateCURP)('garc850101hdfrrl09');
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept CURP with whitespace (trimmed)', () => {
+            const result = (0, curp_validation_1.validateCURP)('  GARC850101HDFRRL09  ');
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept mixed case CURP', () => {
+            const result = (0, curp_validation_1.validateCURP)('Garc850101HdfrRL09');
+            expect(result.isValid).toBe(true);
+        });
+    });
+    describe('invalid CURPs', () => {
+        it('should reject empty string', () => {
+            const result = (0, curp_validation_1.validateCURP)('');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('CURP es requerido');
+        });
+        it('should reject null', () => {
+            const result = (0, curp_validation_1.validateCURP)(null);
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('CURP es requerido');
+        });
+        it('should reject undefined', () => {
+            const result = (0, curp_validation_1.validateCURP)(undefined);
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('CURP es requerido');
+        });
+        it('should reject whitespace only', () => {
+            const result = (0, curp_validation_1.validateCURP)('   ');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('CURP es requerido');
+        });
+        it('should reject CURP too short', () => {
+            const result = (0, curp_validation_1.validateCURP)('GARC850101HDFRR');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('CURP inválido');
+        });
+        it('should reject CURP too long', () => {
+            const result = (0, curp_validation_1.validateCURP)('GARC850101HDFRRL099');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('CURP inválido');
+        });
+        it('should reject CURP with invalid sex character (not H/M)', () => {
+            const result = (0, curp_validation_1.validateCURP)('GARC850101XDFRRL09');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('CURP inválido');
+        });
+        it('should reject CURP with invalid characters', () => {
+            const result = (0, curp_validation_1.validateCURP)('GARC-850101HDFRRL09');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('CURP inválido');
+        });
+        it('should reject CURP with wrong format (all numbers)', () => {
+            const result = (0, curp_validation_1.validateCURP)('123456789012345678');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('CURP inválido');
+        });
+        it('should reject CURP with invalid date format', () => {
+            const result = (0, curp_validation_1.validateCURP)('GARCABCDEFHDFRRL09');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('CURP inválido');
+        });
+    });
+});
+describe('normalizeCURP', () => {
+    it('should convert to uppercase', () => {
+        expect((0, curp_validation_1.normalizeCURP)('garc850101hdfrrl09')).toBe('GARC850101HDFRRL09');
+    });
+    it('should trim whitespace', () => {
+        expect((0, curp_validation_1.normalizeCURP)('  GARC850101HDFRRL09  ')).toBe('GARC850101HDFRRL09');
+    });
+    it('should handle mixed case', () => {
+        expect((0, curp_validation_1.normalizeCURP)('Garc850101HdfrRL09')).toBe('GARC850101HDFRRL09');
+    });
+});
+describe('CURP_PATTERN', () => {
+    it('should match valid CURP with male sex', () => {
+        expect(curp_validation_1.CURP_PATTERN.test('GARC850101HDFRRL09')).toBe(true);
+    });
+    it('should match valid CURP with female sex', () => {
+        expect(curp_validation_1.CURP_PATTERN.test('MELR930224MDFRNS08')).toBe(true);
+    });
+    it('should not match invalid CURP', () => {
+        expect(curp_validation_1.CURP_PATTERN.test('INVALID')).toBe(false);
+    });
+    it('should not match CURP with invalid sex', () => {
+        expect(curp_validation_1.CURP_PATTERN.test('GARC850101XDFRRL09')).toBe(false);
+    });
+});

package/dist/validation/email.validation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/validation/email.validation.test.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const email_validation_1 = require("./email.validation");
+describe('validateEmail', () => {
+    describe('valid emails', () => {
+        it('should accept valid email', () => {
+            const result = (0, email_validation_1.validateEmail)('test@example.com');
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+        it('should accept email with subdomain', () => {
+            const result = (0, email_validation_1.validateEmail)('test@mail.example.com');
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept email with numbers', () => {
+            const result = (0, email_validation_1.validateEmail)('test123@example.com');
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept email with dots in local part', () => {
+            const result = (0, email_validation_1.validateEmail)('test.user@example.com');
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept email with plus sign', () => {
+            const result = (0, email_validation_1.validateEmail)('test+tag@example.com');
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept uppercase email (normalized)', () => {
+            const result = (0, email_validation_1.validateEmail)('TEST@EXAMPLE.COM');
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept email with whitespace (trimmed)', () => {
+            const result = (0, email_validation_1.validateEmail)('  test@example.com  ');
+            expect(result.isValid).toBe(true);
+        });
+    });
+    describe('invalid emails', () => {
+        it('should reject empty string', () => {
+            const result = (0, email_validation_1.validateEmail)('');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Email es requerido');
+        });
+        it('should reject null', () => {
+            const result = (0, email_validation_1.validateEmail)(null);
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Email es requerido');
+        });
+        it('should reject undefined', () => {
+            const result = (0, email_validation_1.validateEmail)(undefined);
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Email es requerido');
+        });
+        it('should reject whitespace only', () => {
+            const result = (0, email_validation_1.validateEmail)('   ');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Email es requerido');
+        });
+        it('should reject email without @', () => {
+            const result = (0, email_validation_1.validateEmail)('testexample.com');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Email inválido');
+        });
+        it('should reject email without domain', () => {
+            const result = (0, email_validation_1.validateEmail)('test@');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Email inválido');
+        });
+        it('should reject email without local part', () => {
+            const result = (0, email_validation_1.validateEmail)('@example.com');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Email inválido');
+        });
+        it('should reject email without TLD', () => {
+            const result = (0, email_validation_1.validateEmail)('test@example');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Email inválido');
+        });
+        it('should reject email with spaces', () => {
+            const result = (0, email_validation_1.validateEmail)('test @example.com');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Email inválido');
+        });
+    });
+});
+describe('normalizeEmail', () => {
+    it('should convert to lowercase', () => {
+        expect((0, email_validation_1.normalizeEmail)('TEST@EXAMPLE.COM')).toBe('test@example.com');
+    });
+    it('should trim whitespace', () => {
+        expect((0, email_validation_1.normalizeEmail)('  test@example.com  ')).toBe('test@example.com');
+    });
+    it('should handle mixed case', () => {
+        expect((0, email_validation_1.normalizeEmail)('Test@Example.Com')).toBe('test@example.com');
+    });
+});
+describe('EMAIL_PATTERN', () => {
+    it('should match valid email', () => {
+        expect(email_validation_1.EMAIL_PATTERN.test('test@example.com')).toBe(true);
+    });
+    it('should not match invalid email', () => {
+        expect(email_validation_1.EMAIL_PATTERN.test('invalid')).toBe(false);
+    });
+});

package/dist/validation/index.d.ts

@@ -3,6 +3,8 @@
  * Pure, stateless validation logic shared between frontend and backend
  */
 export * from './rfc.validation';
+export * from './curp.validation';
+export * from './nss.validation';
 export * from './email.validation';
 export * from './phone.validation';
 export * from './address.validation';

package/dist/validation/index.js

@@ -19,6 +19,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./rfc.validation"), exports);
+__exportStar(require("./curp.validation"), exports);
+__exportStar(require("./nss.validation"), exports);
 __exportStar(require("./email.validation"), exports);
 __exportStar(require("./phone.validation"), exports);
 __exportStar(require("./address.validation"), exports);

package/dist/validation/nss.validation.d.ts

@@ -0,0 +1,25 @@
+import { ValidationResult } from './rfc.validation';
+/**
+ * Validates NSS (Número de Seguridad Social) format
+ *
+ * NSS is the Mexican social security number issued by IMSS.
+ * Format: 11 digits (e.g., 12345678901)
+ *
+ * Note: This performs basic format validation only (11 digits).
+ *
+ * @param value - NSS to validate
+ * @returns ValidationResult with isValid flag and optional error message
+ */
+export declare function validateNSS(value: string | null | undefined): ValidationResult;
+/**
+ * Normalizes NSS by trimming whitespace
+ *
+ * @param value - NSS to normalize
+ * @returns Normalized NSS
+ */
+export declare function normalizeNSS(value: string): string;
+/**
+ * Regex pattern for NSS validation
+ * Can be used directly in form libraries that accept regex
+ */
+export declare const NSS_PATTERN: RegExp;

package/dist/validation/nss.validation.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NSS_PATTERN = void 0;
+exports.validateNSS = validateNSS;
+exports.normalizeNSS = normalizeNSS;
+/**
+ * Validates NSS (Número de Seguridad Social) format
+ *
+ * NSS is the Mexican social security number issued by IMSS.
+ * Format: 11 digits (e.g., 12345678901)
+ *
+ * Note: This performs basic format validation only (11 digits).
+ *
+ * @param value - NSS to validate
+ * @returns ValidationResult with isValid flag and optional error message
+ */
+function validateNSS(value) {
+    if (!value || !value.trim()) {
+        return { isValid: false, error: 'NSS es requerido' };
+    }
+    const normalized = value.trim();
+    // NSS format: exactly 11 digits
+    const nssPattern = /^\d{11}$/;
+    if (!nssPattern.test(normalized)) {
+        return { isValid: false, error: 'NSS inválido. Debe tener exactamente 11 dígitos' };
+    }
+    return { isValid: true };
+}
+/**
+ * Normalizes NSS by trimming whitespace
+ *
+ * @param value - NSS to normalize
+ * @returns Normalized NSS
+ */
+function normalizeNSS(value) {
+    return value.trim();
+}
+/**
+ * Regex pattern for NSS validation
+ * Can be used directly in form libraries that accept regex
+ */
+exports.NSS_PATTERN = /^\d{11}$/;

package/dist/validation/nss.validation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/validation/nss.validation.test.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const nss_validation_1 = require("./nss.validation");
+describe('validateNSS', () => {
+    describe('valid NSS', () => {
+        it('should accept valid 11-digit NSS', () => {
+            const result = (0, nss_validation_1.validateNSS)('12345678901');
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+        it('should accept NSS with whitespace (trimmed)', () => {
+            const result = (0, nss_validation_1.validateNSS)('  12345678901  ');
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept another valid NSS', () => {
+            const result = (0, nss_validation_1.validateNSS)('98765432109');
+            expect(result.isValid).toBe(true);
+        });
+    });
+    describe('invalid NSS', () => {
+        it('should reject empty string', () => {
+            const result = (0, nss_validation_1.validateNSS)('');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('NSS es requerido');
+        });
+        it('should reject null', () => {
+            const result = (0, nss_validation_1.validateNSS)(null);
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('NSS es requerido');
+        });
+        it('should reject undefined', () => {
+            const result = (0, nss_validation_1.validateNSS)(undefined);
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('NSS es requerido');
+        });
+        it('should reject whitespace only', () => {
+            const result = (0, nss_validation_1.validateNSS)('   ');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('NSS es requerido');
+        });
+        it('should reject NSS too short', () => {
+            const result = (0, nss_validation_1.validateNSS)('1234567890');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('NSS inválido');
+        });
+        it('should reject NSS too long', () => {
+            const result = (0, nss_validation_1.validateNSS)('123456789012');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('NSS inválido');
+        });
+        it('should reject NSS with letters', () => {
+            const result = (0, nss_validation_1.validateNSS)('1234567890A');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('NSS inválido');
+        });
+        it('should reject NSS with special characters', () => {
+            const result = (0, nss_validation_1.validateNSS)('12345-67890');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('NSS inválido');
+        });
+        it('should reject NSS with spaces in the middle', () => {
+            const result = (0, nss_validation_1.validateNSS)('12345 67890');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('NSS inválido');
+        });
+    });
+});
+describe('normalizeNSS', () => {
+    it('should trim whitespace', () => {
+        expect((0, nss_validation_1.normalizeNSS)('  12345678901  ')).toBe('12345678901');
+    });
+    it('should not modify valid NSS', () => {
+        expect((0, nss_validation_1.normalizeNSS)('12345678901')).toBe('12345678901');
+    });
+});
+describe('NSS_PATTERN', () => {
+    it('should match valid 11-digit NSS', () => {
+        expect(nss_validation_1.NSS_PATTERN.test('12345678901')).toBe(true);
+    });
+    it('should not match invalid NSS', () => {
+        expect(nss_validation_1.NSS_PATTERN.test('INVALID')).toBe(false);
+    });
+    it('should not match NSS with wrong length', () => {
+        expect(nss_validation_1.NSS_PATTERN.test('123456789')).toBe(false);
+    });
+});

package/dist/validation/phone.validation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/validation/phone.validation.test.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const phone_validation_1 = require("./phone.validation");
+describe('validatePhone', () => {
+    describe('valid phones', () => {
+        it('should accept valid 10-digit phone', () => {
+            const result = (0, phone_validation_1.validatePhone)('9991234567');
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+        it('should accept phone with whitespace (trimmed)', () => {
+            const result = (0, phone_validation_1.validatePhone)('  9991234567  ');
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept undefined (phone is optional)', () => {
+            const result = (0, phone_validation_1.validatePhone)(undefined);
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept null (phone is optional)', () => {
+            const result = (0, phone_validation_1.validatePhone)(null);
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept empty string (phone is optional)', () => {
+            const result = (0, phone_validation_1.validatePhone)('');
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept whitespace only (phone is optional)', () => {
+            const result = (0, phone_validation_1.validatePhone)('   ');
+            expect(result.isValid).toBe(true);
+        });
+    });
+    describe('invalid phones', () => {
+        it('should reject phone with less than 10 digits', () => {
+            const result = (0, phone_validation_1.validatePhone)('999123456');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('10 dígitos');
+        });
+        it('should reject phone with more than 10 digits', () => {
+            const result = (0, phone_validation_1.validatePhone)('99912345678');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('10 dígitos');
+        });
+        it('should reject phone with letters', () => {
+            const result = (0, phone_validation_1.validatePhone)('999123456a');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('10 dígitos');
+        });
+        it('should reject phone with special characters', () => {
+            const result = (0, phone_validation_1.validatePhone)('999-123-4567');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('10 dígitos');
+        });
+        it('should reject phone with spaces inside', () => {
+            const result = (0, phone_validation_1.validatePhone)('999 123 4567');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('10 dígitos');
+        });
+        it('should reject phone with parentheses', () => {
+            const result = (0, phone_validation_1.validatePhone)('(999)1234567');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('10 dígitos');
+        });
+    });
+});
+describe('PHONE_PATTERN', () => {
+    it('should match valid 10-digit phone', () => {
+        expect(phone_validation_1.PHONE_PATTERN.test('9991234567')).toBe(true);
+    });
+    it('should not match invalid phone', () => {
+        expect(phone_validation_1.PHONE_PATTERN.test('999-123-4567')).toBe(false);
+    });
+    it('should not match phone with less than 10 digits', () => {
+        expect(phone_validation_1.PHONE_PATTERN.test('999123456')).toBe(false);
+    });
+});

package/dist/validation/rfc.validation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/validation/rfc.validation.test.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rfc_validation_1 = require("./rfc.validation");
+describe('validateRFC', () => {
+    describe('valid RFCs', () => {
+        it('should accept valid RFC persona moral (12 chars)', () => {
+            const result = (0, rfc_validation_1.validateRFC)('HVP850101AB1');
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+        it('should accept valid RFC persona física (13 chars)', () => {
+            const result = (0, rfc_validation_1.validateRFC)('GARC850101AB1');
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+        it('should accept RFC with Ñ', () => {
+            const result = (0, rfc_validation_1.validateRFC)('MÑO850101AB1');
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept RFC with &', () => {
+            const result = (0, rfc_validation_1.validateRFC)('M&O850101AB1');
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept lowercase RFC (normalized)', () => {
+            const result = (0, rfc_validation_1.validateRFC)('hvp850101ab1');
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept RFC with whitespace (trimmed)', () => {
+            const result = (0, rfc_validation_1.validateRFC)('  HVP850101AB1  ');
+            expect(result.isValid).toBe(true);
+        });
+    });
+    describe('invalid RFCs', () => {
+        it('should reject empty string', () => {
+            const result = (0, rfc_validation_1.validateRFC)('');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('RFC es requerido');
+        });
+        it('should reject null', () => {
+            const result = (0, rfc_validation_1.validateRFC)(null);
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('RFC es requerido');
+        });
+        it('should reject undefined', () => {
+            const result = (0, rfc_validation_1.validateRFC)(undefined);
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('RFC es requerido');
+        });
+        it('should reject whitespace only', () => {
+            const result = (0, rfc_validation_1.validateRFC)('   ');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('RFC es requerido');
+        });
+        it('should reject RFC too short', () => {
+            const result = (0, rfc_validation_1.validateRFC)('HVP850101');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('RFC inválido');
+        });
+        it('should reject RFC too long', () => {
+            const result = (0, rfc_validation_1.validateRFC)('GARC850101AB1X');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('RFC inválido');
+        });
+        it('should reject RFC with invalid characters', () => {
+            const result = (0, rfc_validation_1.validateRFC)('HVP-850101AB1');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('RFC inválido');
+        });
+        it('should reject RFC with wrong format', () => {
+            const result = (0, rfc_validation_1.validateRFC)('123456789012');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('RFC inválido');
+        });
+    });
+});
+describe('normalizeRFC', () => {
+    it('should convert to uppercase', () => {
+        expect((0, rfc_validation_1.normalizeRFC)('hvp850101ab1')).toBe('HVP850101AB1');
+    });
+    it('should trim whitespace', () => {
+        expect((0, rfc_validation_1.normalizeRFC)('  HVP850101AB1  ')).toBe('HVP850101AB1');
+    });
+    it('should handle mixed case', () => {
+        expect((0, rfc_validation_1.normalizeRFC)('HvP850101Ab1')).toBe('HVP850101AB1');
+    });
+});
+describe('RFC_PATTERN', () => {
+    it('should match valid RFC persona moral', () => {
+        expect(rfc_validation_1.RFC_PATTERN.test('HVP850101AB1')).toBe(true);
+    });
+    it('should match valid RFC persona física', () => {
+        expect(rfc_validation_1.RFC_PATTERN.test('GARC850101AB1')).toBe(true);
+    });
+    it('should not match invalid RFC', () => {
+        expect(rfc_validation_1.RFC_PATTERN.test('INVALID')).toBe(false);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hvp-shared",
-  "version": "3.0.1",
+  "version": "3.2.0",
   "description": "Shared types and utilities for HVP backend and frontend",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",