import * as i0 from '@angular/core';
import * as i1 from '@angular/common';
import { HttpContextToken, HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
import { Observable } from 'rxjs';
import * as CryptoJS from 'crypto-js';

/**
 * Modulo de seguridad
 * @decorators `@NgModule`
 */
declare class SecurityModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SecurityModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SecurityModule, never, [typeof i1.CommonModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SecurityModule>;
}

/**
 * Servicio de cifrado y descifrado de información
 * @decorator `@Injectable()`
 */
declare class CifradoService {
    /**
     * Método que realiza el cifrado de los datos tipo Texto
     * @param data - Texto a cifrar
     * @returns Datos cifrados en modo tex
     */
    cifrar(data: string): string;
    /**
     * Método que descifra el texto
     * @params data - Texto a descifrar
     * @returns Texto descifrado
     */
    descifrar(data: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CifradoService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CifradoService>;
}

declare class ReflectionService {
    private readonly cifradoService;
    constructor(cifradoService: CifradoService);
    /**
     * Valida si la propiedad de un objeto es segura
     * @param data - Objeto a validar
     * @param key - Propiedad del objeto a validar
     * @returns True si es una propiedad segura
     */
    private isValidDecorator;
    /**
     * Valida si la propiedad tiene el decorador de seguridad
     * @param data - Entidad objetivo
     * @param key - Nombre de la propiedad
     */
    private propertyHasDecorator;
    /**
     * Valida si un objeto es seguro
     * @param data - Objeto a validar
     * @returns True si existe el decorador @Secure
     */
    private hasDecorator;
    /**
     * Valida si es un objeto y no esta nulo
     * @param object - Objeto a validar
     * @returns True si es un objeto valido
     */
    private isValidObject;
    /**
     * Cifra los datos especificados
     * @param datos - Datos a cifrar
     * @returns Regresa el objeto con los datos cifrados
     */
    cifrarDatos(datos: unknown): any;
    /**
     * Descifra los datos a partir de una definición
     * @param datos - Datos a descifrar
     * @param definition - Definición de los datos con los decoradores seguros
     * @returns Datos descifrados
     */
    descifrarDatos(datos: unknown, definition: unknown): any;
    /**
     * Cifra el texto especificado
     * @param datos - Contiene los datos que se cifraran
     * @returns Datos cifrados
     */
    private cifrarTexto;
    /**
     * Descifra el texto proporcionado
     * @param datos - Contiene los datos que se descifraran
     * @returns Datos descifrados
     */
    private decifrarTexto;
    static ɵfac: i0.ɵɵFactoryDeclaration<ReflectionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ReflectionService>;
}

/** Request token para el contexto Http */
declare const REQUEST_TOKEN: HttpContextToken<unknown>;
/** Response token para el contexto Http */
declare const RESPONSE_TOKEN: HttpContextToken<unknown>;
/**
 * Interceptor de seguridad que cifra y descifra información sensible en las peticiones Web
 * @decorator `@Injectable()`
 */
declare class RediSecureInterceptor implements HttpInterceptor {
    private readonly reflectionService;
    constructor(reflectionService: ReflectionService);
    intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
    /**
     * Regresa una respuesta HTTP descifrada
     * @param request - Petición web
     * @param response - Respuesta web a descifrar
     * @returns Respuesta http descifrada
     */
    private descifrarResponse;
    /**
     * Cifra los datos de la petición interceptada y regresa una nueva petición con los datos cifrados
     * @param request - Petición Http
     * @returns - Petición con datos cifrados
     */
    private cifrarRequest;
    /**
     * Realiza el cifrado de la petición cuando los datos a cifrar se mandan en la URL
     * @param request - Petición HTTP
     * @returns StringQueryParams cifrados en URL
     */
    private cifrarPeticionUrl;
    static ɵfac: i0.ɵɵFactoryDeclaration<RediSecureInterceptor, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RediSecureInterceptor>;
}

/**
 * Fabrica de decoradores para del modulo de seguridad
 * @param cipher Indica el algoritmo de cifrado
 */
declare function secure(cipher?: string): (target: unknown, propertyKey?: string) => void;
/**
 * Token para decorador de seguridad
 */
declare const TOKEN_SECURE: string;

declare class CifradoBasicoService {
    secretPass: string;
    llave: CryptoJS.lib.WordArray;
    llave_tamanio: number;
    vector: CryptoJS.lib.WordArray;
    vector_tamanio: number;
    iterations: number;
    encrypt_dos(msg: string): string;
    decrypt_dos(transitmessage: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CifradoBasicoService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CifradoBasicoService>;
}

export { CifradoBasicoService, CifradoService, REQUEST_TOKEN, RESPONSE_TOKEN, RediSecureInterceptor, ReflectionService, SecurityModule, TOKEN_SECURE, secure };