valtech-components 2.0.687 → 2.0.689

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

@@ -1,401 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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;