general-library-union 3.0.96 → 3.0.97

package/src/app/core/modelos/user.model.d.ts

@@ -0,0 +1,6 @@
+export declare class UserLoginCredentials {
+    login: string;
+    clave: string;
+    aplicacion: string;
+    base: string;
+}

package/src/app/core/plantilla-general/plantilla-general.template.d.ts

@@ -0,0 +1,89 @@
+import { AfterViewInit, OnDestroy, OnInit, Renderer2 } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { AuthService } from '../../core/servicios/auth.service';
+import { MenuService } from '../..//core/servicios/menu.service';
+import { StorageService } from '../../core/servicios/storage.service';
+import { PrimeNGConfig } from 'primeng/api';
+import { ModulosModel } from '../../seguridad/modelos/ModulosModel';
+import { TareasModel } from '../../seguridad/modelos/TareasModel';
+import { AutoComplete } from 'primeng/autocomplete';
+import { AnimationEvent } from '@angular/animations';
+import { CargarControlFuncionalidadService } from '../servicios/cargar-control-funcionalidad.service';
+import { UtilsService } from '../servicios/utils.service';
+import * as i0 from "@angular/core";
+export declare class PlantillaGeneralTemplate implements OnInit, AfterViewInit, OnDestroy {
+    private primeConfig;
+    private renderer;
+    private menuService;
+    private authService;
+    private router;
+    private storage;
+    private activatedRoute;
+    private utilsService;
+    private storageService;
+    private controlFuncionalidad;
+    modulo: string;
+    intervalId: number;
+    menuActive: boolean;
+    mobileMenuActive: boolean;
+    mobileTopbarActive: boolean;
+    menuClick: boolean;
+    topbarItemClick: boolean;
+    activeTopbarItem: string;
+    search: boolean;
+    searchClick: boolean;
+    documentClickListener: () => void;
+    nombreEmpresa: string;
+    modulosDisponibles: ModulosModel[];
+    tareaSeleccionadas: TareasModel;
+    tareasFiltradas: TareasModel[];
+    searchInputViewChild: AutoComplete;
+    constructor(primeConfig: PrimeNGConfig, renderer: Renderer2, menuService: MenuService, authService: AuthService, router: Router, storage: StorageService, activatedRoute: ActivatedRoute, utilsService: UtilsService, storageService: StorageService, controlFuncionalidad: CargarControlFuncionalidadService);
+    /**
+     * Activa ripple de PrimeNG para las animaciones de los botones
+     */
+    ngOnInit(): void;
+    /**
+     * Después de crear la vista y sub-vistas inicializa las tareas y eventos básicos como
+     * el timer de sesión, cargar el menú y eventos del html para ocultar menús.
+     */
+    ngAfterViewInit(): void;
+    /**
+     * Limpia el componente de las subscripciones
+     */
+    ngOnDestroy(): void;
+    /**
+     * Muestra/Esconte el menú principal de navegación
+     * @param event
+     */
+    onMenuButtonClick(event: {
+        preventDefault: () => void;
+    }): void;
+    /**
+     * Si el sitio esta en móviles, muestra/esconde el menú de la barra superior (los tres puntos)
+     * @param event
+     */
+    onTopbarMobileButtonClick(event: {
+        preventDefault: () => void;
+    }): void;
+    /**
+     * Muestra/Esconde los menus emergentes de la barra superior (Buscar, Módulos y Perfil).
+     * @param event
+     * @param item
+     */
+    onTopbarItemClick(event: {
+        preventDefault: () => void;
+    }, item: string): void;
+    /**
+     * Si la pantalla tiene un ancho menor o igual a 991 es un dispositivo móvil.
+     * @returns boolean
+     */
+    private _isMobile;
+    onSearchAnimationEnd(event: AnimationEvent): void;
+    salir(): void;
+    cambioModulo(modulo: ModulosModel, navegar: boolean): void;
+    filterTarea(event: any): void;
+    tareaSeleccion(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlantillaGeneralTemplate, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PlantillaGeneralTemplate, "app-plantilla-general", never, {}, {}, never, never, true, never>;
+}

package/src/app/core/servicios/auth.service.d.ts

@@ -0,0 +1,52 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { UserLoginCredentials } from '../modelos/user.model';
+import { StorageService } from './storage.service';
+import { CargarControlFuncionalidadService } from './cargar-control-funcionalidad.service';
+import { CookieService } from 'ngx-cookie-service';
+import { RolModel } from '../../seguridad/modelos/RolModel';
+import * as i0 from "@angular/core";
+export declare class AuthService {
+    private http;
+    private storageService;
+    private controlFuncionalidad;
+    private cookieService;
+    constructor(http: HttpClient, storageService: StorageService, controlFuncionalidad: CargarControlFuncionalidadService, cookieService: CookieService);
+    /**
+     * Realiza la petición para autenticar al usuario. Devuelve el token que generó el servicio.
+     * @param credentials Objeto con los datos de acceso
+     * @returns Token válido
+     */
+    login(credentials: UserLoginCredentials, urlapinucleo: any, tokenPublico: any): Observable<string>;
+    /**
+     * Devuelve el token almacenado en el storage o vacio si no lo encuentra
+     * @returns Token
+     */
+    getToken(): string;
+    /**
+     * Devuelve el valor asociado a la llave que se encuentra almacenado en el token.
+     * @param key Llave presente en el objeto del token
+     * @returns Valor almacenado
+     */
+    getTokenKey(key: string): string;
+    /**
+     * Indica si el token almacenado en el storage es válido verificando que se
+     * pueda decodificar y que el tiempo actual sea menor al de expiración.
+     * @returns
+     */
+    isTokenValid(): boolean;
+    /**
+     * Borra el token del usuario para invalidar la sesión
+     */
+    deleteToken(): void;
+    /**
+     * Decodifica el token que esta almacenado y devuelve el objeto que representa
+     * @returns Información almacenada en el Token
+     */
+    private _decodeToken;
+    refrescarToken(objeto: any, token: any): Observable<any>;
+    generarTokenPublico(urlnucleo?: any): Observable<any>;
+    seleccionRol(_rolSeleccionado: RolModel, urlnucleo?: any): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
+}

package/src/app/core/servicios/cargar-control-funcionalidad.service.d.ts

@@ -0,0 +1,19 @@
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { StorageService } from './storage.service';
+import { UtilsService } from './utils.service';
+import * as i0 from "@angular/core";
+export declare class CargarControlFuncionalidadService {
+    private httpClient;
+    private storageService;
+    private utilsService;
+    constructor(httpClient: HttpClient, storageService: StorageService, utilsService: UtilsService);
+    cargarFuncionalidad(rol: any, url: string, headers: HttpHeaders): Observable<string>;
+    getControlFuncionalidad(valor: string): boolean;
+    /**
+     * Borra controles de funcionalidad en la sesión
+     */
+    eliminarFuncionalidades(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CargarControlFuncionalidadService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CargarControlFuncionalidadService>;
+}

package/src/app/core/servicios/data-exporter-table.utils.d.ts

@@ -0,0 +1,11 @@
+import "jspdf-autotable";
+export declare class DataExporter {
+    constructor();
+    exportPdf(lista: any[], exportColumns: any[], nombreArchivo: string): void;
+    exportExcel(lista: any[], nombreArchivo: string): Promise<void>;
+    exportExcelColumnas(lista: any[], nombreArchivo: string, columnas: string[], nombreHoja?: string): Promise<void>;
+    saveAsExcelFile(buffer: any, fileName: string): void;
+    exportCSV(lista: any[], columnas: string[], nombreArchivo: string): void;
+    convertirAFormatoCSV(data: any[], columns: string[]): string;
+    descargarArchivoCSV(csvContent: any, nombreArchivo: string): void;
+}

package/src/app/core/servicios/error-interceptor.service.d.ts

@@ -0,0 +1,41 @@
+import { UtilsService } from './utils.service';
+import { Router } from '@angular/router';
+import { AuthService } from './auth.service';
+import { StorageService } from './storage.service';
+import * as i0 from "@angular/core";
+export declare class ErrorIntecertorService {
+    private utilsService;
+    private route;
+    private authService;
+    private storageService;
+    constructor(utilsService: UtilsService, route: Router, authService: AuthService, storageService: StorageService);
+    /**
+    * Muestra un mensaje de error según el tipo de error proporcionado.
+    * @param errorJson El objeto JSON que representa el error.
+    */
+    showError(errorJson: string): void;
+    /**
+     * Muestra un mensaje de información con el código.
+     * @param mensaje El mensaje a mostrar.
+     * @param codigo El código asociado al mensaje.
+     */
+    private showInfo;
+    /**
+     * Muestra una advertencia con detalles adicionales como causa, acción y traza.
+     * @param mensaje El mensaje a mostrar.
+     * @param codigo El código asociado al mensaje.
+     * @param causa La causa del error.
+     * @param accion La acción recomendada.
+     * @param traza La traza del error.
+     */
+    private showWarning;
+    /**
+     * Muestra un mensaje de error con detalles adicionales como el código de error y la traza.
+     * @param mensaje El mensaje a mostrar.
+     * @param errorCode El código de error asociado al mensaje.
+     * @param traza La traza del error.
+     */
+    private showErrorDetails;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorIntecertorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ErrorIntecertorService>;
+}

package/src/app/core/servicios/guardias/auth.guard.d.ts

@@ -0,0 +1,17 @@
+import { CanLoad, Route, Router, UrlSegment } from '@angular/router';
+import { AuthService } from '../../../core/servicios/auth.service';
+import { ToastService } from '../../../core/servicios/toast.service';
+import { StorageService } from '../storage.service';
+import { UtilsService } from '../utils.service';
+import * as i0 from "@angular/core";
+export declare class AuthGuard implements CanLoad {
+    private authService;
+    private utilsService;
+    private route;
+    private toastService;
+    private storageService;
+    constructor(authService: AuthService, utilsService: UtilsService, route: Router, toastService: ToastService, storageService: StorageService);
+    canLoad(route: Route, segments: UrlSegment[]): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthGuard>;
+}

package/src/app/core/servicios/guardias/publico.guard.d.ts

@@ -0,0 +1,13 @@
+import { ActivatedRouteSnapshot, CanActivate, Router, RouterStateSnapshot } from '@angular/router';
+import { AuthService } from '../../../core/servicios/auth.service';
+import { UtilsService } from '../utils.service';
+import * as i0 from "@angular/core";
+export declare class PublicoGuard implements CanActivate {
+    private authService;
+    private route;
+    private utilsService;
+    constructor(authService: AuthService, route: Router, utilsService: UtilsService);
+    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PublicoGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PublicoGuard>;
+}

package/src/app/core/servicios/interceptores/loading-interceptor.d.ts

@@ -0,0 +1,11 @@
+import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { SpinnerService } from '../spinner-service';
+import * as i0 from "@angular/core";
+export declare class LoadingInterceptor implements HttpInterceptor {
+    private spinnerService;
+    constructor(spinnerService: SpinnerService);
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoadingInterceptor>;
+}

package/src/app/core/servicios/interceptores/token-interceptor.service.d.ts

@@ -0,0 +1,26 @@
+import { Router } from '@angular/router';
+import { HttpRequest, HttpHandler, HttpEvent, HttpInterceptor } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { AuthService } from '../auth.service';
+import { StorageService } from '../../servicios/storage.service';
+import { UtilsService } from '../utils.service';
+import { ErrorIntecertorService } from '../error-interceptor.service';
+import * as i0 from "@angular/core";
+export declare class TokenInterceptorService implements HttpInterceptor {
+    private router;
+    private authService;
+    private storage;
+    private errorInterceptor;
+    private storageService;
+    private utilsService;
+    constructor(router: Router, authService: AuthService, storage: StorageService, errorInterceptor: ErrorIntecertorService, storageService: StorageService, utilsService: UtilsService);
+    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    interceptDetalle(request: HttpRequest<any>, next: HttpHandler): Promise<HttpEvent<any>>;
+    setearTokenRequest(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    portaltraerSitioSincrono(url: string, idDBSeguridad: any, idSitio: any, token: string): any;
+    obtenerTokenSyncrono(url: any): any;
+    private navegar;
+    get urlNavegador(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TokenInterceptorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TokenInterceptorService>;
+}

package/src/app/core/servicios/loading.service.d.ts

@@ -0,0 +1,22 @@
+import * as i0 from "@angular/core";
+export declare class LoadingService {
+    private _loadingFullScreen;
+    private _loadingFullScreenObservable$;
+    private _loadingBreadCrumb;
+    private _loadingBreadCrumbObservable$;
+    constructor();
+    /**
+     * Observable del loading full screen
+     */
+    get loadingFullScreen(): import("rxjs").Observable<boolean>;
+    /**
+     * Observable del loading en el breadcrumb
+     */
+    get loadingBreadCrumb(): import("rxjs").Observable<boolean>;
+    startFullScreenLoading(): void;
+    endFullScreenLoading(): void;
+    startBreadCrumLoading(): void;
+    endBreadCrumLoading(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoadingService>;
+}

package/src/app/core/servicios/menu.service.d.ts

@@ -0,0 +1,35 @@
+import { MenuItem } from 'primeng/api/menuitem';
+import { Observable } from 'rxjs';
+import { StorageService } from './storage.service';
+import * as i0 from "@angular/core";
+export declare class MenuService {
+    private storageService;
+    private _menu;
+    private _menuSource;
+    private _breadcrumbSource;
+    private _menuObservable$;
+    private _breadcrumbObservable$;
+    constructor(storageService: StorageService);
+    /**
+     * Observable para los eventos del breadcrumb
+     */
+    get breadcrumb(): Observable<MenuItem[]>;
+    /**
+     * Observable para el menu principal
+     */
+    get menu(): Observable<MenuItem>;
+    /**
+     * Agrega items al breadcrumb
+     * @param items
+     */
+    setBreadcrumb(items: MenuItem[]): void;
+    /**
+     * Consulta la lista de tareas del usuario para cargar el menú
+     * @returns
+     */
+    loadTareas(): Observable<void>;
+    convertToMenuItems(tareas: any[]): MenuItem[];
+    setTareasDelModulo(modulo: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MenuService>;
+}

package/src/app/core/servicios/spinner-service.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+export declare class SpinnerService {
+    private spinnerSubject;
+    spinner$: import("rxjs").Observable<boolean>;
+    show(): void;
+    hide(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpinnerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SpinnerService>;
+}

package/src/app/core/servicios/storage.service.d.ts

@@ -0,0 +1,37 @@
+import { UtilsService } from './utils.service';
+import * as i0 from "@angular/core";
+export declare class StorageService {
+    private utilsService;
+    constructor(utilsService: UtilsService);
+    private rolSeleccionado;
+    setRolSeleccionado(rolSeleccionado: any): void;
+    /**
+     * Guarda un valor string en la clave dada dentro del localStorage
+     * @param key Clave
+     * @param value Valor en formato texto
+     */
+    setItem(key: string, value: string): void;
+    /**
+     * Retorna el valor almacenado en el localStorage bajo la clave dada.
+     * Si no existe y se específica un valor por defecto se retorna el valor
+     * por defecto. En caso que no se especifique ningun valor, se retorna
+     * undefined.
+     * @param key clave
+     * @param defaultValue Valor opcional por defecto
+     * @returns string | undefined
+     */
+    getItem(key: string, defaultValue?: string): string | undefined;
+    /**
+     * Borra del localStorage la clave/valor de la clave dada.
+     * @param key Clave
+     */
+    removeItem(key: string): void;
+    /**
+     * Borra todos los datos del localStorage
+     */
+    clear(): void;
+    getSessionToken(): any;
+    getDecodedJWT(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StorageService>;
+}

package/src/app/core/servicios/template.service.d.ts

@@ -0,0 +1,20 @@
+import { HttpClient } from '@angular/common/http';
+import { StorageService } from './storage.service';
+import { AuthService } from './auth.service';
+import { CookieService } from 'ngx-cookie-service';
+import { UtilsService } from './utils.service';
+import { ErrorIntecertorService } from './error-interceptor.service';
+import * as i0 from "@angular/core";
+export declare class TemplateService {
+    private storageService;
+    private cookieService;
+    private authService;
+    private utilsService;
+    private errorInterceptor;
+    private http;
+    constructor(storageService: StorageService, cookieService: CookieService, authService: AuthService, utilsService: UtilsService, errorInterceptor: ErrorIntecertorService, http: HttpClient);
+    private handleError;
+    getTemplateColor(urlapinucleo: any, codigoAplicacion: any, nombreAplicacion: any): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TemplateService>;
+}

package/src/app/core/servicios/toast.service.d.ts

@@ -0,0 +1,48 @@
+import { MessageService } from 'primeng/api';
+import { UtilsService } from './utils.service';
+import * as i0 from "@angular/core";
+export declare class ToastService {
+    private messageService;
+    private utilsService;
+    private _delay;
+    constructor(messageService: MessageService, utilsService: UtilsService);
+    /**
+     * Muestra el toast con el mensaje de éxito enviado.
+     * @param message
+     * @param title
+     */
+    showSuccess(message: string, title?: string): void;
+    /**
+     * Muestra el toast con el mensaje informativo enviado.
+     * @param message
+     * @param title
+     */
+    showInfo(message: string, title?: string): void;
+    /**
+     * Muestra el toast con el mensaje de advertencia enviado.
+     * @param message
+     * @param title
+     */
+    showWarningPopup(message: string, title?: string): void;
+    /**
+     * Muestra el toast con el mensaje de advertencia enviado.
+     * @param message
+     * @param title
+     */
+    showWarning(message: string, title?: string): void;
+    /**
+     * Muestra el toast con el mensaje de error enviado.
+     * @param message
+     * @param title
+     */
+    showError(message: string, title?: string): void;
+    /**
+     * Agregar un mensaje al servicio para que el toast lo muestre.
+     * @param severity success | info | warn | error
+     * @param title
+     * @param message
+     */
+    private _showMessage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ToastService>;
+}

package/src/app/core/servicios/utils.service.d.ts

@@ -0,0 +1,43 @@
+import { CookieService } from 'ngx-cookie-service';
+import * as i0 from "@angular/core";
+export declare class UtilsService {
+    private cookieService;
+    private document;
+    private RESERVADAS_SQL_NOPUEDECONTENER;
+    private reservadas;
+    constructor(cookieService: CookieService, document: Document);
+    generarLlave(): string;
+    generarPin(cantidad: number): string;
+    rightpad(str: any, length: any, char: any): string;
+    validarCampoNumerico(event: any): void;
+    isNotBlank(str: string | String | null | undefined): boolean;
+    isBlank(str: string | String | null | undefined): boolean;
+    validarCampoObligatorio(valor: any): boolean;
+    capitalizeFully(inputString: string): string;
+    ordenarSelectItemsAlfabeticamente(arrayDeObjetos: any[]): any[];
+    obtenerParametroDeURL(urlString: string, parametro: string): string | null;
+    validarEmail(email: string): boolean;
+    obtenerBase(): (string | null);
+    private validarEspacio;
+    validarTextoSQL(valor: string, obligatorio: boolean, select: boolean, longitud: number, validarSentencia: boolean): (string | null);
+    sleep(ms: number): Promise<void>;
+    validarTextoArchivoJasper(texto: string): (string | null);
+    resizeWindowIFrame(): void;
+    /**
+     * Funcion para mantener la posición actual en el iframe.
+     * @param obj es un "FrameElement"
+     */
+    private resizeIframeKeepPosition;
+    private getDocHeight;
+    obtenerNavegador(): any;
+    obtenerUrlApi(urlapi?: string): string;
+    private getTokenKey;
+    private _decodeToken;
+    getItem(key: string, defaultValue?: string): string | undefined;
+    cambiarTema(tema: ('temaClaro' | 'temaOscuro')): void;
+    calcularPosicionDialog(): void;
+    validarPalabra(texto: string): boolean;
+    isNumeric(value: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UtilsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UtilsService>;
+}

package/src/app/core/sharedlib.module.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class SharedLibModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SharedLibModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SharedLibModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SharedLibModule>;
+}

package/src/app/core/utilidades/color.util.d.ts

@@ -0,0 +1,70 @@
+export declare class ColorUtil {
+    /**
+     * Define las variables CSS del tema y las agrega al documento.
+     * Se definene 9 colores alternativos más el color principal.
+     * Adicional se agregan las componentes HSL del color para hacer
+     * variaciones personalizadas y ajustar la opacidad.
+     * @param color Color principal del tema
+     */
+    static addPalleteToRoot(color: string): void;
+    /**
+     * Mezcla dos colores en proporción a un porcentaje para obtener un
+     * nuevo color.
+     * @param baseColor Color base para mezclar
+     * @param color Color que se quiere mezclar
+     * @param weight Porcentaje que se quiere mezclar. Entre 0 y 1
+     * @returns Color resultante en formato RGB (#AABBCC)
+     */
+    static mix(baseColor: string, color: string, weight: number): string;
+    /**
+     * Aclara un color proporcionalmente.
+     * @param color Color base para modificar
+     * @param percent Porcentaje de blanco que se agrega
+     * @returns Nuevo color más claro
+     */
+    static tint(color: string, percent: number): string;
+    /**
+     * Oscurece un color proporcionalmente.
+     * @param color Color base para modificar
+     * @param percent  Porcentaje de negro que se agrega
+     * @returns Nuevo color más oscuro
+     */
+    static shade(color: string, percent: number): string;
+    /**
+     * Transforma un color en RGB a su equivalente en formato HSL
+     * @param color Color en formato RGB
+     * @returns Arreglo de componentes HSL
+     */
+    static RGB2HSL(color: string): {
+        hue: number;
+        saturation: number;
+        lightness: number;
+    };
+    /**
+     * Retorna 1 (blanco) o 0 (negro) para contrastar el color enviado.
+     * @param color Color del cual se quiere buscar el contraste
+     * @returns Blanco o Negro en RGB
+     */
+    static contrastColor(color: string): number;
+    /**
+     * Valida que la cadena de texto represente un color RGB válido y
+     * retorna las componentes del color en formato de seis caracteres.
+     * @param color Color en formato RGB. Ejemplo: (#000)
+     * @returns String del color sin el simbolo #
+     */
+    private static _normalizeColor;
+    /**
+     * Transforma un color Hexadecimal a Decimal en sus respectivas
+     * comopnenetes.
+     * @param color Color en Hecadecimal para descomponer
+     * @returns Un objeto {red, green, blue} en decimal
+     */
+    private static _getRGBValues;
+    /**
+     * Define una paleta de 10 colores, 5 más claros y 4 más oscuros basados
+     * en el color principal. El color principal será el color medio de la paleta
+     * @param color Color base para definir los demás colores
+     * @returns Arreglo de todos los colores de la paleta
+     */
+    private static _generatePalette;
+}

package/src/app/layout/api/{menuchangeevent.ts → menuchangeevent.d.ts}

@@ -1,4 +1,4 @@
 export interface MenuChangeEvent {
     key: string;
     routeEvent?: boolean;
-}
+}

package/src/app/layout/app.breadcrumb.component.d.ts

@@ -0,0 +1,28 @@
+import { OnDestroy, OnInit, ChangeDetectorRef } from '@angular/core';
+import { Router } from '@angular/router';
+import { MenuItem } from 'primeng/api';
+import { MenuService } from '../core/servicios/menu.service';
+import { UtilsService } from '../core/servicios/utils.service';
+import * as i0 from "@angular/core";
+interface Breadcrumb {
+    label: string;
+    url?: string;
+}
+export declare class AppBreadcrumbComponent implements OnInit, OnDestroy {
+    private router;
+    private menuService;
+    private utilsService;
+    private cd;
+    private subscription;
+    items: MenuItem[];
+    home: MenuItem;
+    private readonly _breadcrumbs$;
+    readonly breadcrumbs$: import("rxjs").Observable<Breadcrumb[]>;
+    constructor(router: Router, menuService: MenuService, utilsService: UtilsService, cd: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private addBreadcrumb;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppBreadcrumbComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppBreadcrumbComponent, "app-breadcrumb", never, {}, {}, never, never, true, never>;
+}
+export {};

package/src/app/layout/app.footer.component.d.ts

@@ -0,0 +1,8 @@
+import { LayoutService } from './service/app.layout.service';
+import * as i0 from "@angular/core";
+export declare class AppFooterComponent {
+    layoutService: LayoutService;
+    constructor(layoutService: LayoutService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppFooterComponent, "app-footer", never, {}, {}, never, never, true, never>;
+}