valtech-components 2.0.484 → 2.0.486

package/esm2022/lib/services/auth/session.service.mjs

@@ -0,0 +1,78 @@
+import { Injectable, Inject } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { VALTECH_AUTH_CONFIG } from './config';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+/**
+ * Servicio para gestión de sesiones activas del usuario.
+ * Permite listar y revocar sesiones.
+ *
+ * @example
+ * ```typescript
+ * import { SessionService } from 'valtech-components';
+ *
+ * @Component({...})
+ * export class SessionsPage {
+ *   private sessionService = inject(SessionService);
+ *
+ *   sessions = signal<SessionInfo[]>([]);
+ *
+ *   async ngOnInit() {
+ *     const sessions = await firstValueFrom(this.sessionService.listSessions());
+ *     this.sessions.set(sessions);
+ *   }
+ *
+ *   async revokeSession(sessionId: string) {
+ *     await firstValueFrom(this.sessionService.revokeSession(sessionId));
+ *     // Recargar lista
+ *   }
+ *
+ *   async revokeAllOthers() {
+ *     const result = await firstValueFrom(this.sessionService.revokeAllSessions());
+ *     console.log(`${result.sessionsRevoked} sesiones cerradas`);
+ *   }
+ * }
+ * ```
+ */
+export class SessionService {
+    constructor(config, http) {
+        this.config = config;
+        this.http = http;
+    }
+    get baseUrl() {
+        return `${this.config.apiUrl}/v2/users/me/sessions`;
+    }
+    /**
+     * Lista todas las sesiones activas del usuario.
+     * La sesión actual está marcada con isCurrent=true.
+     */
+    listSessions() {
+        return this.http.get(this.baseUrl).pipe(map(response => response.sessions));
+    }
+    /**
+     * Revoca una sesión específica.
+     * Fuerza el cierre de sesión en ese dispositivo/navegador.
+     */
+    revokeSession(sessionId) {
+        return this.http.delete(`${this.baseUrl}/${sessionId}`);
+    }
+    /**
+     * Revoca todas las sesiones excepto la actual.
+     * Útil para "cerrar sesión en todos los dispositivos".
+     *
+     * @returns Número de sesiones revocadas
+     */
+    revokeAllSessions() {
+        return this.http.delete(this.baseUrl);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SessionService, deps: [{ token: VALTECH_AUTH_CONFIG }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SessionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SessionService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [VALTECH_AUTH_CONFIG]
+                }] }, { type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/auth/types.mjs

@@ -26,4 +26,4 @@ export const INITIAL_MFA_STATE = {
     mfaToken: null,
     method: null,
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../../src/lib/services/auth/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAuFH;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAc;IAC3C,eAAe,EAAE,KAAK;IACtB,SAAS,EAAE,IAAI;IACf,WAAW,EAAE,IAAI;IACjB,YAAY,EAAE,IAAI;IAClB,MAAM,EAAE,IAAI;IACZ,KAAK,EAAE,IAAI;IACX,KAAK,EAAE,EAAE;IACT,WAAW,EAAE,EAAE;IACf,YAAY,EAAE,KAAK;IACnB,SAAS,EAAE,IAAI;IACf,KAAK,EAAE,IAAI;CACZ,CAAC;AAkBF;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAoB;IAChD,QAAQ,EAAE,KAAK;IACf,QAAQ,EAAE,IAAI;IACd,MAAM,EAAE,IAAI;CACb,CAAC","sourcesContent":["/**\n * Tipos e interfaces para el servicio de autenticación de Valtech.\n * Alineados con el backend AuthV2.\n */\n\n// =============================================================================\n// CONFIGURACIÓN\n// =============================================================================\n\n/**\n * Configuración para el servicio de autenticación.\n */\nexport interface ValtechAuthConfig {\n  /** URL base de la API (ej: 'https://api.myvaltech.com') */\n  apiUrl: string;\n  /** Prefijo para endpoints de auth (default: '/v2/auth') */\n  authPrefix?: string;\n  /** Prefijo para las claves de localStorage (default: 'valtech_auth_') */\n  storagePrefix?: string;\n  /** Tiempo antes de expiración para refrescar token en segundos (default: 60) */\n  refreshBeforeExpiry?: number;\n  /** Habilitar sincronización entre pestañas (default: true) */\n  enableTabSync?: boolean;\n  /** Ruta de redirección cuando no autenticado (default: '/login') */\n  loginRoute?: string;\n  /** Ruta de redirección cuando ya autenticado (default: '/') */\n  homeRoute?: string;\n  /** Ruta para acceso denegado (default: '/unauthorized') */\n  unauthorizedRoute?: string;\n  /** Habilitar integración con FirebaseService (default: false) */\n  enableFirebaseIntegration?: boolean;\n  /** Habilitar registro automático de device tokens para push notifications (default: false) */\n  enableDeviceRegistration?: boolean;\n}\n\n// =============================================================================\n// ESTADO DE AUTENTICACIÓN\n// =============================================================================\n\n/**\n * Estado completo de autenticación.\n */\nexport interface AuthState {\n  /** Usuario está autenticado */\n  isAuthenticated: boolean;\n  /** Estado de carga inicial */\n  isLoading: boolean;\n  /** Token de acceso actual */\n  accessToken: string | null;\n  /** Token de refresco actual */\n  refreshToken: string | null;\n  /** ID del usuario */\n  userId: string | null;\n  /** Email del usuario */\n  email: string | null;\n  /** Roles del usuario */\n  roles: string[];\n  /** Permisos del usuario (formato 'resource:action') */\n  permissions: string[];\n  /** Usuario es super admin */\n  isSuperAdmin: boolean;\n  /** Timestamp de expiración del accessToken (ms) */\n  expiresAt: number | null;\n  /** Error de autenticación (si existe) */\n  error: AuthError | null;\n}\n\n/**\n * Información del usuario autenticado.\n */\nexport interface AuthUser {\n  userId: string;\n  email: string;\n  name?: string;\n  phone?: string;\n  roles: string[];\n  permissions: string[];\n  isSuperAdmin: boolean;\n  mfaEnabled?: boolean;\n  mfaMethod?: MFAMethod;\n}\n\n/**\n * Error de autenticación.\n */\nexport interface AuthError {\n  code: string;\n  message: string;\n}\n\n/**\n * Estado inicial de autenticación.\n */\nexport const INITIAL_AUTH_STATE: AuthState = {\n  isAuthenticated: false,\n  isLoading: true,\n  accessToken: null,\n  refreshToken: null,\n  userId: null,\n  email: null,\n  roles: [],\n  permissions: [],\n  isSuperAdmin: false,\n  expiresAt: null,\n  error: null,\n};\n\n// =============================================================================\n// MFA\n// =============================================================================\n\n/** Métodos de MFA soportados */\nexport type MFAMethod = 'EMAIL' | 'SMS' | 'TOTP';\n\n/**\n * Estado de MFA pendiente.\n */\nexport interface MFAPendingState {\n  required: boolean;\n  mfaToken: string | null;\n  method: MFAMethod | null;\n}\n\n/**\n * Estado inicial de MFA.\n */\nexport const INITIAL_MFA_STATE: MFAPendingState = {\n  required: false,\n  mfaToken: null,\n  method: null,\n};\n\n/**\n * Resultado de setup de MFA.\n */\nexport interface MFASetupResult {\n  codeSent: boolean;\n  message: string;\n}\n\n/**\n * Estado de MFA del usuario.\n */\nexport interface MFAStatus {\n  enabled: boolean;\n  method: MFAMethod | null;\n}\n\n// =============================================================================\n// TOTP MFA (Google Authenticator)\n// =============================================================================\n\n/**\n * Response de setup de TOTP.\n */\nexport interface TOTPSetupResponse {\n  operationId: string;\n  /** Secreto TOTP en base32 (para entrada manual) */\n  secret: string;\n  /** URL para generar QR code (otpauth://...) */\n  qrCodeUrl: string;\n  /** Códigos de respaldo de un solo uso */\n  backupCodes: string[];\n  message: string;\n}\n\n/**\n * Request para verificar setup de TOTP.\n */\nexport interface TOTPVerifySetupRequest {\n  /** Código TOTP de 6 dígitos */\n  code: string;\n}\n\n/**\n * Response de verificación de setup TOTP.\n */\nexport interface TOTPVerifySetupResponse {\n  operationId: string;\n  enabled: boolean;\n  message: string;\n}\n\n/**\n * Request para deshabilitar TOTP.\n */\nexport interface TOTPDisableRequest {\n  password: string;\n}\n\n/**\n * Response de deshabilitar TOTP.\n */\nexport interface TOTPDisableResponse {\n  operationId: string;\n  disabled: boolean;\n  message: string;\n}\n\n/**\n * Response de regenerar códigos de respaldo.\n */\nexport interface RegenerateBackupCodesResponse {\n  operationId: string;\n  backupCodes: string[];\n  message: string;\n}\n\n/**\n * Response de cantidad de códigos de respaldo.\n */\nexport interface BackupCodesCountResponse {\n  operationId: string;\n  count: number;\n}\n\n// =============================================================================\n// REQUESTS/RESPONSES (alineados con backend AuthV2)\n// =============================================================================\n\n/**\n * Request para signup (registro).\n */\nexport interface SignupRequest {\n  email: string;\n  password: string;\n  name: string;\n  phone?: string;\n}\n\n/**\n * Response de signup (registro).\n */\nexport interface SignupResponse {\n  operationId: string;\n  userId: string;\n  message: string;\n}\n\n/**\n * Request para verificar email.\n */\nexport interface VerifyEmailRequest {\n  email: string;\n  code: string;\n}\n\n/**\n * Response de verificación de email.\n * Si es exitoso, incluye tokens para auto-login.\n */\nexport interface VerifyEmailResponse {\n  operationId: string;\n  verified: boolean;\n  accessToken?: string;\n  refreshToken?: string;\n  firebaseToken?: string;\n  expiresIn?: number;\n  tokenType?: string;\n}\n\n/**\n * Request para reenviar código de verificación.\n */\nexport interface ResendCodeRequest {\n  email: string;\n  type: 'EMAIL_VERIFY' | 'PASSWORD_RESET';\n}\n\n/**\n * Response de reenvío de código.\n */\nexport interface ResendCodeResponse {\n  operationId: string;\n  sent: boolean;\n}\n\n/**\n * Request para signin.\n */\nexport interface SigninRequest {\n  email: string;\n  password: string;\n}\n\n/**\n * Response de signin.\n */\nexport interface SigninResponse {\n  operationId: string;\n  accessToken?: string;\n  refreshToken?: string;\n  firebaseToken?: string;\n  expiresIn?: number;\n  tokenType?: string;\n  mfaRequired?: boolean;\n  mfaToken?: string;\n  mfaMethod?: MFAMethod;\n  roles?: string[];\n  permissions?: string[];\n}\n\n/**\n * Request para verificar MFA.\n */\nexport interface MFAVerifyRequest {\n  mfaToken: string;\n  code: string;\n}\n\n/**\n * Response de verificar MFA.\n */\nexport interface MFAVerifyResponse {\n  operationId: string;\n  accessToken: string;\n  refreshToken: string;\n  firebaseToken?: string;\n  expiresIn: number;\n  tokenType: string;\n  roles?: string[];\n  permissions?: string[];\n}\n\n/**\n * Request para refrescar token.\n */\nexport interface RefreshRequest {\n  refreshToken: string;\n}\n\n/**\n * Response de refrescar token.\n * Implementa token rotation: cada refresh genera un nuevo refresh token.\n */\nexport interface RefreshResponse {\n  operationId: string;\n  accessToken: string;\n  refreshToken: string; // Token rotation: nuevo refresh token\n  expiresIn: number;\n  firebaseToken?: string;\n  roles?: string[];\n  permissions?: string[];\n}\n\n/**\n * Request para logout.\n */\nexport interface LogoutRequest {\n  refreshToken: string;\n}\n\n/**\n * Response de logout.\n */\nexport interface LogoutResponse {\n  operationId: string;\n  success: boolean;\n}\n\n/**\n * Response de obtener permisos.\n */\nexport interface GetPermissionsResponse {\n  operationId: string;\n  roles: string[];\n  permissions: string[];\n  isSuperAdmin: boolean;\n}\n\n/**\n * Request para setup de MFA.\n */\nexport interface MFASetupRequest {\n  method: MFAMethod;\n  phone?: string;\n}\n\n/**\n * Response de setup de MFA.\n */\nexport interface MFASetupResponse {\n  operationId: string;\n  codeSent: boolean;\n  message: string;\n}\n\n/**\n * Request para confirmar MFA.\n */\nexport interface MFAConfirmRequest {\n  code: string;\n}\n\n/**\n * Response de confirmar MFA.\n */\nexport interface MFAConfirmResponse {\n  operationId: string;\n  mfaEnabled: boolean;\n  method: MFAMethod;\n}\n\n/**\n * Request para deshabilitar MFA.\n */\nexport interface MFADisableRequest {\n  password: string;\n}\n\n/**\n * Response de deshabilitar MFA.\n */\nexport interface MFADisableResponse {\n  operationId: string;\n  mfaDisabled: boolean;\n}\n\n/**\n * Request para iniciar recuperación de contraseña.\n */\nexport interface ForgotPasswordRequest {\n  email: string;\n}\n\n/**\n * Response de forgot password (siempre igual por seguridad).\n */\nexport interface ForgotPasswordResponse {\n  operationId: string;\n  message: string;\n}\n\n/**\n * Request para resetear contraseña con código.\n */\nexport interface ResetPasswordRequest {\n  email: string;\n  code: string;\n  newPassword: string;\n}\n\n/**\n * Response de reset password.\n */\nexport interface ResetPasswordResponse {\n  operationId: string;\n  success: boolean;\n}\n\n/**\n * Response de obtener perfil del usuario.\n */\nexport interface GetProfileResponse {\n  operationId: string;\n  userId: string;\n  email: string;\n  name: string;\n  phone?: string;\n  emailVerified: boolean;\n  phoneVerified: boolean;\n  mfaEnabled: boolean;\n  mfaMethod?: MFAMethod;\n  createdAt: string;\n  updatedAt: string;\n}\n\n/**\n * Request para actualizar perfil.\n */\nexport interface UpdateProfileRequest {\n  name?: string;\n  phone?: string;\n}\n\n/**\n * Response de actualizar perfil.\n */\nexport interface UpdateProfileResponse {\n  operationId: string;\n  updated: boolean;\n}\n\n// =============================================================================\n// EVENTOS DE SINCRONIZACIÓN\n// =============================================================================\n\n// =============================================================================\n// SWITCH ORGANIZATION\n// =============================================================================\n\n/**\n * Request para cambiar de organización activa.\n */\nexport interface SwitchOrgRequest {\n  organizationId: string;\n}\n\n/**\n * Response de cambio de organización.\n */\nexport interface SwitchOrgResponse {\n  operationId: string;\n  firebaseToken: string;\n  activeOrg: string;\n}\n\n// =============================================================================\n// EVENTOS DE SINCRONIZACIÓN\n// =============================================================================\n\n/** Tipos de eventos de sincronización entre pestañas */\nexport type AuthSyncEventType =\n  | 'LOGIN'\n  | 'LOGOUT'\n  | 'TOKEN_REFRESH'\n  | 'PERMISSIONS_UPDATE'\n  | 'ORG_SWITCH';\n\n/**\n * Evento de sincronización entre pestañas.\n */\nexport interface AuthSyncEvent {\n  type: AuthSyncEventType;\n  timestamp: number;\n  payload?: {\n    accessToken?: string;\n    refreshToken?: string; // Token rotation support\n    expiresAt?: number;\n    activeOrg?: string;\n  };\n}\n\n// =============================================================================\n// JWT CLAIMS\n// =============================================================================\n\n/**\n * Claims del JWT de acceso.\n */\nexport interface JWTClaims {\n  /** User ID */\n  uid: string;\n  /** Email */\n  email: string;\n  /** Session ID */\n  sid?: string;\n  /** Issued at */\n  iat: number;\n  /** Expiration */\n  exp: number;\n}\n\n// =============================================================================\n// STORAGE\n// =============================================================================\n\n/**\n * Datos persistidos en storage.\n */\nexport interface StoredAuthState {\n  accessToken: string;\n  refreshToken: string;\n  roles: string[];\n  permissions: string[];\n  isSuperAdmin: boolean;\n  expiresAt?: number;\n}\n\n// =============================================================================\n// DEVICE REGISTRATION (Push Notifications)\n// =============================================================================\n\n/**\n * Plataformas soportadas para push notifications.\n */\nexport type DevicePlatform = 'web' | 'ios' | 'android';\n\n/**\n * Request para registrar un dispositivo.\n */\nexport interface RegisterDeviceRequest {\n  /** FCM token del dispositivo */\n  token: string;\n  /** Plataforma del dispositivo */\n  platform: DevicePlatform;\n  /** Navegador (solo web) */\n  browser?: string;\n  /** Sistema operativo */\n  os?: string;\n  /** Versión de la aplicación */\n  appVersion?: string;\n  /** Nombre amigable del dispositivo */\n  name?: string;\n  /** Metadata adicional */\n  metadata?: Record<string, string>;\n}\n\n/**\n * Response de registro de dispositivo.\n */\nexport interface RegisterDeviceResponse {\n  operationId: string;\n  device: {\n    deviceId: string;\n    token: string;\n    platform: DevicePlatform;\n    browser?: string;\n    os?: string;\n    lastActive: string;\n    createdAt: string;\n  };\n  /** true si es un nuevo dispositivo, false si se actualizó uno existente */\n  isNew: boolean;\n}\n\n/**\n * Resultado de habilitar notificaciones.\n */\nexport interface EnableNotificationsResult {\n  /** Si se otorgaron los permisos */\n  granted: boolean;\n  /** FCM token (solo si granted=true) */\n  token?: string;\n  /** Si el dispositivo fue registrado en el backend */\n  registered?: boolean;\n}\n\n/**\n * Estado de permisos de notificación.\n */\nexport type NotificationPermissionState = 'granted' | 'denied' | 'default' | 'unsupported';\n\n/**\n * Resultado del registro manual de dispositivo.\n */\nexport interface RegisterDeviceResult {\n  /** Si el dispositivo fue registrado exitosamente */\n  registered: boolean;\n  /** ID del dispositivo (solo si registered=true) */\n  deviceId?: string;\n  /** FCM token usado para el registro */\n  token?: string;\n  /** Mensaje de error (solo si registered=false) */\n  error?: string;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../../src/lib/services/auth/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAuFH;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAc;IAC3C,eAAe,EAAE,KAAK;IACtB,SAAS,EAAE,IAAI;IACf,WAAW,EAAE,IAAI;IACjB,YAAY,EAAE,IAAI;IAClB,MAAM,EAAE,IAAI;IACZ,KAAK,EAAE,IAAI;IACX,KAAK,EAAE,EAAE;IACT,WAAW,EAAE,EAAE;IACf,YAAY,EAAE,KAAK;IACnB,SAAS,EAAE,IAAI;IACf,KAAK,EAAE,IAAI;CACZ,CAAC;AAkBF;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAoB;IAChD,QAAQ,EAAE,KAAK;IACf,QAAQ,EAAE,IAAI;IACd,MAAM,EAAE,IAAI;CACb,CAAC","sourcesContent":["/**\n * Tipos e interfaces para el servicio de autenticación de Valtech.\n * Alineados con el backend AuthV2.\n */\n\n// =============================================================================\n// CONFIGURACIÓN\n// =============================================================================\n\n/**\n * Configuración para el servicio de autenticación.\n */\nexport interface ValtechAuthConfig {\n  /** URL base de la API (ej: 'https://api.myvaltech.com') */\n  apiUrl: string;\n  /** Prefijo para endpoints de auth (default: '/v2/auth') */\n  authPrefix?: string;\n  /** Prefijo para las claves de localStorage (default: 'valtech_auth_') */\n  storagePrefix?: string;\n  /** Tiempo antes de expiración para refrescar token en segundos (default: 60) */\n  refreshBeforeExpiry?: number;\n  /** Habilitar sincronización entre pestañas (default: true) */\n  enableTabSync?: boolean;\n  /** Ruta de redirección cuando no autenticado (default: '/login') */\n  loginRoute?: string;\n  /** Ruta de redirección cuando ya autenticado (default: '/') */\n  homeRoute?: string;\n  /** Ruta para acceso denegado (default: '/unauthorized') */\n  unauthorizedRoute?: string;\n  /** Habilitar integración con FirebaseService (default: false) */\n  enableFirebaseIntegration?: boolean;\n  /** Habilitar registro automático de device tokens para push notifications (default: false) */\n  enableDeviceRegistration?: boolean;\n}\n\n// =============================================================================\n// ESTADO DE AUTENTICACIÓN\n// =============================================================================\n\n/**\n * Estado completo de autenticación.\n */\nexport interface AuthState {\n  /** Usuario está autenticado */\n  isAuthenticated: boolean;\n  /** Estado de carga inicial */\n  isLoading: boolean;\n  /** Token de acceso actual */\n  accessToken: string | null;\n  /** Token de refresco actual */\n  refreshToken: string | null;\n  /** ID del usuario */\n  userId: string | null;\n  /** Email del usuario */\n  email: string | null;\n  /** Roles del usuario */\n  roles: string[];\n  /** Permisos del usuario (formato 'resource:action') */\n  permissions: string[];\n  /** Usuario es super admin */\n  isSuperAdmin: boolean;\n  /** Timestamp de expiración del accessToken (ms) */\n  expiresAt: number | null;\n  /** Error de autenticación (si existe) */\n  error: AuthError | null;\n}\n\n/**\n * Información del usuario autenticado.\n */\nexport interface AuthUser {\n  userId: string;\n  email: string;\n  name?: string;\n  phone?: string;\n  roles: string[];\n  permissions: string[];\n  isSuperAdmin: boolean;\n  mfaEnabled?: boolean;\n  mfaMethod?: MFAMethod;\n}\n\n/**\n * Error de autenticación.\n */\nexport interface AuthError {\n  code: string;\n  message: string;\n}\n\n/**\n * Estado inicial de autenticación.\n */\nexport const INITIAL_AUTH_STATE: AuthState = {\n  isAuthenticated: false,\n  isLoading: true,\n  accessToken: null,\n  refreshToken: null,\n  userId: null,\n  email: null,\n  roles: [],\n  permissions: [],\n  isSuperAdmin: false,\n  expiresAt: null,\n  error: null,\n};\n\n// =============================================================================\n// MFA\n// =============================================================================\n\n/** Métodos de MFA soportados */\nexport type MFAMethod = 'EMAIL' | 'SMS' | 'TOTP';\n\n/**\n * Estado de MFA pendiente.\n */\nexport interface MFAPendingState {\n  required: boolean;\n  mfaToken: string | null;\n  method: MFAMethod | null;\n}\n\n/**\n * Estado inicial de MFA.\n */\nexport const INITIAL_MFA_STATE: MFAPendingState = {\n  required: false,\n  mfaToken: null,\n  method: null,\n};\n\n/**\n * Resultado de setup de MFA.\n */\nexport interface MFASetupResult {\n  codeSent: boolean;\n  message: string;\n}\n\n/**\n * Estado de MFA del usuario.\n */\nexport interface MFAStatus {\n  enabled: boolean;\n  method: MFAMethod | null;\n}\n\n// =============================================================================\n// TOTP MFA (Google Authenticator)\n// =============================================================================\n\n/**\n * Response de setup de TOTP.\n */\nexport interface TOTPSetupResponse {\n  operationId: string;\n  /** Secreto TOTP en base32 (para entrada manual) */\n  secret: string;\n  /** URL para generar QR code (otpauth://...) */\n  qrCodeUrl: string;\n  /** Códigos de respaldo de un solo uso */\n  backupCodes: string[];\n  message: string;\n}\n\n/**\n * Request para verificar setup de TOTP.\n */\nexport interface TOTPVerifySetupRequest {\n  /** Código TOTP de 6 dígitos */\n  code: string;\n}\n\n/**\n * Response de verificación de setup TOTP.\n */\nexport interface TOTPVerifySetupResponse {\n  operationId: string;\n  enabled: boolean;\n  message: string;\n}\n\n/**\n * Request para deshabilitar TOTP.\n */\nexport interface TOTPDisableRequest {\n  password: string;\n}\n\n/**\n * Response de deshabilitar TOTP.\n */\nexport interface TOTPDisableResponse {\n  operationId: string;\n  disabled: boolean;\n  message: string;\n}\n\n/**\n * Response de regenerar códigos de respaldo.\n */\nexport interface RegenerateBackupCodesResponse {\n  operationId: string;\n  backupCodes: string[];\n  message: string;\n}\n\n/**\n * Response de cantidad de códigos de respaldo.\n */\nexport interface BackupCodesCountResponse {\n  operationId: string;\n  count: number;\n}\n\n// =============================================================================\n// REQUESTS/RESPONSES (alineados con backend AuthV2)\n// =============================================================================\n\n/**\n * Request para signup (registro).\n */\nexport interface SignupRequest {\n  email: string;\n  password: string;\n  name: string;\n  phone?: string;\n}\n\n/**\n * Response de signup (registro).\n */\nexport interface SignupResponse {\n  operationId: string;\n  userId: string;\n  message: string;\n}\n\n/**\n * Request para verificar email.\n */\nexport interface VerifyEmailRequest {\n  email: string;\n  code: string;\n}\n\n/**\n * Response de verificación de email.\n * Si es exitoso, incluye tokens para auto-login.\n */\nexport interface VerifyEmailResponse {\n  operationId: string;\n  verified: boolean;\n  accessToken?: string;\n  refreshToken?: string;\n  firebaseToken?: string;\n  expiresIn?: number;\n  tokenType?: string;\n}\n\n/**\n * Request para reenviar código de verificación.\n */\nexport interface ResendCodeRequest {\n  email: string;\n  type: 'EMAIL_VERIFY' | 'PASSWORD_RESET';\n}\n\n/**\n * Response de reenvío de código.\n */\nexport interface ResendCodeResponse {\n  operationId: string;\n  sent: boolean;\n}\n\n/**\n * Request para signin.\n */\nexport interface SigninRequest {\n  email: string;\n  password: string;\n  /** Plataforma del dispositivo (para detección de nuevo dispositivo) */\n  platform?: DevicePlatform;\n  /** Navegador (solo web) */\n  browser?: string;\n  /** Sistema operativo */\n  os?: string;\n  /** Nombre amigable del dispositivo */\n  deviceName?: string;\n}\n\n/**\n * Response de signin.\n */\nexport interface SigninResponse {\n  operationId: string;\n  accessToken?: string;\n  refreshToken?: string;\n  firebaseToken?: string;\n  expiresIn?: number;\n  tokenType?: string;\n  mfaRequired?: boolean;\n  mfaToken?: string;\n  mfaMethod?: MFAMethod;\n  roles?: string[];\n  permissions?: string[];\n  /** Indica si el login fue desde un dispositivo nuevo/no reconocido */\n  isNewDevice?: boolean;\n  /** ID del dispositivo usado para el login */\n  deviceId?: string;\n}\n\n/**\n * Request para verificar MFA.\n */\nexport interface MFAVerifyRequest {\n  mfaToken: string;\n  code: string;\n}\n\n/**\n * Response de verificar MFA.\n */\nexport interface MFAVerifyResponse {\n  operationId: string;\n  accessToken: string;\n  refreshToken: string;\n  firebaseToken?: string;\n  expiresIn: number;\n  tokenType: string;\n  roles?: string[];\n  permissions?: string[];\n}\n\n/**\n * Request para refrescar token.\n */\nexport interface RefreshRequest {\n  refreshToken: string;\n}\n\n/**\n * Response de refrescar token.\n * Implementa token rotation: cada refresh genera un nuevo refresh token.\n */\nexport interface RefreshResponse {\n  operationId: string;\n  accessToken: string;\n  refreshToken: string; // Token rotation: nuevo refresh token\n  expiresIn: number;\n  firebaseToken?: string;\n  roles?: string[];\n  permissions?: string[];\n}\n\n/**\n * Request para logout.\n */\nexport interface LogoutRequest {\n  refreshToken: string;\n}\n\n/**\n * Response de logout.\n */\nexport interface LogoutResponse {\n  operationId: string;\n  success: boolean;\n}\n\n/**\n * Response de obtener permisos.\n */\nexport interface GetPermissionsResponse {\n  operationId: string;\n  roles: string[];\n  permissions: string[];\n  isSuperAdmin: boolean;\n}\n\n/**\n * Request para setup de MFA.\n */\nexport interface MFASetupRequest {\n  method: MFAMethod;\n  phone?: string;\n}\n\n/**\n * Response de setup de MFA.\n */\nexport interface MFASetupResponse {\n  operationId: string;\n  codeSent: boolean;\n  message: string;\n}\n\n/**\n * Request para confirmar MFA.\n */\nexport interface MFAConfirmRequest {\n  code: string;\n}\n\n/**\n * Response de confirmar MFA.\n */\nexport interface MFAConfirmResponse {\n  operationId: string;\n  mfaEnabled: boolean;\n  method: MFAMethod;\n}\n\n/**\n * Request para deshabilitar MFA.\n */\nexport interface MFADisableRequest {\n  password: string;\n}\n\n/**\n * Response de deshabilitar MFA.\n */\nexport interface MFADisableResponse {\n  operationId: string;\n  mfaDisabled: boolean;\n}\n\n/**\n * Request para iniciar recuperación de contraseña.\n */\nexport interface ForgotPasswordRequest {\n  email: string;\n}\n\n/**\n * Response de forgot password (siempre igual por seguridad).\n */\nexport interface ForgotPasswordResponse {\n  operationId: string;\n  message: string;\n}\n\n/**\n * Request para resetear contraseña con código.\n */\nexport interface ResetPasswordRequest {\n  email: string;\n  code: string;\n  newPassword: string;\n}\n\n/**\n * Response de reset password.\n */\nexport interface ResetPasswordResponse {\n  operationId: string;\n  success: boolean;\n}\n\n/**\n * Response de obtener perfil del usuario.\n */\nexport interface GetProfileResponse {\n  operationId: string;\n  userId: string;\n  email: string;\n  name: string;\n  phone?: string;\n  emailVerified: boolean;\n  phoneVerified: boolean;\n  mfaEnabled: boolean;\n  mfaMethod?: MFAMethod;\n  createdAt: string;\n  updatedAt: string;\n}\n\n/**\n * Request para actualizar perfil.\n */\nexport interface UpdateProfileRequest {\n  name?: string;\n  phone?: string;\n}\n\n/**\n * Response de actualizar perfil.\n */\nexport interface UpdateProfileResponse {\n  operationId: string;\n  updated: boolean;\n}\n\n// =============================================================================\n// EVENTOS DE SINCRONIZACIÓN\n// =============================================================================\n\n// =============================================================================\n// SWITCH ORGANIZATION\n// =============================================================================\n\n/**\n * Request para cambiar de organización activa.\n */\nexport interface SwitchOrgRequest {\n  organizationId: string;\n}\n\n/**\n * Response de cambio de organización.\n */\nexport interface SwitchOrgResponse {\n  operationId: string;\n  firebaseToken: string;\n  activeOrg: string;\n}\n\n// =============================================================================\n// EVENTOS DE SINCRONIZACIÓN\n// =============================================================================\n\n/** Tipos de eventos de sincronización entre pestañas */\nexport type AuthSyncEventType =\n  | 'LOGIN'\n  | 'LOGOUT'\n  | 'TOKEN_REFRESH'\n  | 'PERMISSIONS_UPDATE'\n  | 'ORG_SWITCH';\n\n/**\n * Evento de sincronización entre pestañas.\n */\nexport interface AuthSyncEvent {\n  type: AuthSyncEventType;\n  timestamp: number;\n  payload?: {\n    accessToken?: string;\n    refreshToken?: string; // Token rotation support\n    expiresAt?: number;\n    activeOrg?: string;\n  };\n}\n\n// =============================================================================\n// JWT CLAIMS\n// =============================================================================\n\n/**\n * Claims del JWT de acceso.\n */\nexport interface JWTClaims {\n  /** User ID */\n  uid: string;\n  /** Email */\n  email: string;\n  /** Session ID */\n  sid?: string;\n  /** Issued at */\n  iat: number;\n  /** Expiration */\n  exp: number;\n}\n\n// =============================================================================\n// STORAGE\n// =============================================================================\n\n/**\n * Datos persistidos en storage.\n */\nexport interface StoredAuthState {\n  accessToken: string;\n  refreshToken: string;\n  roles: string[];\n  permissions: string[];\n  isSuperAdmin: boolean;\n  expiresAt?: number;\n}\n\n// =============================================================================\n// DEVICE REGISTRATION (Push Notifications)\n// =============================================================================\n\n/**\n * Plataformas soportadas para push notifications.\n */\nexport type DevicePlatform = 'web' | 'ios' | 'android';\n\n/**\n * Request para registrar un dispositivo.\n */\nexport interface RegisterDeviceRequest {\n  /** FCM token del dispositivo */\n  token: string;\n  /** Plataforma del dispositivo */\n  platform: DevicePlatform;\n  /** Navegador (solo web) */\n  browser?: string;\n  /** Sistema operativo */\n  os?: string;\n  /** Versión de la aplicación */\n  appVersion?: string;\n  /** Nombre amigable del dispositivo */\n  name?: string;\n  /** Metadata adicional */\n  metadata?: Record<string, string>;\n}\n\n/**\n * Response de registro de dispositivo.\n */\nexport interface RegisterDeviceResponse {\n  operationId: string;\n  device: {\n    deviceId: string;\n    token: string;\n    platform: DevicePlatform;\n    browser?: string;\n    os?: string;\n    lastActive: string;\n    createdAt: string;\n  };\n  /** true si es un nuevo dispositivo, false si se actualizó uno existente */\n  isNew: boolean;\n}\n\n/**\n * Resultado de habilitar notificaciones.\n */\nexport interface EnableNotificationsResult {\n  /** Si se otorgaron los permisos */\n  granted: boolean;\n  /** FCM token (solo si granted=true) */\n  token?: string;\n  /** Si el dispositivo fue registrado en el backend */\n  registered?: boolean;\n}\n\n/**\n * Estado de permisos de notificación.\n */\nexport type NotificationPermissionState = 'granted' | 'denied' | 'default' | 'unsupported';\n\n/**\n * Resultado del registro manual de dispositivo.\n */\nexport interface RegisterDeviceResult {\n  /** Si el dispositivo fue registrado exitosamente */\n  registered: boolean;\n  /** ID del dispositivo (solo si registered=true) */\n  deviceId?: string;\n  /** FCM token usado para el registro */\n  token?: string;\n  /** Mensaje de error (solo si registered=false) */\n  error?: string;\n}\n\n// =============================================================================\n// DEVICE MANAGEMENT (Detección de dispositivos nuevos)\n// =============================================================================\n\n/**\n * Estados posibles de un dispositivo.\n */\nexport type DeviceStatus = 'active' | 'pending_approval' | 'blocked';\n\n/**\n * Información completa de un dispositivo registrado.\n */\nexport interface DeviceInfo {\n  /** ID único del dispositivo */\n  deviceId: string;\n  /** Plataforma del dispositivo */\n  platform: DevicePlatform;\n  /** Navegador (solo web) */\n  browser?: string;\n  /** Sistema operativo */\n  os?: string;\n  /** Nombre amigable del dispositivo */\n  name?: string;\n  /** Estado actual del dispositivo */\n  status: DeviceStatus;\n  /** Dirección IP del último acceso */\n  ipAddress?: string;\n  /** Ubicación geográfica aproximada */\n  location?: string;\n  /** Última actividad */\n  lastActive: string;\n  /** Fecha de creación/registro */\n  createdAt: string;\n  /** Fecha de aprobación (si aplica) */\n  approvedAt?: string;\n  /** Fecha de bloqueo (si aplica) */\n  blockedAt?: string;\n}\n\n/**\n * Response de listar dispositivos del usuario.\n */\nexport interface ListDevicesResponse {\n  operationId: string;\n  devices: DeviceInfo[];\n}\n\n/**\n * Response de acción sobre dispositivo (block/approve/delete).\n */\nexport interface DeviceActionResult {\n  operationId: string;\n  success: boolean;\n  message: string;\n}\n\n// =============================================================================\n// SESSION MANAGEMENT (Gestión de sesiones activas)\n// =============================================================================\n\n/**\n * Información de una sesión activa.\n */\nexport interface SessionInfo {\n  /** ID único de la sesión */\n  sessionId: string;\n  /** ID del dispositivo asociado (si existe) */\n  deviceId?: string;\n  /** Información del dispositivo (User-Agent) */\n  deviceInfo?: string;\n  /** Dirección IP de la sesión */\n  ip?: string;\n  /** Ubicación geográfica aproximada */\n  location?: string;\n  /** Fecha de creación de la sesión */\n  createdAt: string;\n  /** Fecha de expiración de la sesión */\n  expiresAt: string;\n  /** Indica si es la sesión actual del usuario */\n  isCurrent: boolean;\n}\n\n/**\n * Response de listar sesiones activas.\n */\nexport interface ListSessionsResponse {\n  operationId: string;\n  sessions: SessionInfo[];\n}\n\n/**\n * Response de revocar sesión(es).\n */\nexport interface RevokeSessionsResponse {\n  operationId: string;\n  success: boolean;\n  /** Número de sesiones revocadas */\n  sessionsRevoked: number;\n}\n\n// =============================================================================\n// DEVICE ACTION (Acciones desde email de alerta)\n// =============================================================================\n\n/**\n * Request para ejecutar acción de dispositivo desde email.\n * El token viene en la URL del email de alerta.\n */\nexport interface DeviceActionRequest {\n  /** Token JWT de acción (24h, un solo uso) */\n  token: string;\n}\n\n/**\n * Response de ejecutar acción de dispositivo.\n */\nexport interface DeviceActionResponse {\n  operationId: string;\n  /** Si la acción fue ejecutada exitosamente */\n  success: boolean;\n  /** Acción ejecutada (refuse, approve, block) */\n  action: string;\n  /** ID del dispositivo afectado */\n  deviceId: string;\n  /** Número de sesiones revocadas (si action=refuse/block) */\n  sessionsRevoked?: number;\n  /** Mensaje descriptivo */\n  message: string;\n}\n"]}

package/fesm2022/valtech-components.mjs

@@ -25056,10 +25056,19 @@ class AuthService {
     // =============================================
     /**
      * Inicia sesión con email y contraseña.
+     * Detecta automáticamente la plataforma para identificar dispositivos nuevos.
      */
     signin(request) {
         this.stateService.clearError();
-        return this.http.post(`${this.baseUrl}/signin`, request).pipe(tap(response => {
+        // Agregar info de plataforma para device detection
+        const platformInfo = this.detectPlatformInfo();
+        const enrichedRequest = {
+            ...request,
+            platform: request.platform ?? platformInfo.platform,
+            browser: request.browser ?? platformInfo.browser,
+            os: request.os ?? platformInfo.os,
+        };
+        return this.http.post(`${this.baseUrl}/signin`, enrichedRequest).pipe(tap(response => {
             if (response.mfaRequired) {
                 // MFA requerido - guardar estado temporal
                 this.stateService.setMFAPending({
@@ -25071,6 +25080,10 @@ class AuthService {
             else if (response.accessToken) {
                 // Login exitoso sin MFA
                 this.handleSuccessfulAuth(response);
+                // Notificar si es un dispositivo nuevo
+                if (response.isNewDevice) {
+                    console.log('[ValtechAuth] New device detected:', response.deviceId);
+                }
             }
         }), catchError(error => this.handleAuthError(error)));
     }
@@ -26192,6 +26205,178 @@ function roleGuard(roles) {
     };
 }
 
+/**
+ * Servicio para gestión de dispositivos del usuario.
+ * Permite listar, aprobar, bloquear y eliminar dispositivos registrados.
+ *
+ * @example
+ * ```typescript
+ * import { DeviceService } from 'valtech-components';
+ *
+ * @Component({...})
+ * export class DevicesPage {
+ *   private deviceService = inject(DeviceService);
+ *
+ *   devices = signal<DeviceInfo[]>([]);
+ *
+ *   async ngOnInit() {
+ *     const devices = await firstValueFrom(this.deviceService.listDevices());
+ *     this.devices.set(devices);
+ *   }
+ *
+ *   async blockDevice(deviceId: string) {
+ *     await firstValueFrom(this.deviceService.blockDevice(deviceId));
+ *     // Recargar lista
+ *   }
+ * }
+ * ```
+ */
+class DeviceService {
+    constructor(config, http) {
+        this.config = config;
+        this.http = http;
+    }
+    get baseUrl() {
+        return `${this.config.apiUrl}/v2/users/me/devices`;
+    }
+    /**
+     * Lista todos los dispositivos registrados del usuario.
+     */
+    listDevices() {
+        return this.http.get(this.baseUrl).pipe(map$1(response => response.devices));
+    }
+    /**
+     * Obtiene información de un dispositivo específico.
+     */
+    getDevice(deviceId) {
+        return this.http.get(`${this.baseUrl}/${deviceId}`).pipe(map$1(response => response.device));
+    }
+    /**
+     * Bloquea un dispositivo.
+     * Revoca todas las sesiones activas de ese dispositivo.
+     */
+    blockDevice(deviceId) {
+        return this.http.post(`${this.baseUrl}/${deviceId}/block`, {});
+    }
+    /**
+     * Aprueba un dispositivo pendiente.
+     * Cambia el estado de pending_approval a active.
+     */
+    approveDevice(deviceId) {
+        return this.http.post(`${this.baseUrl}/${deviceId}/approve`, {});
+    }
+    /**
+     * Elimina un dispositivo registrado.
+     */
+    deleteDevice(deviceId) {
+        return this.http.delete(`${this.baseUrl}/${deviceId}`);
+    }
+    /**
+     * Ejecuta una acción de dispositivo desde un token de email.
+     * Este endpoint NO requiere autenticación.
+     * El token viene en la URL del email de alerta de nuevo inicio de sesión.
+     *
+     * @param token Token JWT de acción (24h, un solo uso)
+     *
+     * @example
+     * ```typescript
+     * // En la página de dispositivos, al detectar ?token=xxx en la URL:
+     * const token = this.route.snapshot.queryParams['token'];
+     * if (token) {
+     *   const result = await firstValueFrom(this.deviceService.executeAction(token));
+     *   if (result.success) {
+     *     console.log(`Dispositivo bloqueado, ${result.sessionsRevoked} sesiones cerradas`);
+     *   }
+     * }
+     * ```
+     */
+    executeAction(token) {
+        return this.http.post(`${this.config.apiUrl}/v2/auth/device-action`, { token });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DeviceService, deps: [{ token: VALTECH_AUTH_CONFIG }, { token: i1$8.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DeviceService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DeviceService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [VALTECH_AUTH_CONFIG]
+                }] }, { type: i1$8.HttpClient }] });
+
+/**
+ * Servicio para gestión de sesiones activas del usuario.
+ * Permite listar y revocar sesiones.
+ *
+ * @example
+ * ```typescript
+ * import { SessionService } from 'valtech-components';
+ *
+ * @Component({...})
+ * export class SessionsPage {
+ *   private sessionService = inject(SessionService);
+ *
+ *   sessions = signal<SessionInfo[]>([]);
+ *
+ *   async ngOnInit() {
+ *     const sessions = await firstValueFrom(this.sessionService.listSessions());
+ *     this.sessions.set(sessions);
+ *   }
+ *
+ *   async revokeSession(sessionId: string) {
+ *     await firstValueFrom(this.sessionService.revokeSession(sessionId));
+ *     // Recargar lista
+ *   }
+ *
+ *   async revokeAllOthers() {
+ *     const result = await firstValueFrom(this.sessionService.revokeAllSessions());
+ *     console.log(`${result.sessionsRevoked} sesiones cerradas`);
+ *   }
+ * }
+ * ```
+ */
+class SessionService {
+    constructor(config, http) {
+        this.config = config;
+        this.http = http;
+    }
+    get baseUrl() {
+        return `${this.config.apiUrl}/v2/users/me/sessions`;
+    }
+    /**
+     * Lista todas las sesiones activas del usuario.
+     * La sesión actual está marcada con isCurrent=true.
+     */
+    listSessions() {
+        return this.http.get(this.baseUrl).pipe(map$1(response => response.sessions));
+    }
+    /**
+     * Revoca una sesión específica.
+     * Fuerza el cierre de sesión en ese dispositivo/navegador.
+     */
+    revokeSession(sessionId) {
+        return this.http.delete(`${this.baseUrl}/${sessionId}`);
+    }
+    /**
+     * Revoca todas las sesiones excepto la actual.
+     * Útil para "cerrar sesión en todos los dispositivos".
+     *
+     * @returns Número de sesiones revocadas
+     */
+    revokeAllSessions() {
+        return this.http.delete(this.baseUrl);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SessionService, deps: [{ token: VALTECH_AUTH_CONFIG }, { token: i1$8.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SessionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SessionService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [VALTECH_AUTH_CONFIG]
+                }] }, { type: i1$8.HttpClient }] });
+
 /**
  * Valtech Auth Service
  *
@@ -26272,5 +26457,5 @@ function roleGuard(roles) {
  * Generated bundle index. Do not edit.
  */
 
-export { ARTICLE_SPACING, AccordionComponent, ActionHeaderComponent, ActionType, AlertBoxComponent, ArticleBuilder, ArticleComponent, AuthService, AuthStateService, AuthStorageService, AuthSyncService, AvatarComponent, BannerComponent, BaseDefault, BoxComponent, BreadcrumbComponent, ButtonComponent, ButtonGroupComponent, COMMON_COUNTRY_CODES, COMMON_CURRENCIES, CURRENCY_INFO, CardComponent, CardSection, CardType, CardsCarouselComponent, CheckInputComponent, ChipGroupComponent, ClearDefault, ClearDefaultBlock, ClearDefaultFull, ClearDefaultRound, ClearDefaultRoundBlock, ClearDefaultRoundFull, CodeDisplayComponent, CommandDisplayComponent, CommentComponent, CommentInputComponent, CommentSectionComponent, CompanyFooterComponent, ComponentStates, ConfirmationDialogService, ContentLoaderComponent, CountdownComponent, CurrencyInputComponent, DEFAULT_AUTH_CONFIG, DEFAULT_CANCEL_BUTTON, DEFAULT_CONFIRM_BUTTON, DEFAULT_COUNTDOWN_LABELS, DEFAULT_COUNTDOWN_LABELS_EN, DEFAULT_EMPTY_STATE, DEFAULT_LEGEND_LABELS, DEFAULT_MODAL_CANCEL_BUTTON, DEFAULT_MODAL_CONFIRM_BUTTON, DEFAULT_PAGE_SIZE_OPTIONS, DEFAULT_PAYMENT_STATUS_COLORS, DEFAULT_PAYMENT_STATUS_LABELS, DEFAULT_PLATFORMS, DEFAULT_STATUS_COLORS, DEFAULT_STATUS_LABELS, DEFAULT_WINNER_LABELS, DataTableComponent, DateInputComponent, DateRangeInputComponent, DisplayComponent, DividerComponent, DownloadService, EmailInputComponent, ExpandableTextComponent, FabComponent, FileInputComponent, FirebaseService, FirestoreCollectionFactory, FirestoreService, FooterComponent, FooterLinksComponent, FormComponent, FormFooterComponent, FunHeaderComponent, GlowCardComponent, HeaderComponent, HintComponent, HorizontalScrollComponent, HourInputComponent, HrefComponent, INITIAL_AUTH_STATE, INITIAL_MFA_STATE, Icon, IconComponent, IconService, ImageComponent, InAppBrowserService, InfoComponent, InputType, ItemListComponent, LanguageSelectorComponent, LayeredCardComponent, LayoutComponent, LinkComponent, LinkProcessorService, LinksAccordionComponent, LinksCakeComponent, LocalStorageService, LocaleService, MODAL_SIZES, MOTION, MenuComponent, MessagingService, ModalService, MultiSelectSearchComponent, NavigationService, NoContentComponent, NotesBoxComponent, NotificationsService, NumberFromToComponent, NumberInputComponent, NumberStepperComponent, OutlineDefault, OutlineDefaultBlock, OutlineDefaultFull, OutlineDefaultRound, OutlineDefaultRoundBlock, OutlineDefaultRoundFull, PLATFORM_CONFIGS, PageContentComponent, PageTemplateComponent, PageWrapperComponent, PaginationComponent, ParticipantCardComponent, PasswordInputComponent, PhoneInputComponent, PillComponent, PinInputComponent, PlainCodeBoxComponent, PopoverSelectorComponent, PriceTagComponent, PrimarySolidBlockButton, PrimarySolidBlockHrefButton, PrimarySolidBlockIconButton, PrimarySolidBlockIconHrefButton, PrimarySolidDefaultRoundButton, PrimarySolidDefaultRoundHrefButton, PrimarySolidDefaultRoundIconButton, PrimarySolidDefaultRoundIconHrefButton, PrimarySolidFullButton, PrimarySolidFullHrefButton, PrimarySolidFullIconButton, PrimarySolidFullIconHrefButton, PrimarySolidLargeRoundButton, PrimarySolidLargeRoundHrefButton, PrimarySolidLargeRoundIconButton, PrimarySolidLargeRoundIconHrefButton, PrimarySolidSmallRoundButton, PrimarySolidSmallRoundHrefButton, PrimarySolidSmallRoundIconButton, PrimarySolidSmallRoundIconHrefButton, ProcessLinksPipe, ProgressBarComponent, ProgressRingComponent, ProgressStatusComponent, PrompterComponent, QR_PRESETS, QrCodeComponent, QrGeneratorService, QueryBuilder, QuoteBoxComponent, RadioInputComponent, RaffleStatusCardComponent, RangeInputComponent, RatingComponent, RecapCardComponent, RightsFooterComponent, SKELETON_PRESETS, SearchSelectorComponent, SearchbarComponent, SecondarySolidBlockButton, SecondarySolidBlockHrefButton, SecondarySolidBlockIconButton, SecondarySolidBlockIconHrefButton, SecondarySolidDefaultRoundButton, SecondarySolidDefaultRoundHrefButton, SecondarySolidDefaultRoundIconButton, SecondarySolidDefaultRoundIconHrefButton, SecondarySolidFullButton, SecondarySolidFullHrefButton, SecondarySolidFullIconButton, SecondarySolidFullIconHrefButton, SecondarySolidLargeRoundButton, SecondarySolidLargeRoundHrefButton, SecondarySolidLargeRoundIconButton, SecondarySolidLargeRoundIconHrefButton, SecondarySolidSmallRoundButton, SecondarySolidSmallRoundHrefButton, SecondarySolidSmallRoundIconButton, SecondarySolidSmallRoundIconHrefButton, SegmentControlComponent, SelectSearchComponent, ShareButtonsComponent, SimpleComponent, SkeletonComponent, SolidBlockButton, SolidDefault, SolidDefaultBlock, SolidDefaultButton, SolidDefaultFull, SolidDefaultRound, SolidDefaultRoundBlock, SolidDefaultRoundButton, SolidDefaultRoundFull, SolidFullButton, SolidLargeButton, SolidLargeRoundButton, SolidSmallButton, SolidSmallRoundButton, StatsCardComponent, StepperComponent, StorageService, SwipeCarouselComponent, TabbedContentComponent, TabsComponent, TestimonialCardComponent, TestimonialCarouselComponent, TextComponent, TextInputComponent, TextareaInputComponent, ThemeOption, ThemeService, TicketGridComponent, TimelineComponent, TitleBlockComponent, TitleComponent, ToastService, ToggleInputComponent, TokenService, ToolbarActionType, ToolbarComponent, TypedCollection, VALTECH_AUTH_CONFIG, VALTECH_FIREBASE_CONFIG, WinnerDisplayComponent, WizardComponent, WizardFooterComponent, applyDefaultValueToControl, authGuard, authInterceptor, buildPath, collections, createFirebaseConfig, createGlowCardProps, createNumberFromToField, createTitleProps, extractPathParams, getCollectionPath, getDocumentId, goToTop, guestGuard, hasEmulators, isAtEnd, isCollectionPath, isDocumentPath, isEmulatorMode, isValidPath, joinPath, maxLength, permissionGuard, permissionGuardFromRoute, provideValtechAuth, provideValtechAuthInterceptor, provideValtechFirebase, query, replaceSpecialChars, resolveColor, resolveInputDefaultValue, roleGuard, storagePaths, superAdminGuard };
+export { ARTICLE_SPACING, AccordionComponent, ActionHeaderComponent, ActionType, AlertBoxComponent, ArticleBuilder, ArticleComponent, AuthService, AuthStateService, AuthStorageService, AuthSyncService, AvatarComponent, BannerComponent, BaseDefault, BoxComponent, BreadcrumbComponent, ButtonComponent, ButtonGroupComponent, COMMON_COUNTRY_CODES, COMMON_CURRENCIES, CURRENCY_INFO, CardComponent, CardSection, CardType, CardsCarouselComponent, CheckInputComponent, ChipGroupComponent, ClearDefault, ClearDefaultBlock, ClearDefaultFull, ClearDefaultRound, ClearDefaultRoundBlock, ClearDefaultRoundFull, CodeDisplayComponent, CommandDisplayComponent, CommentComponent, CommentInputComponent, CommentSectionComponent, CompanyFooterComponent, ComponentStates, ConfirmationDialogService, ContentLoaderComponent, CountdownComponent, CurrencyInputComponent, DEFAULT_AUTH_CONFIG, DEFAULT_CANCEL_BUTTON, DEFAULT_CONFIRM_BUTTON, DEFAULT_COUNTDOWN_LABELS, DEFAULT_COUNTDOWN_LABELS_EN, DEFAULT_EMPTY_STATE, DEFAULT_LEGEND_LABELS, DEFAULT_MODAL_CANCEL_BUTTON, DEFAULT_MODAL_CONFIRM_BUTTON, DEFAULT_PAGE_SIZE_OPTIONS, DEFAULT_PAYMENT_STATUS_COLORS, DEFAULT_PAYMENT_STATUS_LABELS, DEFAULT_PLATFORMS, DEFAULT_STATUS_COLORS, DEFAULT_STATUS_LABELS, DEFAULT_WINNER_LABELS, DataTableComponent, DateInputComponent, DateRangeInputComponent, DeviceService, DisplayComponent, DividerComponent, DownloadService, EmailInputComponent, ExpandableTextComponent, FabComponent, FileInputComponent, FirebaseService, FirestoreCollectionFactory, FirestoreService, FooterComponent, FooterLinksComponent, FormComponent, FormFooterComponent, FunHeaderComponent, GlowCardComponent, HeaderComponent, HintComponent, HorizontalScrollComponent, HourInputComponent, HrefComponent, INITIAL_AUTH_STATE, INITIAL_MFA_STATE, Icon, IconComponent, IconService, ImageComponent, InAppBrowserService, InfoComponent, InputType, ItemListComponent, LanguageSelectorComponent, LayeredCardComponent, LayoutComponent, LinkComponent, LinkProcessorService, LinksAccordionComponent, LinksCakeComponent, LocalStorageService, LocaleService, MODAL_SIZES, MOTION, MenuComponent, MessagingService, ModalService, MultiSelectSearchComponent, NavigationService, NoContentComponent, NotesBoxComponent, NotificationsService, NumberFromToComponent, NumberInputComponent, NumberStepperComponent, OutlineDefault, OutlineDefaultBlock, OutlineDefaultFull, OutlineDefaultRound, OutlineDefaultRoundBlock, OutlineDefaultRoundFull, PLATFORM_CONFIGS, PageContentComponent, PageTemplateComponent, PageWrapperComponent, PaginationComponent, ParticipantCardComponent, PasswordInputComponent, PhoneInputComponent, PillComponent, PinInputComponent, PlainCodeBoxComponent, PopoverSelectorComponent, PriceTagComponent, PrimarySolidBlockButton, PrimarySolidBlockHrefButton, PrimarySolidBlockIconButton, PrimarySolidBlockIconHrefButton, PrimarySolidDefaultRoundButton, PrimarySolidDefaultRoundHrefButton, PrimarySolidDefaultRoundIconButton, PrimarySolidDefaultRoundIconHrefButton, PrimarySolidFullButton, PrimarySolidFullHrefButton, PrimarySolidFullIconButton, PrimarySolidFullIconHrefButton, PrimarySolidLargeRoundButton, PrimarySolidLargeRoundHrefButton, PrimarySolidLargeRoundIconButton, PrimarySolidLargeRoundIconHrefButton, PrimarySolidSmallRoundButton, PrimarySolidSmallRoundHrefButton, PrimarySolidSmallRoundIconButton, PrimarySolidSmallRoundIconHrefButton, ProcessLinksPipe, ProgressBarComponent, ProgressRingComponent, ProgressStatusComponent, PrompterComponent, QR_PRESETS, QrCodeComponent, QrGeneratorService, QueryBuilder, QuoteBoxComponent, RadioInputComponent, RaffleStatusCardComponent, RangeInputComponent, RatingComponent, RecapCardComponent, RightsFooterComponent, SKELETON_PRESETS, SearchSelectorComponent, SearchbarComponent, SecondarySolidBlockButton, SecondarySolidBlockHrefButton, SecondarySolidBlockIconButton, SecondarySolidBlockIconHrefButton, SecondarySolidDefaultRoundButton, SecondarySolidDefaultRoundHrefButton, SecondarySolidDefaultRoundIconButton, SecondarySolidDefaultRoundIconHrefButton, SecondarySolidFullButton, SecondarySolidFullHrefButton, SecondarySolidFullIconButton, SecondarySolidFullIconHrefButton, SecondarySolidLargeRoundButton, SecondarySolidLargeRoundHrefButton, SecondarySolidLargeRoundIconButton, SecondarySolidLargeRoundIconHrefButton, SecondarySolidSmallRoundButton, SecondarySolidSmallRoundHrefButton, SecondarySolidSmallRoundIconButton, SecondarySolidSmallRoundIconHrefButton, SegmentControlComponent, SelectSearchComponent, SessionService, ShareButtonsComponent, SimpleComponent, SkeletonComponent, SolidBlockButton, SolidDefault, SolidDefaultBlock, SolidDefaultButton, SolidDefaultFull, SolidDefaultRound, SolidDefaultRoundBlock, SolidDefaultRoundButton, SolidDefaultRoundFull, SolidFullButton, SolidLargeButton, SolidLargeRoundButton, SolidSmallButton, SolidSmallRoundButton, StatsCardComponent, StepperComponent, StorageService, SwipeCarouselComponent, TabbedContentComponent, TabsComponent, TestimonialCardComponent, TestimonialCarouselComponent, TextComponent, TextInputComponent, TextareaInputComponent, ThemeOption, ThemeService, TicketGridComponent, TimelineComponent, TitleBlockComponent, TitleComponent, ToastService, ToggleInputComponent, TokenService, ToolbarActionType, ToolbarComponent, TypedCollection, VALTECH_AUTH_CONFIG, VALTECH_FIREBASE_CONFIG, WinnerDisplayComponent, WizardComponent, WizardFooterComponent, applyDefaultValueToControl, authGuard, authInterceptor, buildPath, collections, createFirebaseConfig, createGlowCardProps, createNumberFromToField, createTitleProps, extractPathParams, getCollectionPath, getDocumentId, goToTop, guestGuard, hasEmulators, isAtEnd, isCollectionPath, isDocumentPath, isEmulatorMode, isValidPath, joinPath, maxLength, permissionGuard, permissionGuardFromRoute, provideValtechAuth, provideValtechAuthInterceptor, provideValtechFirebase, query, replaceSpecialChars, resolveColor, resolveInputDefaultValue, roleGuard, storagePaths, superAdminGuard };
 //# sourceMappingURL=valtech-components.mjs.map