fpavon-ee-shared 1.0.0 → 1.0.2

package/dist/dependency-injection/dependency-injection.d.ts

@@ -0,0 +1,3 @@
+import { ContainerBuilder } from 'node-dependency-injection';
+declare let container: ContainerBuilder;
+export default container;

package/dist/digitalSignature/application/digitalSignature.useCase.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+export declare function obtenerFirmasDocumento(uuid: string): Promise<any[]>;
+export declare function firmarDocumento(documento: Buffer, firma: any, usuario: any, clave: any): Promise<Buffer>;
+export declare function firmarDocumento2(token: string, uuid: any, firma: any, clave: any, x1: any, y1: any, page: any): Promise<string>;

package/dist/digitalSignature/domain/PDFArrayCustom.d.ts

@@ -0,0 +1,17 @@
+import { PDFArray } from "pdf-lib";
+/**
+ * Extends PDFArray class in order to make ByteRange look like this:
+ *  /ByteRange [0 /********** /********** /**********]
+ * Not this:
+ *  /ByteRange [ 0 /********** /********** /********** ]
+ *
+ * @see https://github.com/Hopding/pdf-lib/issues/112#issuecomment-569085380
+ * @author https://github.com/Hopding
+ */
+export default class PDFArrayCustom extends PDFArray {
+    static withContext(context: any): any;
+    clone(context: any): any;
+    toString(): string;
+    sizeInBytes(): number;
+    copyBytesInto(buffer: any, offset: any): number;
+}

package/dist/digitalSignature/domain/SignPDF.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+export default class SignPDF {
+    pdfDoc: any;
+    certificate: any;
+    constructor(pdfFile: any, certFile: any);
+    /**
+     * @return Promise<Buffer>
+     */
+    signPDF(clave: any): Promise<Buffer>;
+    /**
+     * @see https://github.com/Hopding/pdf-lib/issues/112#issuecomment-569085380
+     * @returns {Promise<Buffer>}
+     */
+    _addPlaceholder(): Promise<Buffer>;
+    /**
+     * @param {Uint8Array} unit8
+     */
+    static unit8ToBuffer(unit8: any): Buffer;
+}

package/dist/documentos/application/documentos.useCase.d.ts

@@ -0,0 +1,11 @@
+import { IDocumentosRepository } from "../domain/documento.repository";
+import { DocumentoFTP } from "../domain/documentoFTP";
+export declare class DocumentosUseCase {
+    private readonly documentosRepository;
+    constructor(documentosRepository: IDocumentosRepository);
+    crearDocumento: (archivo: any) => Promise<import("../domain/documentoFTP").IDocumentoFTP>;
+    private bufferToStream;
+    crearDocumentoByBuffer: (file: any) => Promise<import("../domain/documentoFTP").IDocumentoFTP>;
+    getDocumentoAdjunto: (uuid: string) => Promise<DocumentoFTP>;
+    deleteDocumento: (uuid: any) => Promise<Boolean>;
+}

package/dist/documentos/domain/documento.class.d.ts

@@ -0,0 +1,40 @@
+import { IDocumento } from "./documento.interface";
+export declare class ImplementacionWorkflow {
+    /**
+     * @param workflowId id del workflow que se esta implentando
+     */
+    workflowId: number;
+    /**
+     * @param firmas arreglo de usuarios firmantes del workflow.
+     */
+    firmas: Firma[];
+    /**
+     * @param unidad la unidad actual en la que se encuentra el wf.
+     */
+    unidad: string;
+    informacionAdicional: string;
+    estado: string;
+    motivoRechazoFinalizacion: string;
+    permitirCompartirExpediente: boolean;
+    constructor(params: any);
+}
+export declare class Firma {
+    usuario: any;
+    fecha: Date;
+    constructor(usuario: any);
+}
+export declare class Documento<TWorkflowState = ImplementacionWorkflow> implements IDocumento {
+    uuid: string;
+    extras: any;
+    fecha?: Date;
+    firmado: boolean;
+    lastUpdate?: Date;
+    descripcion: string;
+    nombre: string;
+    size: string;
+    estadoWorkflow?: TWorkflowState[];
+    constructor(uuid: string, nombre: string, descripcion: string, size: string, opciones?: {
+        lastUpdate?: Date;
+        extras?: any;
+    }, firmado?: boolean, estadoWorkflow?: TWorkflowState[], fecha?: any);
+}

package/dist/documentos/domain/documento.interface.d.ts

@@ -0,0 +1,8 @@
+export interface IDocumento {
+    uuid: string;
+    extras?: any;
+    fecha?: Date;
+    lastUpdate?: Date;
+    nombre: string;
+    descripcion: string;
+}

package/dist/documentos/domain/documento.repository.d.ts

