@muni-sanfer/types-gestor-documental 0.0.1-beta.0 → 0.0.1-beta.10

package/dist/contracts/partsOffice.contract.d.ts

@@ -0,0 +1,171 @@
+import { type DocumentAccessLevel, type DocumentInstruction } from '../base/entities';
+import { type DocDigitalDocumentTypeEntity, type DocDigitalEntityEntity, type PartsOfficeInboundEntity, type DocDigitalUserEntity, type PartsOfficeDispatchEntity, type PartsOfficeFileEntity, type PartsOfficeOkResponseEntity, type PartsOfficeRegisterResponseEntity, type PartsOfficeStatusEntity, type PartsOfficeSummaryEntity, type PartsOfficeSyncResponseEntity } from '../entities';
+import { type RpcPage } from './contract';
+import { type DocumentActor, type DocumentExternalRecipientInput } from './document.contract';
+/** Patrones NATS de `partsOffice` (Oficina de Partes y DocDigital): `<servicio>.<recurso>.<acción>`. */
+export declare const PartsOfficePatterns: {
+    readonly getStatus: "gestorDocumental.partsOffice.getStatus";
+    readonly getSummary: "gestorDocumental.partsOffice.getSummary";
+    readonly getEntities: "gestorDocumental.partsOffice.getEntities";
+    readonly getUsers: "gestorDocumental.partsOffice.getUsers";
+    readonly getDocumentTypes: "gestorDocumental.partsOffice.getDocumentTypes";
+    readonly getDispatches: "gestorDocumental.partsOffice.getDispatches";
+    readonly dispatch: "gestorDocumental.partsOffice.dispatch";
+    readonly returnDispatch: "gestorDocumental.partsOffice.returnDispatch";
+    readonly resendDispatch: "gestorDocumental.partsOffice.resendDispatch";
+    readonly getDispatchFile: "gestorDocumental.partsOffice.getDispatchFile";
+    readonly getInbound: "gestorDocumental.partsOffice.getInbound";
+    readonly syncInbound: "gestorDocumental.partsOffice.syncInbound";
+    readonly registerInbound: "gestorDocumental.partsOffice.registerInbound";
+    readonly acknowledgeInbound: "gestorDocumental.partsOffice.acknowledgeInbound";
+    readonly returnInbound: "gestorDocumental.partsOffice.returnInbound";
+    readonly getInboundFile: "gestorDocumental.partsOffice.getInboundFile";
+};
+/** Destinatario interno de un ingreso, ya resuelto por el gateway (las áreas con sus integrantes). */
+export type PartsOfficeRecipientInput = {
+    type: 'Employee';
+    employeeId: string;
+} | {
+    type: 'Directorate';
+    directorateCodeReference: number;
+    name: string;
+    memberEmployeeIds: string[];
+} | {
+    type: 'Department';
+    departmentId: string;
+    name: string;
+    memberEmployeeIds: string[];
+};
+interface IListPayload<S> {
+    pagination?: {
+        page?: number;
+        limit?: number;
+    };
+    filters?: {
+        search?: string;
+        status?: S;
+    };
+}
+export interface PartsOfficeContract {
+    [PartsOfficePatterns.getStatus]: {
+        payload: Record<string, never>;
+        response: PartsOfficeStatusEntity;
+    };
+    [PartsOfficePatterns.getSummary]: {
+        payload: Record<string, never>;
+        response: PartsOfficeSummaryEntity;
+    };
+    /** Directorio de DocDigital: instituciones por nombre. */
+    [PartsOfficePatterns.getEntities]: {
+        payload: {
+            search?: string;
+        };
+        response: DocDigitalEntityEntity[];
+    };
+    [PartsOfficePatterns.getUsers]: {
+        payload: {
+            entityId: number;
+            search?: string;
+        };
+        response: DocDigitalUserEntity[];
+    };
+    [PartsOfficePatterns.getDocumentTypes]: {
+        payload: Record<string, never>;
+        response: DocDigitalDocumentTypeEntity[];
+    };
+    [PartsOfficePatterns.getDispatches]: {
+        payload: IListPayload<'Pending' | 'Dispatched' | 'Returned'>;
+        response: RpcPage<PartsOfficeDispatchEntity[]>;
+    };
+    /** Despacha por DocDigital, con el número del documento como folio. `operatorRun`: RUN de quien despacha. */
+    [PartsOfficePatterns.dispatch]: {
+        payload: {
+            id: string;
+            docDigitalTypeId: number;
+            operatorRun?: string | null;
+            actor: DocumentActor;
+        };
+        response: PartsOfficeOkResponseEntity & {
+            docDigitalDocumentId: string;
+        };
+    };
+    /** Devuelve el despacho al redactor, con el motivo (por ejemplo, un destinatario equivocado). */
+    [PartsOfficePatterns.returnDispatch]: {
+        payload: {
+            id: string;
+            reason: string;
+            actor: DocumentActor;
+        };
+        response: PartsOfficeOkResponseEntity;
+    };
+    /** El redactor corrige las instituciones de destino de un despacho devuelto y lo envía de nuevo a Partes. */
+    [PartsOfficePatterns.resendDispatch]: {
+        payload: {
+            id: string;
+            externalRecipients: DocumentExternalRecipientInput[];
+            actor: DocumentActor;
+        };
+        response: PartsOfficeOkResponseEntity;
+    };
+    /** PDF firmado de un documento por despachar, para que Oficina de Partes lo revise. */
+    [PartsOfficePatterns.getDispatchFile]: {
+        payload: {
+            id: string;
+        };
+        response: PartsOfficeFileEntity;
+    };
+    [PartsOfficePatterns.getInbound]: {
+        payload: IListPayload<'Pending' | 'Registered' | 'Returned'>;
+        response: RpcPage<PartsOfficeInboundEntity[]>;
+    };
+    /** Trae de DocDigital lo recibido que aún no tiene acuse de recibo. */
+    [PartsOfficePatterns.syncInbound]: {
+        payload: Record<string, never>;
+        response: PartsOfficeSyncResponseEntity;
+    };
+    /**
+     * Ingresa un recibido al gestor: le da folio de ingreso, lo deriva a quienes corresponda y da el acuse de recibo
+     * en DocDigital.
+     */
+    [PartsOfficePatterns.registerInbound]: {
+        payload: {
+            id: string;
+            documentTypeId: string;
+            keywords: string[];
+            accessLevel: DocumentAccessLevel;
+            hasSensitiveData: boolean;
+            recipients: PartsOfficeRecipientInput[];
+            instruction: DocumentInstruction;
+            note?: string | null;
+            dueAt?: string | null;
+            actor: DocumentActor;
+        };
+        response: PartsOfficeRegisterResponseEntity;
+    };
+    /** Reintenta el acuse de recibo de un recibido ya ingresado. */
+    [PartsOfficePatterns.acknowledgeInbound]: {
+        payload: {
+            id: string;
+            actor: DocumentActor;
+        };
+        response: PartsOfficeOkResponseEntity;
+    };
+    /** Devuelve el recibido a la institución que lo envió, con el motivo (entre 3 y 255 caracteres). */
+    [PartsOfficePatterns.returnInbound]: {
+        payload: {
+            id: string;
+            reason: string;
+            actor: DocumentActor;
+        };
+        response: PartsOfficeOkResponseEntity;
+    };
+    /** Archivo de un recibido: el principal o, con `attachment`, uno de sus anexos (por su posición). */
+    [PartsOfficePatterns.getInboundFile]: {
+        payload: {
+            id: string;
+            attachment?: number;
+        };
+        response: PartsOfficeFileEntity;
+    };
+}
+export {};

