valtech-components 2.0.484 → 2.0.486

package/lib/components/types.d.ts

@@ -140,6 +140,18 @@ export type InputMetadata = {
     okText?: string;
     /** Position of label for checkbox ('start' | 'end') */
     labelPlacement?: 'start' | 'end';
+    /** Number of digits in PIN (default: 5, only for PIN_CODE type) */
+    length?: number;
+    /** Size of the input boxes: 'small' | 'medium' | 'large' (default: 'medium', only for PIN_CODE type) */
+    size?: 'small' | 'medium' | 'large';
+    /** Allow only numbers (default: true, only for PIN_CODE type) */
+    allowNumbersOnly?: boolean;
+    /** Mask input - show dots instead of characters (only for PIN_CODE type) */
+    mask?: boolean;
+    /** Auto focus first input (only for PIN_CODE type) */
+    autoFocus?: boolean;
+    /** Custom input styles (only for PIN_CODE type) */
+    inputStyles?: Record<string, string>;
 };
 /**
  * A section in a form, grouping multiple fields.

package/lib/services/auth/auth.service.d.ts

@@ -72,6 +72,7 @@ export declare class AuthService implements OnDestroy {
     ngOnDestroy(): void;
     /**
      * Inicia sesión con email y contraseña.
+     * Detecta automáticamente la plataforma para identificar dispositivos nuevos.
      */
     signin(request: SigninRequest): Observable<SigninResponse>;
     /**

package/lib/services/auth/device.service.d.ts

@@ -0,0 +1,80 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { ValtechAuthConfig, DeviceInfo, DeviceActionResult, DeviceActionResponse } from './types';
+import * as i0 from "@angular/core";
+/**
+ * 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
+ *   }
+ * }
+ * ```
+ */
+export declare class DeviceService {
+    private config;
+    private http;
+    constructor(config: ValtechAuthConfig, http: HttpClient);
+    private get baseUrl();
+    /**
+     * Lista todos los dispositivos registrados del usuario.
+     */
+    listDevices(): Observable<DeviceInfo[]>;
+    /**
+     * Obtiene información de un dispositivo específico.
+     */
+    getDevice(deviceId: string): Observable<DeviceInfo>;
+    /**
+     * Bloquea un dispositivo.
+     * Revoca todas las sesiones activas de ese dispositivo.
+     */
+    blockDevice(deviceId: string): Observable<DeviceActionResult>;
+    /**
+     * Aprueba un dispositivo pendiente.
+     * Cambia el estado de pending_approval a active.
+     */
+    approveDevice(deviceId: string): Observable<DeviceActionResult>;
+    /**
+     * Elimina un dispositivo registrado.
+     */
+    deleteDevice(deviceId: string): Observable<DeviceActionResult>;
+    /**
+     * 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: string): Observable<DeviceActionResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeviceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DeviceService>;
+}

package/lib/services/auth/index.d.ts

@@ -77,3 +77,5 @@ export { AuthStateService } from './auth-state.service';
 export { TokenService } from './token.service';
 export { AuthStorageService } from './storage.service';
 export { AuthSyncService } from './sync.service';
+export { DeviceService } from './device.service';
+export { SessionService } from './session.service';

package/lib/services/auth/session.service.d.ts

@@ -0,0 +1,60 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { ValtechAuthConfig, SessionInfo, RevokeSessionsResponse } from './types';
+import * as i0 from "@angular/core";
+/**
+ * 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 declare class SessionService {
+    private config;
+    private http;
+    constructor(config: ValtechAuthConfig, http: HttpClient);
+    private get baseUrl();
+    /**
+     * Lista todas las sesiones activas del usuario.
+     * La sesión actual está marcada con isCurrent=true.
+     */
+    listSessions(): Observable<SessionInfo[]>;
+    /**
+     * Revoca una sesión específica.
+     * Fuerza el cierre de sesión en ese dispositivo/navegador.
+     */
+    revokeSession(sessionId: string): Observable<RevokeSessionsResponse>;
+    /**
+     * Revoca todas las sesiones excepto la actual.
+     * Útil para "cerrar sesión en todos los dispositivos".
+     *
+     * @returns Número de sesiones revocadas
+     */
+    revokeAllSessions(): Observable<RevokeSessionsResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SessionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SessionService>;
+}

package/lib/services/auth/types.d.ts

