ngx-dsxlibrary 1.0.53 → 1.0.55

package/index.d.ts

@@ -1,5 +1,648 @@
+import { AbstractControl, FormGroup, FormBuilder, ValidatorFn, ValidationErrors } from '@angular/forms';
+import * as i0 from '@angular/core';
+import { OnInit, ElementRef, InjectionToken, PipeTransform } from '@angular/core';
+import { SweetAlertIcon, SweetAlertResult } from 'sweetalert2';
+import { Observable } from 'rxjs';
+import { HttpInterceptorFn } from '@angular/common/http';
+import { JwtHelperService } from '@auth0/angular-jwt';
+import { CookieService } from 'ngx-cookie-service';
+
+declare class AppMessageErrorComponent {
+    control: AbstractControl | null;
+    form: FormGroup | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppMessageErrorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppMessageErrorComponent, "app-message-error", never, { "control": { "alias": "control"; "required": false; }; "form": { "alias": "form"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class KpicardComponent {
+    option: i0.InputSignal<"currency" | "integer" | "percent">;
+    label: i0.InputSignal<string>;
+    iconType: i0.InputSignal<string>;
+    color: i0.InputSignal<string | undefined>;
+    valor: i0.InputSignal<number>;
+    theme: i0.InputSignal<"light" | "dark" | "aqua" | "sunset" | "mint" | "peach" | "plasma" | "nebula">;
+    options: Record<'currency' | 'integer' | 'percent', any>;
+    getSelectedOption(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KpicardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KpicardComponent, "app-kpicard", never, { "option": { "alias": "option"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "iconType": { "alias": "iconType"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "valor": { "alias": "valor"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class JsonValuesDebujComponent {
+    form: FormGroup;
+    private environment;
+    private readonly isDevSignal;
+    isDev(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JsonValuesDebujComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<JsonValuesDebujComponent, "app-json-values-debuj", never, { "form": { "alias": "form"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class SpinnerLoadingService {
+    spinnerVisible: i0.WritableSignal<boolean>;
+    constructor();
+    show(): void;
+    hide(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpinnerLoadingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SpinnerLoadingService>;
+}
+
+declare class LoadingComponent {
+    currentYear: number;
+    constructor();
+    _spinnerService: SpinnerLoadingService;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LoadingComponent, "app-loading", never, {}, {}, never, never, true, never>;
+}
+
+interface ResponseHttpModel {
+    isSuccess: boolean;
+    statusCode: number;
+    title: string;
+    statusMessage: string;
+    isAdmin: boolean;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * Configuración personalizable para las alertas visuales
+ *
+ * @property icono - Nombre del archivo de imagen ubicado en 'assets/dsxResource/'.
+ *                  Ejemplo: 'success-icon.png'. Por defecto usa 'icon/check02.png'.
+ *
+ * @property icon - Tipo de icono SweetAlert2 incorporado. Valores posibles:
+ *                 'success' | 'error' | 'warning' | 'info' | 'question'.
+ *                 Por defecto: 'success'.
+ *
+ * @property showConfirmButton - Determina si se muestra el botón de confirmación.
+ *                              Cuando es true, desactiva el cierre automático.
+ *                              Por defecto: false.
+ *
+ * @property confirmButtonText - Texto personalizado para el botón de confirmación.
+ *                              Por defecto: 'Ok'.
+ *
+ * @property timer - Tiempo en milisegundos para el cierre automático de la alerta.
+ *                   Se ignora si showConfirmButton es true.
+ *                   Por defecto: 2000 (2 segundos).
+ *
+ * @property imageWidth - Ancho en píxeles para la imagen personalizada.
+ *                       Por defecto: 125.
+ *
+ * @property imageHeight - Alto en píxeles para la imagen personalizada.
+ *                        Por defecto: 125.
+ *
+ * @property showImage - Controla si se muestra la imagen personalizada.
+ *                      Cuando es false, solo se muestra el icono de SweetAlert2.
+ *                      Por defecto: true.
+ *
+ * @example
+ * // Ejemplo de configuración básica
+ * const options: AlertOptions = {
+ *   icono: 'custom-icon.png',
+ *   icon: 'warning',
+ *   timer: 3000
+ * };
+ *
+ * @example
+ * // Ejemplo de alerta con botón de confirmación
+ * const confirmOptions: AlertOptions = {
+ *   showConfirmButton: true,
+ *   confirmButtonText: 'Aceptar',
+ *   showImage: false
+ * };
  */
-/// <amd-module name="ngx-dsxlibrary" />
-export * from './public-api';
+interface AlertOptions {
+    icono?: string;
+    icon?: SweetAlertIcon;
+    showConfirmButton?: boolean;
+    confirmButtonText?: string;
+    timer?: number;
+    imageWidth?: number;
+    imageHeight?: number;
+    showImage?: boolean;
+}
+declare class AlertaService {
+    private toastrService;
+    /**
+     * @param {number} toastrType - 1. Success 2. Info 3. Warning 4. Error
+     * @param {string} toastrTitle - Titulo de la alerta
+     * @param {string} toastrMessage - Mensaje de la alerta
+     * @param {number} toastrAlign - Alineación de la alerta, por defecto 1. OPCIONES: 0. top-left  1. top-center 2. top-right 3. bottom-left 4. bottom-center 5. bottom-right
+     * @param {number} toastrTimer - Tiempo de la alerta default 3000
+     * @returns - Retonar una alerta toastr
+     * */
+    toastrAlerts(toastrType: number, toastrTitle: string, toastrMessage: string, toastrAlign?: number, toastrTimer?: number): void;
+    private preloadImage;
+    alertConfirm(title: string, text: string, icono: string): Promise<boolean>;
+    alertaHtml(titleAlert: string, message: string, icono?: string, timer?: number): Promise<void>;
+    /**
+     * Muestra una alerta visual personalizada usando SweetAlert2 con múltiples opciones de configuración
+     *
+     * @param titleAlert Título principal de la alerta (requerido)
+     * @param messageHtml Mensaje en formato HTML (requerido)
+     * @param options Opciones configurables de la alerta (opcional)
+     *
+     * @returns Promise<SweetAlertResult> que se resuelve cuando el usuario interactúa con la alerta
+     *          o cuando se cierra automáticamente. Puedes usar .then() para manejar la respuesta.
+     *
+     * @example
+     * // Alerta básica con icono de éxito y cierre automático
+     * alertaHtmlSuccess('Operación exitosa', 'Los datos se guardaron correctamente');
+     *
+     * @example
+     * // Alerta de error con imagen personalizada
+     * alertaHtmlSuccess('Error crítico', 'No se pudo conectar al servidor', {
+     *   icono: 'error-icon.png',
+     *   icon: 'error',
+     *   timer: 5000
+     * });
+     *
+     * @example
+     * // Alerta de confirmación con botón
+     * alertaHtmlSuccess('Confirmar acción', '¿Está seguro de eliminar este registro?', {
+     *   showConfirmButton: true,
+     *   confirmButtonText: 'Sí, eliminar',
+     *   icon: 'warning',
+     *   showImage: false
+     * }).then((result) => {
+     *   if (result.isConfirmed) {
+     *     // Lógica cuando el usuario confirma
+     *   }
+     * });
+     */
+    alertaHtmlSuccess(titleAlert: string, messageHtml: string, options?: AlertOptions): Promise<SweetAlertResult>;
+    private configureTimer;
+    toastrHttpResponse(response: ResponseHttpModel): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertaService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AlertaService>;
+}
+
+interface ParameterValue {
+    value: number;
+}
+interface ParameterSecurity {
+    parameterName: string;
+    parameterValues: ParameterValue[];
+}
+interface SeguridadITParameter {
+    sistemaId: number;
+    sistema: string;
+    parameterBase: string | null;
+    parameterSecurity: ParameterSecurity[];
+}
+interface MyParameterValues {
+    parameterName: string;
+    values: number[];
+}
+
+declare class ParameterValuesService {
+    private initialParameters;
+    private _dataParameter;
+    get dataParameter(): MyParameterValues[];
+    set dataParameter(values: MyParameterValues[]);
+    getAllParameterValues(data: SeguridadITParameter): MyParameterValues[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParameterValuesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ParameterValuesService>;
+}
+
+interface ModelToken {
+    token: string;
+    tokenRefresh: string;
+    refreshTokenExpiry: Date;
+}
+
+declare class SecurityService {
+    private http;
+    private environment;
+    private urlApi;
+    /**
+     * Método para obtener un nuevo token de acceso utilizando un refresh token.
+     * @param refreshToken El refresh token que se utilizará para obtener un nuevo token de acceso.
+     * @returns Un Observable que emite un objeto de tipo ModelToken.
+     */
+    tokenRefresh(refreshToken: string): Observable<ModelToken>;
+    /**
+     * Método para obtener los parámetros de seguridad.
+     * @param invalidCacheParam Indica si se debe invalidar la caché (opcional, por defecto es false).
+     * @returns Un Observable que emite un objeto de tipo SeguridadITParameter.
+     */
+    getParameterSecurity(invalidCacheParam?: boolean): Observable<SeguridadITParameter>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SecurityService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SecurityService>;
+}
+
+declare class NavbarDsxComponent implements OnInit {
+    _securityService: SecurityService;
+    _parameterSecurityService: ParameterValuesService;
+    _alertaService: AlertaService;
+    logoWidth: i0.InputSignal<string>;
+    appVersion: i0.InputSignal<string>;
+    urlLogo: i0.InputSignal<string>;
+    checked: boolean;
+    ngOnInit(): void;
+    initializeTheme(): void;
+    onThemeChange(isDarkMode: boolean): void;
+    applyTheme(theme: string): void;
+    actualizarSeguridadIT(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavbarDsxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavbarDsxComponent, "app-navbar-dsx", never, { "logoWidth": { "alias": "logoWidth"; "required": false; "isSignal": true; }; "appVersion": { "alias": "appVersion"; "required": false; "isSignal": true; }; "urlLogo": { "alias": "urlLogo"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directiva que permite solo la entrada de:
+ * - Dígitos (0-9)
+ * - Separadores punto (.)
+ * - Rango con guión (-)
+ *
+ * Ejemplos válidos:
+ * - 1.2.3
+ * - 4-6
+ * - 1.3.5-9
+ *
+ * Restringe:
+ * - Letras
+ * - Espacios
+ * - Caracteres especiales
+ * - Doble punto (..), doble guión (--), o combinaciones como (.-)
+ */
+declare class OnlyRangoPatternDirective {
+    private el;
+    constructor(el: ElementRef<HTMLInputElement>);
+    /**
+     * Expresión regular para permitir caracteres válidos individualmente (tecla por tecla).
+     */
+    private keyRegex;
+    /**
+     * Escucha el evento de teclado y permite únicamente teclas válidas.
+     * También evita combinaciones inválidas como `..`, `--`, `.1`, etc.
+     */
+    onKeyDown(event: KeyboardEvent): void;
+    /**
+     * Previene el pegado de cadenas que no cumplan con la estructura válida.
+     * Solo permite: número o número separados por punto o guión correctamente.
+     */
+    onPaste(event: ClipboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OnlyRangoPatternDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OnlyRangoPatternDirective, "[appOnlyRangoPattern]", never, {}, {}, never, never, true, never>;
+}
+
+declare class SelectAllOnFocusDirective {
+    selectAll(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectAllOnFocusDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectAllOnFocusDirective, "[appSelectAllOnFocus]", never, {}, {}, never, never, true, never>;
+}
+
+declare const CACHE_KEYS: InjectionToken<Record<string, string>>;
+
+interface EnvironmentConfig {
+    production: boolean;
+    myAppUrl: string;
+    tokenName: string;
+    tokenNameRF: string;
+    sessionStatus: string;
+    refreshTokenExpiry: string;
+}
+declare const ENVIRONMENT: InjectionToken<EnvironmentConfig>;
+
+declare const INITIAL_PARAMETERS: InjectionToken<MyParameterValues[]>;
+
+declare const httpAuthorizeInterceptor: HttpInterceptorFn;
+
+type InferCacheKeyType<T extends Record<string, string>> = keyof T;
+/**
+ * Transforma un tipo de mapa `T` cuyas claves son simbólicas
+ * y cuyos valores son nombres de propiedades reales de caché,
+ * a un objeto donde esas propiedades reales son claves booleanas.
+ *
+ * @example
+ * ```ts
+ * type T = { cliente: 'invalidateCacheCliente' };
+ * InferCacheOptions<T> // { invalidateCacheCliente: boolean }
+ * ```
+ */
+type InferCacheOptions<T extends Record<string, string>> = {
+    [K in keyof T as T[K]]: boolean;
+};
+declare function createInitialCache<T extends Record<string, string>>(cacheKeys: T): {
+    -readonly [K in keyof T as T[K]]: boolean;
+};
+
+interface ExportColumn {
+    title: string;
+    dataKey: string;
+}
+interface Column {
+    field: string;
+    header?: string;
+    customExportHeader: string;
+}
+
+interface typeModel<T> {
+    values: T[];
+}
+interface T {
+    [key: string]: any;
+}
+type TipoFechaConversion = 'short' | 'zh';
+interface FechasConversion {
+    nombre: string;
+    tipo: TipoFechaConversion;
+}
+interface FilterOption {
+    value: string;
+    field?: string;
+}
+
+type FieldConfig<T> = {
+    [K in keyof T]: {
+        value: T[K] | null;
+        disabled?: boolean;
+        validators?: any[];
+    };
+};
+
+declare class JsonHighlightPipe implements PipeTransform {
+    transform(value: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JsonHighlightPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<JsonHighlightPipe, "jsonHighlight", true>;
+}
+
+declare class TruncatePipe implements PipeTransform {
+    /**
+     * Transforma una cadena de texto truncándola según los parámetros proporcionados.
+     *
+     * @param value - La cadena de texto que se desea truncar.
+     * @param limit - El número máximo de caracteres permitidos. Por defecto es 100. Si no se encuentra un espacio dentro del límite, usa el límite original (15).
+     * @param completeWords - Si es true, evita cortar palabras a la mitad. Por defecto es false.
+     * @param ellipsis - La cadena que se añadirá al final del texto truncado. Por defecto es '...'.
+     * @returns La cadena truncada con el ellipsis añadido, si es necesario.
+     */
+    transform(value: string, limit?: number, completeWords?: boolean, ellipsis?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TruncatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TruncatePipe, "truncate", true>;
+}
+
+declare class AuthorizeService {
+    private environment;
+    _cookieService: CookieService;
+    helperJwt: JwtHelperService;
+    private _isRefreshing;
+    private getCookieOptions;
+    private setCookie;
+    get isRefreshing(): boolean;
+    set isRefreshing(value: boolean);
+    getToken(): string | null;
+    getTokenRefresh(): string | null;
+    setLastActivity(): void;
+    tokenReload(tokens: ModelToken): void;
+    getTokenValid(token: string | null): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthorizeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthorizeService>;
+}
+
+declare class CacheService<T extends Record<string, string>> {
+    /**
+     * Mapa de claves simbólicas a claves reales de caché.
+     * Se inyecta desde el proyecto consumidor mediante `CACHE_KEYS`.
+     */
+    private keys;
+    /**
+     * Servicio de alerta utilizado para mostrar notificaciones al usuario.
+     */
+    private alert;
+    /**
+     * Estado reactivo que contiene un objeto donde cada propiedad (clave real de caché)
+     * tiene un valor booleano que indica si el caché ha sido invalidado (`true`)
+     * o sigue siendo válido (`false`).
+     *
+     * Este estado es tipado automáticamente en función de los valores de `T`.
+     */
+    private _options;
+    /**
+     * Obtiene el estado actual del caché.
+     * Cada propiedad representa una clave real de caché con su valor booleano.
+     */
+    get options(): InferCacheOptions<T>;
+    /**
+     * Invalida una o más claves simbólicas, marcando su correspondiente
+     * propiedad de caché como `true` (invalidada).
+     *
+     * @param keysToInvalidate - Lista de claves simbólicas (`keyof T`) a invalidar.
+     *
+     * @example
+     * ```ts
+     * cacheService.invalidate(['cliente', 'empresa']);
+     * ```
+     */
+    invalidate(keysToInvalidate?: (keyof T)[] | null): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CacheService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CacheService<any>>;
+}
+
+declare class EndpointService<T> {
+    private http;
+    private environment;
+    private getUrl;
+    list(endpoint: string, invalidateCache?: boolean): Observable<T[]>;
+    edit(endpoint: string, id: number): Observable<T>;
+    save(endpoint: string, values: T): Observable<ResponseHttpModel>;
+    delete(endpoint: string, values: T, softDelete?: boolean): Observable<ResponseHttpModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EndpointService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EndpointService<any>>;
+}
+
+declare class UtilityAddService {
+    private _serviceAlerta;
+    private environment;
+    /**
+     * Convierte una fecha a una cadena de texto formateada según la zona horaria especificada.
+     *
+     * @param {string | Date} fecha - La fecha que se desea convertir. Puede ser una cadena de texto o un objeto Date.
+     * @returns {string | null} - La fecha formateada en la zona horaria especificada o null si la fecha es null.
+     */
+    convertirFechaSegunZonaHoraria(fecha: string | Date): string | null;
+    /**
+     * Convierte una fecha a un objeto Date en formato ISO, opcionalmente ajustando la hora al inicio del día.
+     *
+     * @param {string | Date} fecha - La fecha que se desea convertir. Puede ser una cadena de texto o un objeto Date.
+     * @param {boolean} initHour - Si es true, la hora se ajusta al inicio del día (00:00:00).
+     * @returns {Date | null} - La fecha convertida en formato Date o null si la fecha es null.
+     */
+    convertirFechaISOString(fecha: string | Date, initHour?: boolean): Date | null;
+    /**
+     * Convierte una fecha a una cadena de texto en formato corto (YYYY-MM-DD).
+     *
+     * @param {string | Date} fecha - La fecha que se desea convertir. Puede ser una cadena de texto o un objeto Date.
+     * @param {boolean} initHour - Si es true, la hora se ajusta al inicio del día (00:00:00).
+     * @returns {string | null} - La fecha formateada en formato corto (YYYY-MM-DD) o null si la fecha es null.
+     */
+    convertirFechaShort(fecha: string | Date, initHour?: boolean): string | null;
+    /**
+     * Convierte una fecha a una cadena de texto que representa solo la hora (HH:mm).
+     *
+     * @param {string | Date} fecha - La fecha que se desea convertir. Puede ser una cadena de texto o un objeto Date.
+     * @returns {string | null} - La hora formateada (HH:mm) o null si la fecha es null.
+     */
+    convertirFechaTime(fecha: string | Date): string | null;
+    /**
+     * Convierte una fecha a una cadena de texto en formato timestamp (YYYYMMDD).
+     *
+     * @param {string | Date} fecha - La fecha que se desea convertir. Puede ser una cadena de texto o un objeto Date.
+     * @returns {string | null} - La fecha formateada en formato timestamp (YYYYMMDD) o null si la fecha es null.
+     */
+    convertirTimeStampString(fecha: string | Date): string | null;
+    /**
+     * Crea un FormGroup tipado a partir de una configuración de campos.
+     *
+     * @param {FormBuilder} fb - Instancia de FormBuilder para crear el FormGroup.
+     * @param {FieldConfig<T>} config - Configuración de los campos del formulario.
+     * @param {ValidatorFn[]} groupValidators - Validadores adicionales a nivel de grupo.
+     * @returns {FormGroup} - El FormGroup creado.
+     */
+    createTypedForm<T>(fb: FormBuilder, config: FieldConfig<T>, groupValidators?: ValidatorFn[]): FormGroup;
+    /**
+     * Sanitiza un modelo obteniendo valores de un formulario, aplicando conversiones de fecha según los campos especificados.
+     *
+     * @template T - El tipo genérico del modelo a procesar.
+     * @param form - El formulario reactivo de Angular del que se obtendrán los valores.
+     * @param campos - Un array de objetos que especifican los campos de fecha y el tipo de conversión a aplicar. Cada objeto debe contener:
+     *   - `nombre`: El nombre del campo de fecha en el modelo.
+     *   - `tipo`: El tipo de conversión que se debe aplicar (por ejemplo, `'short'` o `'zh'`).
+     * @param fieldName - (Opcional) El nombre de un campo específico en el formulario que contiene los datos. Si no se proporciona, se obtendrán todos los valores del formulario.
+     * @returns Un objeto del tipo `typeModel<T>` que contiene un array `values` con los datos procesados y las conversiones de fecha aplicadas.
+     * @throws Error - Si el campo especificado no existe en el formulario, o si un campo de fecha especificado no existe en los datos.
+     */
+    sanitizarModelo<T>(form: any, campos: FechasConversion[], fieldName?: string): typeModel<T>;
+    /**
+     * Convierte una fecha al formato especificado.
+     *
+     * @param fecha - La fecha en formato string que se desea convertir.
+     *                Debe estar en un formato reconocible por `Date` o en ISO 8601.
+     * @param tipo - El tipo de conversión a realizar. Actualmente soporta:
+     *               - `'short'`: Convierte la fecha a un formato corto (día/mes/año).
+     *               - `'zh'`: Convierte la fecha considerando la zona horaria configurada.
+     * @returns La fecha convertida como string según el tipo especificado.
+     * @throws Error - Si el tipo de conversión no es válido o soportado.
+     */
+    private convertirFecha;
+    /**
+     * Maneja la respuesta de un archivo descargable
+     * @param fileObservable Observable que emite el Blob del archivo
+     * @param actionId 0 para abrir en nueva ventana, 1 para descargar
+     * @param fileName Nombre del archivo sin extensión
+     */
+    handleFileResponse(fileObservable: Observable<Blob>, actionId: number, fileName: string): void;
+    private isExcelFile;
+    private getFileExtension;
+    private handleNonExcelFiles;
+    private forceDownload;
+    private revokeObjectUrl;
+    /**
+     *
+     * @param message - Texto que se desea mostrar en consola
+     *                  solo se visualiza en desarrollo para evitar mostrar información innecesaria en producción
+     */
+    logIfNotProduction(message: any): void;
+    /**
+     * Marca todos los controles de un formulario como "tocados" y muestra un mensaje de alerta.
+     * @param form - El formulario que se va a validar.
+     */
+    checkFormValid(form: FormGroup): void;
+    /**
+     * Obtiene valores únicos de un campo específico de un array de objetos
+     * @param data Array de objetos de tipo T
+     * @param field Campo del objeto del cual extraer valores únicos
+     * @returns FilterOption[] Listado filtrado, tipado y ordenado alfabéticamente
+     */
+    getUniqueValues<T>(data: T[], field: keyof T): FilterOption[];
+    /**
+     * Función pura que procesa una cadena de texto conteniendo números individuales y/o rangos numéricos,
+     * devolviendo un array con todos los números expandidos.
+     *
+     * @param input - Cadena de texto con el formato: número[.número][.inicio-fin][...]
+     * @returns Array de números con todos los valores individuales y rangos expandidos
+     *
+     * @example
+     * // Uso básico
+     * const result = parseNumericRanges('1.5.7.10-12');
+     * // Retorna: [1, 5, 7, 10, 11, 12]
+     *
+     * @example
+     * // Con espacios y caracteres especiales
+     * const result = parseNumericRanges(' 3. 5-7 .10-12abc');
+     * // Retorna: [3, 5, 6, 7, 10, 11, 12]
+     *
+     * @example
+     * // Rangos invertidos (serán ignorados)
+     * const result = parseNumericRanges('10-8');
+     * // Retorna: [] (array vacío)
+     *
+     * @note
+     * Características especiales:
+     * - Elimina automáticamente espacios y caracteres no numéricos
+     * - Los números deben estar separados por puntos (.)
+     * - Los rangos deben usar guión (-) sin espacios entre números
+     * - Es tolerante a formatos inconsistentes
+     * - Omite elementos inválidos sin generar errores
+     */
+    parseNumericRanges(input: string): number[];
+    /**
+     * Adaptador para procesar eventos de input y extraer rangos numéricos.
+     *
+     * @param event - Objeto Event del DOM, preferiblemente de un elemento input
+     * @returns Array de números generado a partir del valor del input
+     *
+     * @example
+     * // Uso en template Angular
+     * <input (input)="processNumericRangesFromEvent($event)">
+     *
+     * @example
+     * // Uso directo
+     * const result = processNumericRangesFromEvent(inputEvent);
+     *
+     * @note
+     * Esta función es un wrapper que:
+     * - Extrae el valor del input del evento
+     * - Delega el procesamiento a parseNumericRanges()
+     * - Mantiene compatibilidad con eventos de diferentes frameworks
+     *
+     * @dependencies
+     * Requiere que el evento tenga la propiedad target.value (standard DOM)
+     * Para otros tipos de eventos (ej. Angular Material) puede necesitar ajustes
+     */
+    processNumericRangesFromEvent(event: Event): number[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<UtilityAddService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UtilityAddService>;
+}
+
+/**
+ * Valida que el control contenga un rango de fechas válido (dos fechas no nulas y válidas).
+ */
+declare function dateRangeValidator(control: AbstractControl): ValidationErrors | null;
+/**
+ * Valida que una fecha única esté dentro de un rango mínimo y máximo.
+ * @param minDate Fecha mínima permitida.
+ * @param maxDate Fecha máxima permitida.
+ */
+declare function dateMinMaxValidator(minDate: Date, maxDate: Date): (control: AbstractControl) => ValidationErrors | null;
+/**
+ * Valida que al menos uno de los campos especificados esté lleno.
+ * @param fields Los nombres de los campos a validar.
+ */
+declare function atLeastOneFieldRequiredValidator(fields: string[]): (formGroup: AbstractControl) => ValidationErrors | null;
+/**
+ * Validador personalizado para verificar si un NIT (Número de Identificación Tributaria) es válido.
+ * Este validador se puede usar en formularios reactivos de Angular.
+ *
+ * @param control - El control del formulario que contiene el valor del NIT.
+ * @returns Un objeto de error si el NIT no es válido, o `null` si el NIT es válido.
+ */
+declare function nitValidator(control: AbstractControl): ValidationErrors | null;
+/**
+ * Validador personalizado para verificar si un CUI (Código Único de Identificación) es válido.
+ * Este validador se puede usar en formularios reactivos de Angular.
+ *
+ * @param control - El control del formulario que contiene el valor del CUI.
+ * @returns Un objeto de error si el CUI no es válido, o `null` si el CUI es válido.
+ */
+declare function cuiValidator(control: AbstractControl): ValidationErrors | null;
+
+export { AlertaService, AppMessageErrorComponent, AuthorizeService, CACHE_KEYS, CacheService, ENVIRONMENT, EndpointService, INITIAL_PARAMETERS, JsonHighlightPipe, JsonValuesDebujComponent, KpicardComponent, LoadingComponent, NavbarDsxComponent, OnlyRangoPatternDirective, ParameterValuesService, SecurityService, SelectAllOnFocusDirective, TruncatePipe, UtilityAddService, atLeastOneFieldRequiredValidator, createInitialCache, cuiValidator, dateMinMaxValidator, dateRangeValidator, httpAuthorizeInterceptor, nitValidator };
+export type { Column, EnvironmentConfig, ExportColumn, FechasConversion, FieldConfig, FilterOption, InferCacheKeyType, InferCacheOptions, MyParameterValues, ParameterSecurity, ParameterValue, ResponseHttpModel, SeguridadITParameter, T, TipoFechaConversion, typeModel };