package/dist/contracts/partsOffice.contract.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PartsOfficePatterns = void 0;
+/** Patrones NATS de `partsOffice` (Oficina de Partes y DocDigital): `<servicio>.<recurso>.<acción>`. */
+exports.PartsOfficePatterns = {
+    getStatus: 'gestorDocumental.partsOffice.getStatus',
+    getSummary: 'gestorDocumental.partsOffice.getSummary',
+    getEntities: 'gestorDocumental.partsOffice.getEntities',
+    getUsers: 'gestorDocumental.partsOffice.getUsers',
+    getDocumentTypes: 'gestorDocumental.partsOffice.getDocumentTypes',
+    getDispatches: 'gestorDocumental.partsOffice.getDispatches',
+    dispatch: 'gestorDocumental.partsOffice.dispatch',
+    returnDispatch: 'gestorDocumental.partsOffice.returnDispatch',
+    resendDispatch: 'gestorDocumental.partsOffice.resendDispatch',
+    getDispatchFile: 'gestorDocumental.partsOffice.getDispatchFile',
+    getInbound: 'gestorDocumental.partsOffice.getInbound',
+    syncInbound: 'gestorDocumental.partsOffice.syncInbound',
+    registerInbound: 'gestorDocumental.partsOffice.registerInbound',
+    acknowledgeInbound: 'gestorDocumental.partsOffice.acknowledgeInbound',
+    returnInbound: 'gestorDocumental.partsOffice.returnInbound',
+    getInboundFile: 'gestorDocumental.partsOffice.getInboundFile',
+};