@@ -0,0 +1,11 @@
+import { IDocumentoFTP } from "./documentoFTP";
+export interface IDocumentosRepository {
+    /** INSERT */
+    createDocumento(documento: IDocumentoFTP): Promise<IDocumentoFTP>;
+    createDocumentoBuffer(documento: IDocumentoFTP): Promise<IDocumentoFTP>;
+    createDocumentoFromBuffer(documento: IDocumentoFTP): Promise<IDocumentoFTP>;
+    getDocumentoById(id: any): Promise<IDocumentoFTP>;
+    deleteDocumento(id: any): Promise<Boolean>;
+    modifyDocumento(documentoModificado: IDocumentoFTP): Promise<IDocumentoFTP>;
+    ver(params: any): any;
+}

package/dist/documentos/domain/documentoFTP.d.ts

@@ -0,0 +1,9 @@
+export interface IDocumentoFTP {
+    uuid: any;
+    archivo: any;
+}
+export declare class DocumentoFTP implements IDocumentoFTP {
+    uuid: any;
+    archivo: any;
+    constructor(archivo: any);
+}

package/dist/documentos/domain/value-object/uuid.d.ts

@@ -0,0 +1,7 @@
+export declare class UUID {
+    private value;
+    constructor();
+    getValue(): string;
+    equals(other: UUID): boolean;
+    static validate(uuid: string): boolean;
+}

package/dist/documentos/infrastructure/repository/documentos.ftp.repository.d.ts

@@ -0,0 +1,14 @@
+import { FtpConnection } from "../../../infrastructure/fileServer/fileServer.basic-ftp";
+import { IDocumentosRepository } from "../../domain/documento.repository";
+import { DocumentoFTP, IDocumentoFTP } from "../../domain/documentoFTP";
+export declare class DocumentosFTPRepository implements IDocumentosRepository {
+    private fptClient;
+    constructor(fptClient: FtpConnection);
+    createDocumento(documento: IDocumentoFTP): Promise<DocumentoFTP>;
+    createDocumentoFromBuffer(documento: DocumentoFTP): Promise<DocumentoFTP>;
+    createDocumentoBuffer(documento: IDocumentoFTP): Promise<IDocumentoFTP>;
+    getDocumentoById(uuid: string): Promise<DocumentoFTP>;
+    deleteDocumento(uuid: any): Promise<Boolean>;
+    modifyDocumento(documentoModificado: IDocumentoFTP): Promise<IDocumentoFTP>;
+    ver(params: any): Promise<void>;
+}

package/dist/estados/application/flujos.useCase.d.ts

@@ -0,0 +1,6 @@
+import { IFlujosRepository } from "../domain/flujos.repository";
+export declare class FlujosUseCase {
+    private readonly flujosRepository;
+    constructor(flujosRepository: IFlujosRepository);
+    getFlujoByModulo: (modulo: string) => Promise<import("../domain/estado.class").Flujo>;
+}

package/dist/estados/domain/estado.class.d.ts

@@ -0,0 +1,61 @@
+export interface EstadoFlujo {
+    /**
+     * @argument grupoRequerido Indica el grupo que debe tener un usuario para operar en este estado.
+     */
+    grupoRequerido: string;
+    /**
+     * @argument requiereSupervision Indica si el estado requiere una supervision. Para supervisar se requiere el rol supervisar.
+     */
+    requiereSupervision: boolean;
+    /**
+     * @argument requiereAprobacion Indica si el estado requiere una aprobacion de un usuario administrador.
+     */
+    requiereAprobacion: boolean;
+    /**
+     * @argument requiereFirma Indica si el estado requiere una firma electronica. Para firmar se necesita el rol firmar.
+     */
+    requiereFirma: boolean;
+    /**
+     * @argument cantidadDeFirmasRequeridas Indica la cantidad de firmas requeridas para realizar la aprobacion, en caso de requiereFirma=true.
+     * Si se requiere firma, al alcanzar la cantidad de firmas requeridas, se procede a la autorizacion del estado.
+     */
+    cantidadDeFirmasRequeridas: number;
+    derivacion: string | null;
+    /**
+    * @argument puedeObservarse Indica si el estado puede observarse. Al observar una solicitud se vuelve al estado anterior con el flag observado en true.
+    * Para observar se requiere el rol observar
+    */
+    puedeObservarse: boolean | null;
+    /**
+     * @argument estadoSiguiente Indica el estado siguiente al que debe avanzar en caso de aprobarse el estado actual.
+     */
+    estadoSiguiente: string;
+}
+export interface Flujo {
+    [key: string]: EstadoFlujo;
+}
+export declare class Estado {
+    nombre: string;
+    modulo: string;
+    exito: boolean;
+    firmado: boolean;
+    supervisado: boolean;
+    observado: boolean;
+    derivado: boolean;
+    devuelto: boolean;
+    cantidadDeFirmas: number;
+    firmantes: string[];
+    leido: boolean;
+    seModifico: boolean;
+    esVisiblePor: any[];
+    constructor(estadoParams: any);
+    static estadoPorDefault(): Estado;
+    autorizar(usuario: any, flujo: Flujo): Estado;
+    rechazar(usuario: any, flujo: Flujo): Estado;
+    cancelar(usuario: any, flujo: Flujo): Estado;
+    observar(usuario: any, flujo: Flujo): this;
+    supervisar(usuario: any, flujo: Flujo): this;
+    devolver(usuario: any, flujo: Flujo): this;
+    firmar(usuario: any, flujo: Flujo): Estado;
+    setFlagExito(exito: boolean): void;
+}