@@ -221,6 +221,14 @@ export interface ResendCodeResponse {
 export interface SigninRequest {
     email: string;
     password: string;
+    /** Plataforma del dispositivo (para detección de nuevo dispositivo) */
+    platform?: DevicePlatform;
+    /** Navegador (solo web) */
+    browser?: string;
+    /** Sistema operativo */
+    os?: string;
+    /** Nombre amigable del dispositivo */
+    deviceName?: string;
 }
 /**
  * Response de signin.
@@ -237,6 +245,10 @@ export interface SigninResponse {
     mfaMethod?: MFAMethod;
     roles?: string[];
     permissions?: string[];
+    /** Indica si el login fue desde un dispositivo nuevo/no reconocido */
+    isNewDevice?: boolean;
+    /** ID del dispositivo usado para el login */
+    deviceId?: string;
 }
 /**
  * Request para verificar MFA.
@@ -522,3 +534,112 @@ export interface RegisterDeviceResult {
     /** Mensaje de error (solo si registered=false) */
     error?: string;
 }
+/**
+ * Estados posibles de un dispositivo.
+ */
+export type DeviceStatus = 'active' | 'pending_approval' | 'blocked';
+/**
+ * Información completa de un dispositivo registrado.
+ */
+export interface DeviceInfo {
+    /** ID único del dispositivo */
+    deviceId: string;
+    /** Plataforma del dispositivo */
+    platform: DevicePlatform;
+    /** Navegador (solo web) */
+    browser?: string;
+    /** Sistema operativo */
+    os?: string;
+    /** Nombre amigable del dispositivo */
+    name?: string;
+    /** Estado actual del dispositivo */
+    status: DeviceStatus;
+    /** Dirección IP del último acceso */
+    ipAddress?: string;
+    /** Ubicación geográfica aproximada */
+    location?: string;
+    /** Última actividad */
+    lastActive: string;
+    /** Fecha de creación/registro */
+    createdAt: string;
+    /** Fecha de aprobación (si aplica) */
+    approvedAt?: string;
+    /** Fecha de bloqueo (si aplica) */
+    blockedAt?: string;
+}
+/**
+ * Response de listar dispositivos del usuario.
+ */
+export interface ListDevicesResponse {
+    operationId: string;
+    devices: DeviceInfo[];
+}
+/**
+ * Response de acción sobre dispositivo (block/approve/delete).
+ */
+export interface DeviceActionResult {
+    operationId: string;
+    success: boolean;
+    message: string;
+}
+/**
+ * Información de una sesión activa.
+ */
+export interface SessionInfo {
+    /** ID único de la sesión */
+    sessionId: string;
+    /** ID del dispositivo asociado (si existe) */
+    deviceId?: string;
+    /** Información del dispositivo (User-Agent) */
+    deviceInfo?: string;
+    /** Dirección IP de la sesión */
+    ip?: string;
+    /** Ubicación geográfica aproximada */
+    location?: string;
+    /** Fecha de creación de la sesión */
+    createdAt: string;
+    /** Fecha de expiración de la sesión */
+    expiresAt: string;
+    /** Indica si es la sesión actual del usuario */
+    isCurrent: boolean;
+}
+/**
+ * Response de listar sesiones activas.
+ */
+export interface ListSessionsResponse {
+    operationId: string;
+    sessions: SessionInfo[];
+}
+/**
+ * Response de revocar sesión(es).
+ */
+export interface RevokeSessionsResponse {
+    operationId: string;
+    success: boolean;
+    /** Número de sesiones revocadas */
+    sessionsRevoked: number;
+}
+/**
+ * Request para ejecutar acción de dispositivo desde email.
+ * El token viene en la URL del email de alerta.
+ */
+export interface DeviceActionRequest {
+    /** Token JWT de acción (24h, un solo uso) */
+    token: string;
+}
+/**
+ * Response de ejecutar acción de dispositivo.
+ */
+export interface DeviceActionResponse {
+    operationId: string;
+    /** Si la acción fue ejecutada exitosamente */
+    success: boolean;
+    /** Acción ejecutada (refuse, approve, block) */
+    action: string;
+    /** ID del dispositivo afectado */
+    deviceId: string;
+    /** Número de sesiones revocadas (si action=refuse/block) */
+    sessionsRevoked?: number;
+    /** Mensaje descriptivo */
+    message: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "valtech-components",
-  "version": "2.0.484",
+  "version": "2.0.486",
   "private": false,
   "bin": {
     "valtech-firebase-config": "./src/lib/services/firebase/scripts/generate-sw-config.js"