package/dist/contracts/procedure.contract.d.ts

@@ -0,0 +1,50 @@
+import { type ProcedureEntity } from '../base/entities';
+import { type ProcedureCreateResponseEntity, type ProcedureGetAllResponseEntity, type ProcedureGetByIdResponseEntity, type ProcedureUpdateResponseEntity } from '../entities';
+import { type RpcPage } from './contract';
+/** Patrones NATS de `procedure`: `<servicio>.<recurso>.<acción>`. */
+export declare const ProcedurePatterns: {
+    readonly getAll: "gestorDocumental.procedure.getAll";
+    readonly getById: "gestorDocumental.procedure.getById";
+    readonly create: "gestorDocumental.procedure.create";
+    readonly update: "gestorDocumental.procedure.update";
+    readonly setEnabled: "gestorDocumental.procedure.setEnabled";
+};
+/** Datos de un procedimiento administrativo al crearlo o editarlo. */
+export interface ProcedureWritePayload {
+    name: string;
+    cpatId?: string | null;
+    cpatCode?: string | null;
+    description?: string | null;
+    enabled?: boolean;
+}
+export interface ProcedureContract {
+    [ProcedurePatterns.getAll]: {
+        payload: {
+            pagination?: {
+                page?: number;
+                limit?: number;
+            };
+            filters?: {
+                search?: string;
+                enabled?: boolean;
+            };
+        };
+        response: RpcPage<ProcedureGetAllResponseEntity[]>;
+    };
+    [ProcedurePatterns.getById]: {
+        payload: Pick<ProcedureEntity, 'id'>;
+        response: ProcedureGetByIdResponseEntity;
+    };
+    [ProcedurePatterns.create]: {
+        payload: ProcedureWritePayload;
+        response: ProcedureCreateResponseEntity;
+    };
+    [ProcedurePatterns.update]: {
+        payload: ProcedureWritePayload & Pick<ProcedureEntity, 'id'>;
+        response: ProcedureUpdateResponseEntity;
+    };
+    [ProcedurePatterns.setEnabled]: {
+        payload: Pick<ProcedureEntity, 'id' | 'enabled'>;
+        response: ProcedureUpdateResponseEntity;
+    };
+}

package/dist/contracts/procedure.contract.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcedurePatterns = void 0;
+/** Patrones NATS de `procedure`: `<servicio>.<recurso>.<acción>`. */
+exports.ProcedurePatterns = {
+    getAll: 'gestorDocumental.procedure.getAll',
+    getById: 'gestorDocumental.procedure.getById',
+    create: 'gestorDocumental.procedure.create',
+    update: 'gestorDocumental.procedure.update',
+    setEnabled: 'gestorDocumental.procedure.setEnabled',
+};