package/dist/estados/domain/flujos.repository.d.ts

@@ -0,0 +1,7 @@
+import { Flujo } from "./estado.class";
+export interface IFlujosRepository {
+    insert(flujo: Flujo): Promise<Flujo>;
+    selectByModulo(modulo: string): Promise<Flujo>;
+    update(flujo: Flujo): Promise<Flujo>;
+    delete(modulo: string): Promise<boolean>;
+}

package/dist/estados/infrastructure/controller/flujos.controller.d.ts

@@ -0,0 +1,6 @@
+import { FlujosUseCase } from "../../application/flujos.useCase";
+export declare class FlujosController {
+    private readonly flujosUseCase;
+    constructor(flujosUseCase: FlujosUseCase);
+    getFlujoByModulo: (req: Request, res: Response) => Promise<void>;
+}

package/dist/estados/infrastructure/repositories/flujos.sql.repository.d.ts

@@ -0,0 +1,9 @@
+import { Flujo } from "../../domain/estado.class";
+import { IFlujosRepository } from "../../domain/flujos.repository";
+export declare class FlujosRepository implements IFlujosRepository {
+    insert(flujo: Flujo): Promise<Flujo>;
+    selectByModulo(modulo: string): Promise<Flujo>;
+    update(flujo: Flujo): Promise<Flujo>;
+    delete(modulo: string): Promise<boolean>;
+    delete2(): void;
+}

package/dist/estados/infrastructure/routes/flujo.route.d.ts

@@ -0,0 +1,2 @@
+declare const route: any;
+export default route;

package/dist/expediente-electronico/application/expediente-electronico.useCase.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="node" />
+import { ExpedienteElectronico } from '../domain/expediente-electronico.class';
+import { IExpedienteElectronicoRepository } from '../domain/expediente-electronico.repository';
+export declare class ExpedienteElectronicoUseCase {
+    private readonly expedienteRepo;
+    constructor(expedienteRepo: IExpedienteElectronicoRepository);
+    getExpedienteByIdUseCase: (id: string) => Promise<ExpedienteElectronico>;
+    getExpedienteByIdCodigoInterno: (codigoInterno: string) => Promise<ExpedienteElectronico>;
+    getExpUseCase: (usuario: any, page: number, limit: number, estado?: string[], filtro?: any) => Promise<{
+        totalRecords: number;
+        expedientes: import("../domain/expediente-electronico.interface").IExpedienteElectronico[];
+    }>;
+    getExpSinPaginacionUseCase: (usuario: any, estado?: string[], filtros?: {
+        [key: string]: string;
+    }) => Promise<{
+        totalRecords: number;
+        expedientes: import("../domain/expediente-electronico.interface").IExpedienteElectronico[];
+    }>;
+    getExpPendientesUseCase: (usuario: any, page: number, limit: number) => Promise<{
+        totalRecords: number;
+        expedientes: import("../domain/expediente-electronico.interface").IExpedienteElectronico[];
+    }>;
+    getExpPendientesSinPaginadoUseCase: (usuario: any) => Promise<{
+        totalRecords: number;
+        expedientes: import("../domain/expediente-electronico.interface").IExpedienteElectronico[];
+    }>;
+    getExpRechazadosUseCase: (usuario: any, page: number, limit: number) => Promise<{
+        totalRecords: number;
+        expedientes: import("../domain/expediente-electronico.interface").IExpedienteElectronico[];
+    }>;
+    getExpAprobadosUseCase: (usuario: any, page: number, limit: number) => Promise<{
+        totalRecords: number;
+        expedientes: import("../domain/expediente-electronico.interface").IExpedienteElectronico[];
+    }>;
+    getExpTotalesUseCase: (usuario: any) => Promise<number>;
+    getExpCantidadPendientesUseCase: (usuario: any) => Promise<number>;
+    getExpCantidadAprobadosUseCase: (usuario: any) => Promise<number>;
+    getExpCantidadRechazadosUseCase: (usuario: any) => Promise<number>;
+    guardarNotaUseCase: (idExpediente: any, notaParams: any, usuario: any) => Promise<ExpedienteElectronico>;
+    leerNotaUseCase: (idExpediente: any, usuario: any) => Promise<ExpedienteElectronico>;
+    getAllUnidades: () => Promise<string[]>;
+    getUnidadesByUnidad: (unidad: string) => Promise<string[]>;
+    firmarDocumentoUseCase: (documento: any, usuario: any, firma: any, clave: any) => Promise<Buffer>;
+}

