import * as i0 from '@angular/core';
import { Observable } from 'rxjs';
import { ActivatedRoute } from '@angular/router';

/**
 * Servicio que provee métodos para trabajar con datos CSV
 */
declare class CsvService {
    /**
       * Genera el texto CSV a partir de un archivo
       * @param data- Datos a construir
       * @returns CSV texto
       */
    generarCsv<T extends {}>(data: Array<T>): string;
    /**
     * Método que indica si la propiedad es serializable
     * @param propiedad - Propiedad a validar
     * @returns True si es una propiedad serializable
     */
    private tipoSerializable;
    /**
     * Descarga el CSV a partir de los datos establecidos
     * @param archivo - Nombre del archivo a descargar
     * @param data - Arreglo de datos a descargar
     */
    descargarCsv<T extends {}>(archivo: string, data: Array<T>): void;
    /**
     * Genera el link para el blob y archivo establecidos
     * @param archivo - Nombre del archivo a descargar
     * @param blob - Contenido del blob
     * @returns link
     */
    private generarLink;
    static ɵfac: i0.ɵɵFactoryDeclaration<CsvService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CsvService>;
}

/**
 * Interface de suscripción para compartir datos
 */
interface DataSubject<T> {
    /**
     * Realiza la propagación de datos a los suscriptores
     * @param {T} data - Dato a propagar
     */
    broadcast(data: T): void;
    /**
     * Obtiene los datos propagados
     * @return {T} datos
     */
    get data(): T;
    /**
     * Observable de datos
     * @return {Observer<T>} Observable<T>
     */
    get observer(): Observable<T>;
}

/**
 * Servicio para compartir datos
 * @decorators `@Injectable`
 */
declare class DataSubjectService<T> implements DataSubject<T> {
    /**
     * Crea un nuevo servicio de Datos compartidos
     */
    constructor();
    /**
     * Contiene el subject que emite datos
     */
    private readonly subject;
    /**
     * Datos internos
     */
    private _data;
    /**
     * Emite los datos a los subscriptores
     * @param data Datos a emitir
     */
    broadcast(data: T): void;
    /**
     * Contiene el ultimo dato emitido
     */
    get data(): T;
    /**
     * Observable  que notifica los cambios
     */
    get observer(): Observable<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DataSubjectService<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DataSubjectService<any>>;
}

/**
 * Servicio para compartir datos entre micro-fronts
 * @decorators `@Injectable`
 */
declare class BagDataSubjectService {
    /**
     * Crea un nuevo servicio de datos compartido
     */
    constructor();
    /**
     * Obtiene el subjet dada un identificador
     * @param subject Identificador
     * @returns Servicio de datos
     */
    getSubject<T>(subject: string): DataSubjectService<T>;
    /**
     * Asigna los datos a un servicio mediante su identificador
     * @param subject Identificador del servicio
     * @param data Datos a emitir
     */
    setData<T>(subject: string, data: T): void;
    /**
     * Obtiene el ultimo dato del servicio especificando su identificador
     * @param subject Identificador del servicio
     * @returns Dato
     */
    getData<T>(subject: string): T;
    /**
     * Obtiene el observable especificando el servicio
     * @param subject Identificador del servicio
     * @returns Observable<T>
     */
    getObservable<T>(subject: string): Observable<T>;
    /**
     * Objeto contenedor de los subjects
     */
    private subjects;
    static ɵfac: i0.ɵɵFactoryDeclaration<BagDataSubjectService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BagDataSubjectService>;
}

/**
 * Interface que contiene los filtros de parámetros
 */
interface QueryFilters {
    /**
     * Indica que elementos están seleccionados
     */
    seleccionados: Array<string>;
    /**
     * Indica que elementos están deseleccionados
     */
    deseleccionados: Array<string>;
    /**
     * Indica que elementos se eliminan
     */
    eliminados: Array<string>;
    /**
     * Indica que elementos se filtran
     */
    filtrados: Array<string>;
    /**
     * Indica si se selecciona todo
     */
    seleccionarTodo: boolean;
    /**
     * Contiene el nombre del servicio que comparten datos
     */
    servicio: string;
}

/**
 * Servicio de filtro de datos para query params
 * @decorators `@Injectable`
 */
declare class QueryFiltersService {
    private readonly rutaActiva;
    /**
     * Crea una nueva instancia de QueryFilter
     * @param {ActivatedRoute} rutaActiva - Servicio de ruta
     */
    constructor(rutaActiva: ActivatedRoute);
    /**
     * Obtiene los filtros de la ruta
     * @returns Observable<QueryFilters>
     */
    getQueryFilters(): Observable<QueryFilters>;
    getSnapFilters(state: string): QueryFilters;
    generateFilter(url: string): QueryFilters | undefined;
    /**
     * Obtiene los datos de los parámetros establecidos
     * @param {Params} param - Parámetros
     * @param {string} key - Clave del parámetro
     * @returns Arreglo de parámetros
     */
    private getData;
    static ɵfac: i0.ɵɵFactoryDeclaration<QueryFiltersService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<QueryFiltersService>;
}

declare class FormBindService {
    constructor();
    setValues<T extends {}>(entity: T, formGroup: unknown): void;
    updateValues<T extends {}>(entity: T, formGroup: unknown): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormBindService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FormBindService>;
}

declare class LocationService {
    private readonly router;
    constructor();
    navigate(path: string): void;
    getRelative(relativePath?: string): Array<string>;
    private getCurrentPath;
    static ɵfac: i0.ɵɵFactoryDeclaration<LocationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LocationService>;
}

export { BagDataSubjectService, CsvService, DataSubjectService, FormBindService, LocationService, QueryFiltersService };
export type { QueryFilters };