package/dist/contracts/registerBook.contract.d.ts

@@ -0,0 +1,27 @@
+import { type RegisterBookEntity, type RegisterBookExportEntity, type RegisterBookKind } from '../entities';
+/** Patrones NATS de `registerBook` (libros de registro): `<servicio>.<recurso>.<acción>`. */
+export declare const RegisterBookPatterns: {
+    readonly get: "gestorDocumental.registerBook.get";
+    readonly export: "gestorDocumental.registerBook.export";
+};
+/** Qué libro y qué período: un año y, si se indica, un mes. El de un tipo documental exige el tipo. */
+export interface RegisterBookQuery {
+    kind: RegisterBookKind;
+    documentTypeId?: string;
+    year: number;
+    month?: number | null;
+}
+export interface RegisterBookContract {
+    [RegisterBookPatterns.get]: {
+        payload: RegisterBookQuery;
+        response: RegisterBookEntity;
+    };
+    /** El libro en Excel o PDF. `generatedBy`: quién lo descarga (va en el encabezado). */
+    [RegisterBookPatterns.export]: {
+        payload: RegisterBookQuery & {
+            format: 'xlsx' | 'pdf';
+            generatedBy: string;
+        };
+        response: RegisterBookExportEntity;
+    };
+}

package/dist/contracts/registerBook.contract.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegisterBookPatterns = void 0;
+/** Patrones NATS de `registerBook` (libros de registro): `<servicio>.<recurso>.<acción>`. */
+exports.RegisterBookPatterns = {
+    get: 'gestorDocumental.registerBook.get',
+    export: 'gestorDocumental.registerBook.export',
+};

package/dist/contracts/signatureBatch.contract.d.ts

@@ -0,0 +1,109 @@
+import { type DocumentAccessLevel } from '../base/entities';
+import { type SignatureBatchCreateResponseEntity, type SignatureBatchGetAllResponseEntity, type SignatureBatchGetByIdResponseEntity, type SignatureBatchRejectResponseEntity, type SignatureBatchSignResponseEntity, type SignatureBatchTab, type SignatureBatchVisaResponseEntity } from '../entities';
+import { type RpcPage } from './contract';
+import { type DocumentActor } from './document.contract';
+/** Patrones NATS de `signatureBatch` (lotes de firma): `<servicio>.<recurso>.<acción>`. */
+export declare const SignatureBatchPatterns: {
+    readonly getAll: "gestorDocumental.signatureBatch.getAll";
+    readonly getById: "gestorDocumental.signatureBatch.getById";
+    readonly create: "gestorDocumental.signatureBatch.create";
+    readonly visa: "gestorDocumental.signatureBatch.visa";
+    readonly sign: "gestorDocumental.signatureBatch.sign";
+    readonly reject: "gestorDocumental.signatureBatch.reject";
+};
+/** Datos de quien firma, para el sello de la firma (los resuelve el gateway desde la sesión). */
+export interface SignatureBatchSigner {
+    rut: string;
+    fullName: string;
+    role: string;
+    areaName: string;
+}
+export interface SignatureBatchContract {
+    [SignatureBatchPatterns.getAll]: {
+        payload: {
+            pagination?: {
+                page?: number;
+                limit?: number;
+            };
+            filters?: {
+                search?: string;
+                tab?: SignatureBatchTab;
+            };
+            actor: DocumentActor;
+        };
+        response: RpcPage<SignatureBatchGetAllResponseEntity[]>;
+    };
+    /** Lo ven su redactor y quienes visan o firman sus documentos; con `viewAll`, quien lleva el registro. */
+    [SignatureBatchPatterns.getById]: {
+        payload: {
+            id: string;
+            actor: DocumentActor;
+            viewAll?: boolean;
+        };
+        response: SignatureBatchGetByIdResponseEntity;
+    };
+    /**
+     * Crea el lote y lo envía a tramitación: un documento por cada PDF, todos del mismo tipo y con el mismo flujo.
+     * Cada documento recibe su código de verificación y, con su primera firma, su número (si el tipo lo lleva).
+     */
+    [SignatureBatchPatterns.create]: {
+        payload: {
+            name: string;
+            documentTypeId: string;
+            keywords: string[];
+            accessLevel?: DocumentAccessLevel;
+            hasSensitiveData?: boolean;
+            directorateCodeReference?: number | null;
+            departmentId?: string | null;
+            visaEmployeeIds?: string[];
+            visaStages?: number[] | null;
+            signatureEmployeeIds: string[];
+            signatureSheet?: boolean;
+            documents: {
+                subject: string;
+                file: {
+                    fileId: string;
+                    name: string;
+                };
+            }[];
+            actor: DocumentActor;
+        };
+        response: SignatureBatchCreateResponseEntity;
+    };
+    /** Visa de una vez los documentos del lote que el funcionario tiene en su turno de visación. */
+    [SignatureBatchPatterns.visa]: {
+        payload: {
+            id: string;
+            observation?: string | null;
+            actor: DocumentActor;
+        };
+        response: SignatureBatchVisaResponseEntity;
+    };
+    /**
+     * Firma con un solo OTP los documentos del lote que el funcionario tiene en su turno de firma. FirmaGob admite 5 MB
+     * por solicitud: los que no caben quedan en `remaining`, para firmarlos con un OTP nuevo.
+     */
+    [SignatureBatchPatterns.sign]: {
+        payload: {
+            id: string;
+            observation?: string | null;
+            signer: SignatureBatchSigner;
+            otp?: string;
+            actor: DocumentActor;
+        };
+        response: SignatureBatchSignResponseEntity;
+    };
+    /**
+     * Devuelve a su redactor los documentos del lote que el funcionario tiene en su turno: todos, o los indicados en
+     * `documentIds`. Los demás siguen su curso.
+     */
+    [SignatureBatchPatterns.reject]: {
+        payload: {
+            id: string;
+            observation: string;
+            documentIds?: string[];
+            actor: DocumentActor;
+        };
+        response: SignatureBatchRejectResponseEntity;
+    };
+}