package/dist/expediente-electronico/domain/expediente-electronico.class.d.ts

@@ -0,0 +1,61 @@
+import { Documento } from "../../documentos/domain/documento.class";
+import { Estado, Flujo } from "../../estados/domain/estado.class";
+import { IExpedienteElectronico } from "./expediente-electronico.interface";
+import { Nota } from "./value-object/notas.class";
+export declare class ExpedienteElectronico implements IExpedienteElectronico {
+    id: number;
+    fechaAlta: Date;
+    fechaCierre: Date;
+    usuarioResponsable: any;
+    titulo: string;
+    descripcion: string;
+    tipo: string;
+    codigoInterno: string;
+    bitacora: any;
+    private documentos;
+    private estado;
+    notas: Nota[];
+    extras: any;
+    origen: string;
+    destino: string;
+    constructor(params: any);
+    private asignarBitacora;
+    static fromRecordset(recordset: any): ExpedienteElectronico;
+    /**
+     * Setea un estado al expediente. Si el estado es undefined, se setea un estado por default.
+     * @param estado El estado que se quiere setear al expediente
+     */
+    setEstado(estado?: Estado): void;
+    /**
+     *
+     * @returns Devuelve el estado actual del expediente.
+     */
+    getEstado(): Estado;
+    /**
+     * Setea un arreglo de documentos al expediente
+     * @param documentos El nuevo arreglo de documentos que se quiere setear al expediente
+     */
+    setDocumentos(documentos: Documento[]): void;
+    /**
+     * Agrega un nuevo documento al arreglo de documentos del expediente.
+     * @param documento El documento que se quiere agregar al arreglo de documentos del expediente.
+     */
+    pushDocumento(documento: Documento): void;
+    /**
+     * Reemplaza el documento que esta en el indice indicado por el que se envia como parametro.
+     * @param index: Indice del docuemento a reemplazar.
+     * @param documento El documento que reemplaza al anterior.
+     */
+    modificarDocumento(index: number, documento: Documento): void;
+    getDocumentos(): Documento[];
+    avanzarEstado(usuario: any, flujo: Flujo): void;
+    updateFlagExito(exito: boolean): void;
+    supervisar(usuario: any, flujo: Flujo): void;
+    observar(usuario: any, flujo: Flujo): void;
+    rechazar(usuario: any, flujo: Flujo): void;
+    cancelar(usuario: any, flujo: Flujo): void;
+    devolver(usuario: any, flujo: Flujo): void;
+    firmar(usuario: any, flujo: Flujo): void;
+    getAtributos(): any;
+    static transferirExpediente(expediente: ExpedienteElectronico, oficinaResponsable: any): Estado;
+}

package/dist/expediente-electronico/domain/expediente-electronico.interface.d.ts

@@ -0,0 +1,16 @@
+import { Nota } from "./value-object/notas.class";
+export interface IExpedienteElectronico {
+    id: number;
+    fechaAlta: Date;
+    fechaCierre: Date;
+    usuarioResponsable: any;
+    titulo: string;
+    descripcion: string;
+    tipo: string;
+    codigoInterno: string;
+    bitacora: any;
+    notas: Nota[];
+    extras: any;
+    origen: string;
+    destino: string;
+}

package/dist/expediente-electronico/domain/expediente-electronico.repository.d.ts

