valtech-components 2.0.691 → 2.0.692

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

@@ -0,0 +1,401 @@
+import { OnDestroy } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Router } from '@angular/router';
+import { Observable } from 'rxjs';
+import { AuthStateService } from './auth-state.service';
+import { TokenService } from './token.service';
+import { AuthStorageService } from './storage.service';
+import { AuthSyncService } from './sync.service';
+import { SigninRequest, SigninResponse, SignupRequest, SignupResponse, VerifyEmailRequest, VerifyEmailResponse, ResendCodeRequest, ResendCodeResponse, MFAVerifyResponse, RefreshResponse, GetPermissionsResponse, GetProfileResponse, UpdateProfileRequest, UpdateProfileResponse, MFASetupResponse, MFAConfirmResponse, MFADisableResponse, ForgotPasswordRequest, ForgotPasswordResponse, ResetPasswordRequest, ResetPasswordResponse, ChangePasswordResponse, DeleteAccountResponse, SwitchOrgResponse, MFAMethod, AuthError, ValtechAuthConfig, EnableNotificationsResult, NotificationPermissionState, RegisterDeviceResult, TOTPSetupResponse, TOTPVerifySetupResponse, TOTPDisableResponse, RegenerateBackupCodesResponse, BackupCodesCountResponse, OAuthProvider, LinkedProvider, HasPasswordResponse, UpdateHandleResponse, CheckHandleResponse, UpdateAvatarRequest, UpdateAvatarResponse } from './types';
+import { OAuthService } from './oauth.service';
+import { FirebaseService, MessagingService } from '../firebase';
+import { I18nService } from '../i18n';
+import * as i0 from "@angular/core";
+/**
+ * Servicio principal de autenticación.
+ *
+ * @example
+ * ```typescript
+ * import { AuthService } from 'valtech-components';
+ *
+ * @Component({...})
+ * export class LoginComponent {
+ *   private auth = inject(AuthService);
+ *
+ *   async login() {
+ *     await firstValueFrom(this.auth.signin({ email, password }));
+ *     if (this.auth.mfaPending().required) {
+ *       // Mostrar UI de MFA
+ *     } else {
+ *       this.router.navigate(['/']);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare class AuthService implements OnDestroy {
+    private config;
+    private http;
+    private router;
+    private stateService;
+    private tokenService;
+    private storageService;
+    private syncService;
+    private firebaseService;
+    private oauthService;
+    private messagingService;
+    private i18nService;
+    private refreshTimerId;
+    private syncSubscription;
+    constructor(config: ValtechAuthConfig, http: HttpClient, router: Router, stateService: AuthStateService, tokenService: TokenService, storageService: AuthStorageService, syncService: AuthSyncService, firebaseService: FirebaseService, oauthService: OAuthService, messagingService: MessagingService | null, i18nService: I18nService | null);
+    /** Estado completo de autenticación */
+    readonly state: import("@angular/core").Signal<import("./types").AuthState>;
+    /** Usuario está autenticado */
+    readonly isAuthenticated: import("@angular/core").Signal<boolean>;
+    /** Estado de carga */
+    readonly isLoading: import("@angular/core").Signal<boolean>;
+    /** Información del usuario */
+    readonly user: import("@angular/core").Signal<import("./types").AuthUser>;
+    /** Token de acceso */
+    readonly accessToken: import("@angular/core").Signal<string>;
+    /** Roles del usuario */
+    readonly roles: import("@angular/core").Signal<string[]>;
+    /** Permisos del usuario */
+    readonly permissions: import("@angular/core").Signal<string[]>;
+    /** Usuario es super admin */
+    readonly isSuperAdmin: import("@angular/core").Signal<boolean>;
+    /** Estado de MFA pendiente */
+    readonly mfaPending: import("@angular/core").Signal<import("./types").MFAPendingState>;
+    /** Error actual */
+    readonly error: import("@angular/core").Signal<AuthError>;
+    /**
+     * Inicializa el servicio de autenticación.
+     * Llamado automáticamente por provideValtechAuth.
+     */
+    initialize(): Promise<void>;
+    ngOnDestroy(): void;
+    /**
+     * Inicia sesión con email y contraseña.
+     * Detecta automáticamente la plataforma para identificar dispositivos nuevos.
+     */
+    signin(request: SigninRequest): Observable<SigninResponse>;
+    /**
+     * Inicia sesión con OAuth (Google, Apple, Microsoft).
+     * Abre un popup para el flujo de autenticación.
+     *
+     * @param provider - Proveedor OAuth ('google', 'apple', 'microsoft')
+     * @returns Observable que emite SigninResponse cuando se completa
+     *
+     * @example
+     * ```typescript
+     * this.auth.signinWithOAuth('google').subscribe({
+     *   next: () => this.router.navigate(['/']),
+     *   error: (err) => console.error('OAuth failed:', err)
+     * });
+     * ```
+     */
+    signinWithOAuth(provider: OAuthProvider): Observable<SigninResponse>;
+    /**
+     * Vincula un proveedor OAuth adicional a la cuenta actual.
+     * Requiere que el usuario esté autenticado.
+     *
+     * @param provider - Proveedor OAuth a vincular
+     */
+    linkOAuthProvider(provider: OAuthProvider): Observable<{
+        success: boolean;
+    }>;
+    /**
+     * Obtiene los proveedores OAuth vinculados al usuario.
+     */
+    getLinkedProviders(): Observable<LinkedProvider[]>;
+    /**
+     * Desvincula un proveedor OAuth de la cuenta.
+     *
+     * @param provider - Proveedor a desvincular
+     */
+    unlinkOAuthProvider(provider: OAuthProvider): Observable<{
+        success: boolean;
+    }>;
+    /**
+     * Establece contraseña para usuarios que solo tienen OAuth.
+     * Permite que usuarios OAuth-only puedan también usar email/password.
+     *
+     * @param password - Nueva contraseña
+     */
+    setPasswordForOAuthUser(password: string): Observable<{
+        success: boolean;
+    }>;
+    /**
+     * Verifica si el usuario tiene contraseña establecida.
+     * Útil para mostrar/ocultar opciones de cambio de contraseña.
+     */
+    checkHasPassword(): Observable<HasPasswordResponse>;
+    /**
+     * Registra un nuevo usuario.
+     * El usuario queda en estado PENDING hasta verificar su email.
+     */
+    signup(request: SignupRequest): Observable<SignupResponse>;
+    /**
+     * Verifica email con código de 6 dígitos.
+     * Si es exitoso, hace auto-login y retorna tokens.
+     */
+    verifyEmail(request: VerifyEmailRequest): Observable<VerifyEmailResponse>;
+    /**
+     * Reenvía código de verificación al email.
+     */
+    resendCode(request: ResendCodeRequest): Observable<ResendCodeResponse>;
+    /**
+     * Verifica código MFA.
+     */
+    verifyMFA(code: string): Observable<MFAVerifyResponse>;
+    /**
+     * Refresca el token de acceso.
+     * Implementa token rotation: cada refresh genera un nuevo refresh token
+     * que el cliente debe guardar para el próximo refresh.
+     */
+    refreshAccessToken(): Observable<RefreshResponse>;
+    /**
+     * Maneja autenticación exitosa desde fuentes externas (OAuth, etc).
+     * Guarda tokens, actualiza estado, inicia Firebase si corresponde.
+     *
+     * @param authResult - Resultado de autenticación con tokens
+     *
+     * @example
+     * ```typescript
+     * // Desde un flujo OAuth externo
+     * externalOAuth.signIn().subscribe({
+     *   next: (result) => {
+     *     this.authService.setExternalAuth(result);
+     *   }
+     * });
+     * ```
+     */
+    setExternalAuth(authResult: {
+        accessToken: string;
+        refreshToken: string;
+        firebaseToken?: string;
+        expiresIn: number;
+        roles?: string[];
+        permissions?: string[];
+    }): void;
+    /**
+     * Cierra sesión.
+     */
+    logout(): Promise<void>;
+    /**
+     * Configura MFA para el usuario.
+     */
+    setupMFA(method: MFAMethod, phone?: string): Observable<MFASetupResponse>;
+    /**
+     * Confirma la configuración de MFA.
+     */
+    confirmMFA(code: string): Observable<MFAConfirmResponse>;
+    /**
+     * Deshabilita MFA.
+     */
+    disableMFA(password: string): Observable<MFADisableResponse>;
+    /**
+     * Inicia configuración de TOTP MFA.
+     * Retorna el secreto, URL para QR code y códigos de respaldo.
+     */
+    setupTOTP(): Observable<TOTPSetupResponse>;
+    /**
+     * Verifica el código TOTP y activa MFA.
+     * Debe llamarse después de setupTOTP con el código del authenticator.
+     */
+    verifyTOTPSetup(code: string): Observable<TOTPVerifySetupResponse>;
+    /**
+     * Regenera los códigos de respaldo TOTP.
+     * Los códigos anteriores son invalidados.
+     */
+    regenerateBackupCodes(): Observable<RegenerateBackupCodesResponse>;
+    /**
+     * Obtiene la cantidad de códigos de respaldo restantes.
+     */
+    getBackupCodesCount(): Observable<BackupCodesCountResponse>;
+    /**
+     * Desactiva TOTP MFA (requiere contraseña).
+     */
+    disableTOTP(password: string): Observable<TOTPDisableResponse>;
+    /**
+     * Cambia la organización activa del usuario.
+     * Genera un nuevo Firebase token con el activeOrg actualizado.
+     *
+     * @param organizationId - ID de la organización a la que cambiar
+     * @returns Observable con el nuevo Firebase token y activeOrg
+     *
+     * @example
+     * ```typescript
+     * await firstValueFrom(this.auth.switchOrg('org_xyz789'));
+     * // Firebase ya está re-autenticado con la nueva org
+     * const activeOrg = await this.firebase.getActiveOrg();
+     * ```
+     */
+    switchOrg(organizationId: string): Observable<SwitchOrgResponse>;
+    /**
+     * Obtiene el perfil del usuario autenticado.
+     * Incluye información de MFA y teléfono.
+     */
+    getProfile(): Observable<GetProfileResponse>;
+    /**
+     * Actualiza el perfil del usuario.
+     */
+    updateProfile(request: UpdateProfileRequest): Observable<UpdateProfileResponse>;
+    /**
+     * Actualiza el avatar del usuario en el backend.
+     * Nota: El estado local del avatar se maneja a través de getProfile().
+     */
+    updateAvatar(request: UpdateAvatarRequest): Observable<UpdateAvatarResponse>;
+    /**
+     * Inicia el proceso de recuperación de contraseña.
+     * Envía un código al email del usuario.
+     */
+    forgotPassword(request: ForgotPasswordRequest): Observable<ForgotPasswordResponse>;
+    /**
+     * Resetea la contraseña usando el código enviado por email.
+     */
+    resetPassword(request: ResetPasswordRequest): Observable<ResetPasswordResponse>;
+    /**
+     * Cambia la contraseña del usuario autenticado.
+     * Requiere la contraseña actual para verificación.
+     */
+    changePassword(currentPassword: string, newPassword: string): Observable<ChangePasswordResponse>;
+    /**
+     * Elimina la cuenta del usuario (soft delete).
+     * Requiere confirmación de contraseña por seguridad.
+     * Después de eliminar, cierra sesión automáticamente.
+     *
+     * @param password - Contraseña actual para confirmar
+     * @returns Observable con resultado de la eliminación
+     *
+     * @example
+     * ```typescript
+     * async confirmDeleteAccount(password: string) {
+     *   try {
+     *     const result = await firstValueFrom(this.auth.deleteAccount(password));
+     *     console.log(result.message); // "Tu cuenta ha sido eliminada..."
+     *     // Usuario es redirigido automáticamente al login
+     *   } catch (error) {
+     *     // Manejar error (contraseña incorrecta, etc)
+     *   }
+     * }
+     * ```
+     */
+    deleteAccount(password: string): Observable<DeleteAccountResponse>;
+    /**
+     * Obtiene los permisos actualizados del backend.
+     */
+    fetchPermissions(): Observable<GetPermissionsResponse>;
+    /**
+     * Verifica si el usuario tiene un permiso específico.
+     * Formato: "resource:action" (ej: "templates:edit")
+     */
+    hasPermission(permission: string): boolean;
+    /**
+     * Verifica si el usuario tiene alguno de los permisos dados.
+     */
+    hasAnyPermission(permissions: string[]): boolean;
+    /**
+     * Verifica si el usuario tiene todos los permisos dados.
+     */
+    hasAllPermissions(permissions: string[]): boolean;
+    /**
+     * Verifica si el usuario tiene un rol específico.
+     */
+    hasRole(role: string): boolean;
+    /**
+     * Actualiza el handle (@username) del usuario.
+     * @param handle - Nuevo handle (sin @, ej: "victorv")
+     */
+    updateHandle(handle: string): Observable<UpdateHandleResponse>;
+    /**
+     * Verifica si un handle está disponible.
+     * @param handle - Handle a verificar (sin @)
+     */
+    checkHandleAvailability(handle: string): Observable<CheckHandleResponse>;
+    private get baseUrl();
+    private handleSuccessfulAuth;
+    private clearState;
+    private startRefreshTimer;
+    private stopRefreshTimer;
+    private handleSyncEvent;
+    private handleAuthError;
+    private signInWithFirebase;
+    private signOutFirebase;
+    /**
+     * Solicita permisos de notificación y registra el dispositivo.
+     * Usar cuando el usuario acepta recibir notificaciones.
+     *
+     * @example
+     * ```typescript
+     * async onEnableNotifications() {
+     *   const result = await this.auth.enableNotifications();
+     *   if (result.granted) {
+     *     console.log('Notificaciones habilitadas');
+     *   }
+     * }
+     * ```
+     */
+    enableNotifications(): Promise<EnableNotificationsResult>;
+    /**
+     * Desactiva las notificaciones para este dispositivo.
+     * Elimina el token del backend y de FCM.
+     * Usar desde un toggle de preferencias cuando el usuario desactiva notificaciones.
+     *
+     * NOTA: Esto NO revoca el permiso del navegador (el usuario debe hacerlo manualmente
+     * desde la configuración del navegador). Solo elimina el registro del dispositivo.
+     *
+     * @example
+     * ```typescript
+     * async onToggleNotifications(enabled: boolean) {
+     *   if (enabled) {
+     *     await this.auth.enableNotifications();
+     *   } else {
+     *     await this.auth.disableNotifications();
+     *   }
+     * }
+     * ```
+     */
+    disableNotifications(): Promise<{
+        disabled: boolean;
+    }>;
+    /**
+     * Retorna el estado actual de permisos de notificación.
+     *
+     * @returns 'granted' | 'denied' | 'default' | 'unsupported'
+     */
+    getNotificationPermissionState(): NotificationPermissionState;
+    /**
+     * Registra manualmente el dispositivo en el backend.
+     * Útil para sincronizar dispositivos que tienen token FCM pero no están registrados.
+     *
+     * @param providedToken Token FCM opcional. Si se proporciona, se usa directamente
+     *                      sin depender del MessagingService (evita timing issues).
+     * @returns Resultado del registro con deviceId si fue exitoso
+     *
+     * @example
+     * ```typescript
+     * // Sincronizar con token existente (recomendado)
+     * const result = await this.auth.registerDevice(myToken);
+     *
+     * // Sin token, intentará obtenerlo del MessagingService
+     * const result = await this.auth.registerDevice();
+     * ```
+     */
+    registerDevice(providedToken?: string): Promise<RegisterDeviceResult>;
+    /**
+     * Registra el dispositivo en el backend si tiene permisos de notificación.
+     * Se llama automáticamente después de un login exitoso si enableDeviceRegistration=true.
+     */
+    private registerDeviceIfNeeded;
+    /**
+     * Elimina el dispositivo del backend y borra el token FCM.
+     */
+    private unregisterDevice;
+    /**
+     * Detecta información de la plataforma del dispositivo.
+     */
+    private detectPlatformInfo;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, [null, null, null, null, null, null, null, null, null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
+}

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