package/dist/contracts/signatureBatch.contract.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignatureBatchPatterns = void 0;
+/** Patrones NATS de `signatureBatch` (lotes de firma): `<servicio>.<recurso>.<acción>`. */
+exports.SignatureBatchPatterns = {
+    getAll: 'gestorDocumental.signatureBatch.getAll',
+    getById: 'gestorDocumental.signatureBatch.getById',
+    create: 'gestorDocumental.signatureBatch.create',
+    visa: 'gestorDocumental.signatureBatch.visa',
+    sign: 'gestorDocumental.signatureBatch.sign',
+    reject: 'gestorDocumental.signatureBatch.reject',
+};

package/dist/contracts/workFolder.contract.d.ts

@@ -0,0 +1,114 @@
+import { type WorkFolderConvertInput, type WorkFolderConvertResponseEntity, type WorkFolderGetAllResponseEntity, type WorkFolderGetByIdResponseEntity, type WorkFolderWriteResponseEntity } from '../entities';
+import { type RpcPage } from './contract';
+import { type DocumentActor } from './document.contract';
+/** Patrones NATS de `workFolder` (carpetas de trabajo): `<servicio>.<recurso>.<acción>`. */
+export declare const WorkFolderPatterns: {
+    readonly getAll: "gestorDocumental.workFolder.getAll";
+    readonly getById: "gestorDocumental.workFolder.getById";
+    readonly create: "gestorDocumental.workFolder.create";
+    readonly update: "gestorDocumental.workFolder.update";
+    readonly share: "gestorDocumental.workFolder.share";
+    readonly unshare: "gestorDocumental.workFolder.unshare";
+    readonly addItem: "gestorDocumental.workFolder.addItem";
+    readonly removeItem: "gestorDocumental.workFolder.removeItem";
+    readonly remove: "gestorDocumental.workFolder.remove";
+    readonly convert: "gestorDocumental.workFolder.convert";
+};
+/** Lo que se agrega a una carpeta: un documento finalizado del gestor o un archivo ya subido. */
+export type WorkFolderItemInput = {
+    kind: 'Document';
+    documentId: string;
+} | {
+    kind: 'File';
+    fileId: string;
+    fileName: string;
+    title: string;
+};
+type TActor = {
+    actor: DocumentActor;
+};
+/**
+ * Carpetas de trabajo: agrupan y comparten documentos y archivos sin procedimiento asociado. Las ven su responsable y
+ * aquellos con quienes la compartió.
+ */
+export interface WorkFolderContract {
+    [WorkFolderPatterns.getAll]: {
+        payload: {
+            pagination?: {
+                page?: number;
+                limit?: number;
+            };
+            filters?: {
+                search?: string;
+            };
+        } & TActor;
+        response: RpcPage<WorkFolderGetAllResponseEntity[]>;
+    };
+    [WorkFolderPatterns.getById]: {
+        payload: {
+            id: string;
+        } & TActor;
+        response: WorkFolderGetByIdResponseEntity;
+    };
+    [WorkFolderPatterns.create]: {
+        payload: {
+            name: string;
+            description?: string | null;
+        } & TActor;
+        response: WorkFolderWriteResponseEntity;
+    };
+    [WorkFolderPatterns.update]: {
+        payload: {
+            id: string;
+            name: string;
+            description?: string | null;
+        } & TActor;
+        response: WorkFolderWriteResponseEntity;
+    };
+    [WorkFolderPatterns.share]: {
+        payload: {
+            id: string;
+            employeeIds: string[];
+        } & TActor;
+        response: WorkFolderWriteResponseEntity;
+    };
+    [WorkFolderPatterns.unshare]: {
+        payload: {
+            id: string;
+            participantId: string;
+        } & TActor;
+        response: WorkFolderWriteResponseEntity;
+    };
+    [WorkFolderPatterns.addItem]: {
+        payload: {
+            id: string;
+            item: WorkFolderItemInput;
+        } & TActor;
+        response: WorkFolderWriteResponseEntity;
+    };
+    [WorkFolderPatterns.removeItem]: {
+        payload: {
+            id: string;
+            itemId: string;
+        } & TActor;
+        response: WorkFolderWriteResponseEntity;
+    };
+    /** La carpeta deja de verse. Lo que contiene no se toca: los documentos siguen en el gestor. */
+    [WorkFolderPatterns.remove]: {
+        payload: {
+            id: string;
+        } & TActor;
+        response: WorkFolderWriteResponseEntity;
+    };
+    /**
+     * La convierte en expediente: lo crea con estos metadatos, lo comparte con los mismos funcionarios e incorpora sus
+     * ítems al índice en el orden en que se agregaron. Desde ahí la carpeta queda solo de consulta.
+     */
+    [WorkFolderPatterns.convert]: {
+        payload: {
+            id: string;
+        } & WorkFolderConvertInput & TActor;
+        response: WorkFolderConvertResponseEntity;
+    };
+}
+export {};

package/dist/contracts/workFolder.contract.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkFolderPatterns = void 0;
+/** Patrones NATS de `workFolder` (carpetas de trabajo): `<servicio>.<recurso>.<acción>`. */
+exports.WorkFolderPatterns = {
+    getAll: 'gestorDocumental.workFolder.getAll',
+    getById: 'gestorDocumental.workFolder.getById',
+    create: 'gestorDocumental.workFolder.create',
+    update: 'gestorDocumental.workFolder.update',
+    share: 'gestorDocumental.workFolder.share',
+    unshare: 'gestorDocumental.workFolder.unshare',
+    addItem: 'gestorDocumental.workFolder.addItem',
+    removeItem: 'gestorDocumental.workFolder.removeItem',
+    remove: 'gestorDocumental.workFolder.remove',
+    convert: 'gestorDocumental.workFolder.convert',
+};