@@ -0,0 +1,51 @@
+import { ExpedienteElectronico } from "./expediente-electronico.class";
+import { IExpedienteElectronico } from "./expediente-electronico.interface";
+export interface IExpedienteElectronicoRepository {
+    getExpedienteById(id: string): Promise<ExpedienteElectronico>;
+    getExpedienteByCodigoInterno(codigoInterno: string): Promise<ExpedienteElectronico>;
+    getExpRepo(usuario: any, pagination?: {
+        offset: number;
+        limitClause: string;
+    }, estado?: string[], filtro?: string): Promise<{
+        totalRecords: number;
+        expedientes: IExpedienteElectronico[];
+    }>;
+    getExpSinPaginacionRepo(usuario: any, estado?: string[], filtros?: {
+        [key: string]: string;
+    }): Promise<{
+        totalRecords: number;
+        expedientes: IExpedienteElectronico[];
+    }>;
+    getExpPendientesRepo(usuario: any, pagination?: {
+        offset: number;
+        limitClause: string;
+    }): Promise<{
+        totalRecords: number;
+        expedientes: IExpedienteElectronico[];
+    }>;
+    getExpPendientesSinPaginacionRepo(usuario: any): Promise<{
+        totalRecords: number;
+        expedientes: IExpedienteElectronico[];
+    }>;
+    getExpRechazadosRepo(usuario: any, pagination?: {
+        offset: number;
+        limitClause: string;
+    }): Promise<{
+        totalRecords: number;
+        expedientes: IExpedienteElectronico[];
+    }>;
+    getExpAprobadosRepo(usuario: any, pagination?: {
+        offset: number;
+        limitClause: string;
+    }): Promise<{
+        totalRecords: number;
+        expedientes: IExpedienteElectronico[];
+    }>;
+    getExpTotalesRepo(usuario: any): Promise<number>;
+    getExpCantidadPendientesRepo(usuario: any): Promise<number>;
+    getExpCantidadAprobadosRepo(usuario: any): Promise<number>;
+    getExpCantidadRechazadosRepo(usuario: any): Promise<number>;
+    updateEstado(id: any, expediente: ExpedienteElectronico): Promise<ExpedienteElectronico>;
+    updateExpediente(id: any, expediente: ExpedienteElectronico): Promise<ExpedienteElectronico>;
+    getUnidadesPref(): Promise<any>;
+}

package/dist/expediente-electronico/domain/value-object/limited-string.class.d.ts

@@ -0,0 +1,6 @@
+export declare class LimitedString {
+    private readonly maxLength;
+    private readonly value;
+    constructor(value: string, maxLength: number);
+    getValue(): string;
+}

package/dist/expediente-electronico/domain/value-object/notas.class.d.ts

@@ -0,0 +1,19 @@
+export declare class Nota {
+    title: string;
+    importance: string;
+    message: string;
+    unidades: string[];
+    fechaHora: string;
+    leida: boolean;
+    leidaPor: {
+        unidad: string;
+        afiliados: string[];
+    }[];
+    usuarioResponsable: {
+        nombreCompleto: string;
+        unidad: string;
+        uid: string;
+    };
+    constructor(params: any, usuario: any);
+    marcarNotaComoLeida(usuario: any): void;
+}

package/dist/expediente-electronico/infrastructure/controller/expediente-electronico.controller.d.ts

@@ -0,0 +1,24 @@
+import { ExpedienteElectronicoUseCase } from "../../application/expediente-electronico.useCase";
+import { NotificacionController } from "../../../notificaciones/infrastructure/notificacion.controller";
+export declare class ExpedienteElectronicoController {
+    private readonly expedienteElectronicoUseCase;
+    private readonly notificacionCtrl;
+    constructor(expedienteElectronicoUseCase: ExpedienteElectronicoUseCase, notificacionCtrl: NotificacionController);
+    getExpedienteById: (req: Request, res: Response) => Promise<void>;
+    getExpCtrl: (req: Request, res: Response) => Promise<void>;
+    getExpSinPaginacionCtrl: (req: Request, res: Response) => Promise<void>;
+    private prepararFiltrosExp;
+    getExpPendientesCtrl: (req: Request, res: Response) => Promise<void>;
+    getExpPendientesSinPaginadoCtrl: (req: Request, res: Response) => Promise<void>;
+    getExpRechazadosCtrl: (req: Request, res: Response) => Promise<void>;
+    getExpAprobadosCtrl: (req: Request, res: Response) => Promise<void>;
+    getExpCantidadCtrl: (req: Request, res: Response) => Promise<void>;
+    getExpCantidadPendientesCtrl: (req: Request, res: Response) => Promise<void>;
+    getExpCantidadAprobadosCtrl: (req: Request, res: Response) => Promise<void>;
+    getExpACantidadRechazadosCtrl: (req: Request, res: Response) => Promise<void>;
+    guardarNotaCtrl: (req: Request, res: Response) => Promise<void>;
+    leerNotaCtrl: (req: Request, res: Response) => Promise<void>;
+    getAllUnidades: (req: Request, res: Response) => Promise<void>;
+    getUnidadesByUnidad: (req: Request, res: Response) => Promise<void>;
+    firmarDocumento: (req: Request, res: Response) => Promise<void>;
+}

package/dist/expediente-electronico/infrastructure/repositories/expediente-electronico.sql.repository.d.ts