@@ -0,0 +1,38 @@
+import { EnvironmentProviders, InjectionToken } from '@angular/core';
+import { ValtechAuthConfig } from './types';
+/**
+ * Token de inyección para la configuración de Auth.
+ */
+export declare const VALTECH_AUTH_CONFIG: InjectionToken<ValtechAuthConfig>;
+/**
+ * Configuración por defecto.
+ */
+export declare const DEFAULT_AUTH_CONFIG: Partial<ValtechAuthConfig>;
+/**
+ * Provee el servicio de autenticación a la aplicación Angular.
+ *
+ * @param config - Configuración de autenticación
+ * @returns EnvironmentProviders para usar en bootstrapApplication
+ *
+ * @example
+ * ```typescript
+ * // main.ts
+ * import { bootstrapApplication } from '@angular/platform-browser';
+ * import { provideValtechAuth } from 'valtech-components';
+ * import { environment } from './environments/environment';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideValtechAuth({
+ *       apiUrl: environment.apiUrl,
+ *       enableFirebaseIntegration: true,
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+export declare function provideValtechAuth(config: ValtechAuthConfig): EnvironmentProviders;
+/**
+ * Provee solo el interceptor (para apps que ya tienen AuthService configurado manualmente).
+ */
+export declare function provideValtechAuthInterceptor(): EnvironmentProviders;

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