@@ -0,0 +1,60 @@
+import { ExpedienteElectronico } from "../../domain/expediente-electronico.class";
+import { IExpedienteElectronicoRepository } from "../../domain/expediente-electronico.repository";
+import { IExpedienteElectronico } from "../../domain/expediente-electronico.interface";
+export declare class ExpedienteElectronicoSqlRepository implements IExpedienteElectronicoRepository {
+    getExpedienteById(id: string): Promise<ExpedienteElectronico>;
+    getExpedienteByCodigoInterno(codigoInterno: string): Promise<ExpedienteElectronico>;
+    updateEstado(id: any, expediente: ExpedienteElectronico): Promise<ExpedienteElectronico>;
+    updateExpediente(id: any, expediente: ExpedienteElectronico): Promise<ExpedienteElectronico>;
+    getExpRepo(usuario: any, pagination?: {
+        offset: number;
+        limitClause: string;
+    }, estado?: string[], filtro?: any): Promise<{
+        totalRecords: number;
+        expedientes: IExpedienteElectronico[];
+    }>;
+    getExpSinPaginacionRepo(usuario: any, estado?: string[], filtros?: {
+        [key: string]: string;
+    }): Promise<{
+        totalRecords: number;
+        expedientes: IExpedienteElectronico[];
+    }>;
+    /**
+     * Devuelve los expedientes pendientes para el usuario.
+     * Un expediente pendiente es cuando un usuario tiene que hacer algo sobre el. Para determinar cuales son se ven los roles del usuario para cada grupo que tenga,
+     * luego se ve para cada flujo de expediente si al rol del usuario le corresponde accionar sobre el expediente.
+     * @param usuario Usuario que hace la peticion
+     * @param pagination
+     * @returns
+     */
+    getExpPendientesRepo(usuario: any, pagination?: {
+        offset: number;
+        limitClause: string;
+    }): Promise<{
+        totalRecords: number;
+        expedientes: IExpedienteElectronico[];
+    }>;
+    getExpPendientesSinPaginacionRepo(usuario: any): Promise<{
+        totalRecords: number;
+        expedientes: IExpedienteElectronico[];
+    }>;
+    getExpRechazadosRepo(usuario: any, pagination?: {
+        offset: number;
+        limitClause: string;
+    }): Promise<{
+        totalRecords: number;
+        expedientes: IExpedienteElectronico[];
+    }>;
+    getExpAprobadosRepo(usuario: any, pagination?: {
+        offset: number;
+        limitClause: string;
+    }): Promise<{
+        totalRecords: number;
+        expedientes: IExpedienteElectronico[];
+    }>;
+    getExpTotalesRepo(usuario: any): Promise<number>;
+    getExpCantidadPendientesRepo(usuario: any): Promise<number>;
+    getExpCantidadAprobadosRepo(usuario: any): Promise<number>;
+    getExpCantidadRechazadosRepo(usuario: any): Promise<number>;
+    getUnidadesPref(): Promise<any>;
+}

package/dist/expediente-electronico/infrastructure/routes/expediente-electronico.route.d.ts

@@ -0,0 +1,2 @@
+declare const route: any;
+export default route;

package/dist/infrastructure/bd/connection.sql.d.ts

@@ -0,0 +1,4 @@
+import sql from 'mssql';
+export declare function getConnection(query: string): Promise<any>;
+export declare function executeQuery(query: string, params?: Record<string, any>): Promise<any>;
+export declare function getConnectionForTransaction(): Promise<sql.ConnectionPool>;

package/dist/infrastructure/bd/pagination.sql.d.ts

@@ -0,0 +1,4 @@
+export declare const getPagination: (page?: number, limit?: number) => {
+    offset: number;
+    limitClause: string;
+};

package/dist/infrastructure/docs/swagger.d.ts

@@ -0,0 +1,2 @@
+declare const swaggerDocs: (app: any, port: any) => void;
+export default swaggerDocs;

package/dist/infrastructure/fileServer/fileServer.basic-ftp.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as ftp from 'basic-ftp';
+import { PassThrough } from 'node:stream';
+export declare class FtpConnection {
+    client: ftp.Client;
+    constructor();
+    connect(host: any, user: any, password: any, secure?: any): Promise<void>;
+    disconnect(): Promise<void>;
+    uploadBuffer(buffer: any, remotePath: any): Promise<ftp.FTPResponse>;
+    uploadFromStream(stream: NodeJS.ReadableStream, remotePath: string): Promise<void>;
+    downloadToBuffer(remotePath: any): Promise<any>;
+    downloadToStream(remotePath: any): Promise<PassThrough>;
+    deleteByUuid(uuid: string): Promise<boolean>;
+    list(path: any): Promise<ftp.FileInfo[]>;
+    private deleteAllFilesOnFtpServer;
+}

package/dist/infrastructure/fileServer/fileServer.connection.d.ts

@@ -0,0 +1,8 @@
+export declare class FtpConnection {
+    private client;
+    constructor();
+    connect(host: string, user: string, password: string): Promise<void>;
+    uploadFile(localPath: string, remotePath: string): Promise<void>;
+    downloadFile(remotePath: string, localPath: string): Promise<void>;
+    disconnect(): void;
+}

package/dist/infrastructure/middlewares/middleware.apikey.d.ts

@@ -0,0 +1 @@
+export declare const validarApiKeyInternet: (req: Request, res: Response, next: NextFunction) => any;

package/dist/infrastructure/middlewares/middleware.auth.d.ts

@@ -0,0 +1,18 @@
+export declare const validarToken: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+export declare const extraerNivel: (data: any) => number;
+export declare const cifrado: (usuario: any) => Promise<unknown>;
+export declare const descifrarToken: (token: string) => any;
+export declare const getChildrenLabelNumbers: (searchNumber: string) => Promise<string[]>;
+/**
+ * Obtiene la estructura jerárquica de una unidad
+ */
+/**
+ * Obtiene la estructura jerárquica de una unidad
+ */
+export declare function getGerencia(unidad: string): Promise<any>;
+/**
+ * Obtiene los IDs de todas las unidades subordinadas
+ */
+export declare function getChildrenUnitIds(searchUnitId: string): Promise<string[]>;
+export declare const unidadesJoinFuncion: (unidad: any) => Promise<any[]>;
+export declare const obtenerUnidadPadre: (unidadABuscar: any) => Promise<any>;

package/dist/infrastructure/middlewares/middleware.validarCampos.d.ts

@@ -0,0 +1 @@
+export declare const validarCampos: (req: Request, res: Response, next: any) => any;

package/dist/infrastructure/middlewares/middleware.validarRol.d.ts

@@ -0,0 +1 @@
+export declare function validarRol(rolRequerido: string): (req: Request, res: Response, next: any) => any;

package/dist/infrastructure/middlewares/validarNivel.d.ts

@@ -0,0 +1,2 @@
+export declare function validarNivel(nivelRequerido: number): (req: Request, res: Response, next: any) => any;
+export declare function validarGerencia(gerenciaRequerido: string): (req: Request, res: Response, next: any) => any;

package/dist/infrastructure/server/httpsServer.class.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import https from 'https';
+export declare class HttpsServidor {
+    expressApp: any;
+    private port;
+    httpsServer: https.Server;
+    srvio: any;
+    constructor();
+    useLogger(): void;
+    useRoutes(router: any): void;
+    useCors(): void;
+    useJson(): void;
+    start(): https.Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
+    createHttpsServer(): https.Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
+}

package/dist/infrastructure/server/server.class.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import http from 'http';
+export declare class Servidor {
+    expressApp: any;
+    private port;
+    httpServer: http.Server;
+    srvio: any;
+    constructor();
+    useLogger(): void;
+    useRoutes(router: any): void;
+    useCors(): void;
+    useJson(): void;
+    start(): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+}

package/dist/infrastructure/socket/socketIO.d.ts

@@ -0,0 +1,6 @@
+export declare class SocketClient {
+    private url;
+    socket: any;
+    constructor(url: string);
+    private setupListeners;
+}

package/dist/infrastructure/stream-handler/stream-handler.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { Request, Response } from "express";
+import { Readable } from "stream";
+import { Documento } from "../../documentos/domain/documento.class";
+export declare class DocumentStreamHandler {
+    static sendDocumentStream(req: Request, res: Response, archivoStream: Readable, documento: Documento): Promise<void>;
+    private static getMimeTypeFromDocumento;
+    private static getFilenameFromDocumento;
+    static downloadDocumentStream(req: Request, res: Response, archivoStream: Readable, documento: Documento): Promise<void>;
+}

package/dist/notificaciones/domain/datosNotificacion.class.d.ts

@@ -0,0 +1,7 @@
+import { IDatosNotificacion } from "./datosNotificacion.interface";
+export declare class DatosNotificacion implements IDatosNotificacion {
+    info?: string;
+    usuarioResponsable?: string;
+    icono?: string;
+    constructor(info?: string, usuario?: string, icono?: string);
+}

package/dist/notificaciones/domain/datosNotificacion.interface.d.ts

@@ -0,0 +1,5 @@
+export interface IDatosNotificacion {
+    info?: string;
+    usuarioResponsable?: string;
+    icono?: string;
+}

package/dist/notificaciones/domain/notificacion.class.d.ts

@@ -0,0 +1,12 @@
+import { IDatosNotificacion } from "./datosNotificacion.interface";
+import { INotificacion } from "./notificacion.interface";
+export declare class Notificacion implements INotificacion {
+    idNotificacion: string | undefined;
+    fecha: string;
+    unidadEmisora: string;
+    unidadReceptora: string;
+    descripcion: IDatosNotificacion;
+    lectores: string[];
+    idSolicitud?: string;
+    constructor(unidadEmisora: string, unidadReceptora: string, info: string, usuario: string, icono: string, idSolicitud?: string);
+}

package/dist/notificaciones/domain/notificacion.interface.d.ts