@@ -0,0 +1,101 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { ValtechAuthConfig, DeviceInfo, DeviceActionResult, DeviceActionResponse, ValidateActionResponse } 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>;
+    /**
+     * Valida un token de acción SIN ejecutarlo.
+     * Útil para mostrar confirmación al usuario antes de ejecutar.
+     * Este endpoint NO requiere autenticación.
+     *
+     * @param token Token JWT de acción
+     * @returns Información del token si es válido
+     *
+     * @example
+     * ```typescript
+     * const token = this.route.snapshot.queryParams['token'];
+     * if (token) {
+     *   const validation = await firstValueFrom(this.deviceService.validateAction(token));
+     *   if (validation.valid) {
+     *     // Mostrar confirmación al usuario
+     *     console.log(`Acción: ${validation.actionType}`);
+     *   }
+     * }
+     * ```
+     */
+    validateAction(token: string): Observable<ValidateActionResponse>;
+    /**
+     * 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/guards.d.ts

@@ -0,0 +1,123 @@
+import { CanActivateFn } from '@angular/router';
+/**
+ * Guard que verifica si el usuario está autenticado.
+ * Redirige a loginRoute si no está autenticado.
+ *
+ * @example
+ * ```typescript
+ * import { authGuard } from 'valtech-components';
+ *
+ * const routes: Routes = [
+ *   {
+ *     path: 'dashboard',
+ *     canActivate: [authGuard],
+ *     loadComponent: () => import('./dashboard.page'),
+ *   },
+ * ];
+ * ```
+ */
+export declare const authGuard: CanActivateFn;
+/**
+ * Guard que verifica si el usuario NO está autenticado.
+ * Redirige a homeRoute si ya está autenticado.
+ * Útil para páginas de login/registro.
+ *
+ * @example
+ * ```typescript
+ * import { guestGuard } from 'valtech-components';
+ *
+ * const routes: Routes = [
+ *   {
+ *     path: 'login',
+ *     canActivate: [guestGuard],
+ *     loadComponent: () => import('./login.page'),
+ *   },
+ * ];
+ * ```
+ */
+export declare const guestGuard: CanActivateFn;
+/**
+ * Factory para crear guard de permisos.
+ * Verifica si el usuario tiene el permiso especificado.
+ *
+ * @param permissions - Permiso o lista de permisos requeridos (OR)
+ * @returns Guard function
+ *
+ * @example
+ * ```typescript
+ * import { authGuard, permissionGuard } from 'valtech-components';
+ *
+ * const routes: Routes = [
+ *   {
+ *     path: 'templates',
+ *     canActivate: [authGuard, permissionGuard('templates:read')],
+ *     loadComponent: () => import('./templates.page'),
+ *   },
+ *   {
+ *     path: 'admin',
+ *     canActivate: [authGuard, permissionGuard(['admin:*', 'super_admin'])],
+ *     loadComponent: () => import('./admin.page'),
+ *   },
+ * ];
+ * ```
+ */
+export declare function permissionGuard(permissions: string | string[]): CanActivateFn;
+/**
+ * Guard que lee permisos desde route.data.
+ * Permite configurar permisos directamente en la definición de rutas.
+ *
+ * @example
+ * ```typescript
+ * import { authGuard, permissionGuardFromRoute } from 'valtech-components';
+ *
+ * const routes: Routes = [
+ *   {
+ *     path: 'admin/users',
+ *     canActivate: [authGuard, permissionGuardFromRoute],
+ *     data: {
+ *       permissions: ['users:read', 'users:manage'],
+ *       requireAll: false  // true = AND, false = OR (default)
+ *     },
+ *     loadComponent: () => import('./users.page'),
+ *   },
+ * ];
+ * ```
+ */
+export declare const permissionGuardFromRoute: CanActivateFn;
+/**
+ * Guard que verifica si el usuario es super admin.
+ *
+ * @example
+ * ```typescript
+ * import { authGuard, superAdminGuard } from 'valtech-components';
+ *
+ * const routes: Routes = [
+ *   {
+ *     path: 'super-admin',
+ *     canActivate: [authGuard, superAdminGuard],
+ *     loadComponent: () => import('./super-admin.page'),
+ *   },
+ * ];
+ * ```
+ */
+export declare const superAdminGuard: CanActivateFn;
+/**
+ * Guard que verifica si el usuario tiene un rol específico.
+ *
+ * @param roles - Rol o lista de roles requeridos (OR)
+ * @returns Guard function
+ *
+ * @example
+ * ```typescript
+ * import { authGuard, roleGuard } from 'valtech-components';
+ *
+ * const routes: Routes = [
+ *   {
+ *     path: 'editor',
+ *     canActivate: [authGuard, roleGuard(['editor', 'admin'])],
+ *     loadComponent: () => import('./editor.page'),
+ *   },
+ * ];
+ * ```
+ */
+export declare function roleGuard(roles: string | string[]): CanActivateFn;