@@ -0,0 +1,13 @@
+import { IDatosNotificacion } from "./datosNotificacion.interface";
+export interface INotificacion {
+    idNotificacion: string | undefined;
+    fecha: string;
+    unidadEmisora: string;
+    unidadReceptora: string;
+    descripcion: IDatosNotificacion;
+    /**
+     *  @param lectores arreglo de usuarios que leyeron la notificacion.
+     */
+    lectores: string[];
+    idSolicitud?: string;
+}

package/dist/notificaciones/domain/notificacion.repository.d.ts

@@ -0,0 +1,7 @@
+import { INotificacion } from "./notificacion.interface";
+export interface INotificacionRepository {
+    insert(notificacion: INotificacion): Promise<any>;
+    seleinsertctByUnidad(unidades: string[]): Promise<any>;
+    updateLectores(idNotificacion: string, notificacion: INotificacion): Promise<INotificacion>;
+    selectNotificacionById(idNotificacion: string): Promise<INotificacion>;
+}

package/dist/notificaciones/infrastructure/notificacion.controller.d.ts

@@ -0,0 +1,4 @@
+export declare class NotificacionController {
+    constructor();
+    guardarNotificacion: (unidadEmisora: any, unidadReceptora: any, info: any, usuario: any, icono: any, codigoInterno?: any) => Promise<void>;
+}

package/dist/usuarios/application/usuarios.useCase.d.ts

@@ -0,0 +1,6 @@
+import { IUsuariosRepository } from "../domain/usuarios.repository";
+export declare class UsuariosUseCase {
+    private readonly usuariosRepository;
+    constructor(usuariosRepository: IUsuariosRepository);
+    getUsuarios: () => Promise<any>;
+}

package/dist/usuarios/domain/usuario.class.d.ts

@@ -0,0 +1,20 @@
+import { IUsuario } from "./usuario.interface";
+export declare class Usuario implements IUsuario {
+    uid: any;
+    nombre: string;
+    apellido: string;
+    nombreCompleto: string;
+    mail: string;
+    nacimiento: string;
+    unidad: string;
+    unidadSuperior: string;
+    gerencia: string;
+    cargo: string;
+    documento: string;
+    grupoAD: string[];
+    nombreGerencia: string;
+    roles: any[];
+    perfiles: any[];
+    grupos: any[];
+    constructor(params: any);
+}

package/dist/usuarios/domain/usuario.interface.d.ts

@@ -0,0 +1,18 @@
+export interface IUsuario {
+    uid: any;
+    nombre: string;
+    apellido: string;
+    nombreCompleto: string;
+    mail: string;
+    nacimiento: string;
+    unidad: string;
+    unidadSuperior: string;
+    gerencia: string;
+    cargo: string;
+    documento: string;
+    grupoAD: string[];
+    nombreGerencia: string;
+    roles: any[];
+    perfiles: any[];
+    grupos: any[];
+}

package/dist/usuarios/domain/usuarios.repository.d.ts

@@ -0,0 +1,3 @@
+export interface IUsuariosRepository {
+    getUsuarios(): any;
+}

package/dist/usuarios/infrastructure/controller/usuarios.controller.d.ts

@@ -0,0 +1,6 @@
+import { UsuariosUseCase } from "../../application/usuarios.useCase";
+export declare class UsuariosController {
+    private readonly usuariosUseCase;
+    constructor(usuariosUseCase: UsuariosUseCase);
+    getUsuarios: (req: Request, res: Response) => Promise<void>;
+}

package/dist/usuarios/infrastructure/repository/usuarios.sql.repository.d.ts

@@ -0,0 +1,4 @@
+import { IUsuariosRepository } from "../../domain/usuarios.repository";
+export declare class UsuariosSqlRepository implements IUsuariosRepository {
+    getUsuarios(): Promise<any>;
+}

package/dist/usuarios/infrastructure/routes/usuarios.routes.d.ts

@@ -0,0 +1 @@
+export declare function usuariosRoutes(): any;

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "fpavon-ee-shared",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Carpeta compartida entre servicios de Expediente Electronio",
   "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc"
   },

package/tsconfig.json

@@ -14,7 +14,9 @@
     // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
     // "sourceMap": true,                     /* Generates corresponding '.map' file. */
     // "outFile": "./",                       /* Concatenate and emit output to single file. */
-     "outDir": "./dist",                        /* Redirect output structure to the directory. */
+    "declaration": true,   /* Asegura que se generen los archivos .d.ts */
+    "outDir": "./dist",
+    "rootDir": "./",
     // "rootDir": "./",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
     // "composite": true,                     /* Enable project compilation */
     // "tsBuildInfoFile": "./",               /* Specify file to store incremental compilation information */
@@ -69,5 +71,5 @@
     "skipLibCheck": true,                     /* Skip type checking of declaration files. */
     "forceConsistentCasingInFileNames": true  /* Disallow inconsistently-cased references to the same file. */
   },
-  "exclude": ["node_modules","test"]
+  "exclude": ["node_modules","test", "dist"]
 }