@muni-sanfer/types-gestor-documental 0.0.1-beta.3 → 0.0.1-beta.30

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

@@ -0,0 +1,262 @@
+import { type CaseFileActorRelation, type CaseFileActorType, type CaseFileActuationType, type CaseFileEntity, type CaseFileStatus, type DocumentAccessLevel } from '../base/entities';
+import { type CaseFileAddBatchResponseEntity, type CaseFileAddEntryResponseEntity, type CaseFileCreateResponseEntity, type CaseFileEntryFileResponseEntity, type CaseFileExportResponseEntity, type CaseFileGetAllResponseEntity, type CaseFileGetByIdResponseEntity, type CaseFileShareLinkCreateResponseEntity, type CaseFileShareLinkResponseEntity, type CaseFileSharedResponseEntity, type CaseFileUpdateResponseEntity, type CaseFileVerifyExportResponseEntity } from '../entities';
+import { type RpcPage } from './contract';
+import { type DocumentActor } from './document.contract';
+/** Patrones NATS de `caseFile`: `<servicio>.<recurso>.<acción>`. */
+export declare const CaseFilePatterns: {
+    readonly getAll: "gestorDocumental.caseFile.getAll";
+    readonly getById: "gestorDocumental.caseFile.getById";
+    readonly create: "gestorDocumental.caseFile.create";
+    readonly update: "gestorDocumental.caseFile.update";
+    readonly addEntry: "gestorDocumental.caseFile.addEntry";
+    readonly addBatch: "gestorDocumental.caseFile.addBatch";
+    readonly voidEntry: "gestorDocumental.caseFile.voidEntry";
+    readonly moveEntry: "gestorDocumental.caseFile.moveEntry";
+    readonly share: "gestorDocumental.caseFile.share";
+    readonly unshare: "gestorDocumental.caseFile.unshare";
+    readonly close: "gestorDocumental.caseFile.close";
+    readonly getEntryFile: "gestorDocumental.caseFile.getEntryFile";
+    readonly getExport: "gestorDocumental.caseFile.getExport";
+    readonly createShareLink: "gestorDocumental.caseFile.createShareLink";
+    readonly getShareLinks: "gestorDocumental.caseFile.getShareLinks";
+    readonly revokeShareLink: "gestorDocumental.caseFile.revokeShareLink";
+    readonly getShared: "gestorDocumental.caseFile.getShared";
+    readonly getSharedEntryFile: "gestorDocumental.caseFile.getSharedEntryFile";
+    readonly getSharedExport: "gestorDocumental.caseFile.getSharedExport";
+    readonly verifyExport: "gestorDocumental.caseFile.verifyExport";
+};
+/** Enlace temporal para que alguien de fuera consulte el expediente sin sesión. */
+export interface CaseFileShareLinkPayload {
+    /** A quién se entrega. Ej: «Contraloría Regional». */
+    recipient: string;
+    /** Si se indica, el gateway le envía el enlace por correo. */
+    recipientEmail?: string | null;
+    purpose?: string | null;
+    /** Cuántos días dura: de 1 a 30. */
+    days: number;
+    /** Puede descargar el expediente completo (ZIP). Por omisión, sí. */
+    allowExport?: boolean;
+}
+/** Persona u organización relacionada con el expediente (MGDEE54). */
+export interface CaseFileActorInput {
+    relation: CaseFileActorRelation;
+    actorType: CaseFileActorType;
+    identifier?: string | null;
+    name: string;
+}
+/** Metadatos del expediente que se ingresan a mano. */
+export interface CaseFileWritePayload {
+    title: string;
+    subject: string;
+    summary?: string | null;
+    procedureId: string;
+    accessLevel: DocumentAccessLevel;
+    hasSensitiveData: boolean;
+    /** MGDEE8_2: fin de la restricción de acceso (ISO 8601), si no es público. */
+    restrictionEndsAt?: string | null;
+    /** MGDEE1_2: serie del Cuadro de Clasificación. */
+    archivalSeriesId?: string | null;
+    actors?: CaseFileActorInput[];
+}
+/** Actuación que se incorpora al índice: un documento del gestor, un archivo subido u otro expediente. */
+export type CaseFileEntryInput = {
+    kind: 'Document';
+    actuationType: CaseFileActuationType;
+    documentId: string;
+} | {
+    kind: 'File';
+    actuationType: CaseFileActuationType;
+    fileId: string;
+    fileName: string;
+    title: string;
+    documentTypeName?: string | null;
+    originDate?: string | null;
+    author?: string | null;
+    keywords: string[];
+    accessLevel: DocumentAccessLevel;
+    hasSensitiveData: boolean;
+} | {
+    kind: 'CaseFile';
+    actuationType: CaseFileActuationType;
+    linkedCaseFileId: string;
+} | {
+    kind: 'Physical';
+    actuationType: CaseFileActuationType;
+    title: string;
+    documentTypeName?: string | null;
+    originDate?: string | null;
+    author?: string | null;
+    /** Dónde está el papel: oficina, archivador, caja (MGDDE5_5). */
+    physicalLocation: string;
+    /** Por qué no se pudo digitalizar. */
+    physicalReason: string;
+    pageCount?: number | null;
+    keywords: string[];
+    accessLevel: DocumentAccessLevel;
+    hasSensitiveData: boolean;
+};
+/** Quién hace la operación (de la sesión) y si puede ver todos los expedientes. */
+interface CaseFileActorPayload {
+    actor: DocumentActor;
+    viewAll?: boolean;
+}
+/** Ámbito del listado: los expedientes del funcionario (responsable o compartidos con él) o todos. */
+export type CaseFileScope = 'mine' | 'all';
+export interface CaseFileContract {
+    [CaseFilePatterns.getAll]: {
+        payload: {
+            pagination?: {
+                page?: number;
+                limit?: number;
+            };
+            filters?: {
+                search?: string;
+                status?: CaseFileStatus;
+                procedureId?: string;
+                scope?: CaseFileScope;
+            };
+        } & CaseFileActorPayload;
+        response: RpcPage<CaseFileGetAllResponseEntity[]>;
+    };
+    /** Por id o por su identificador (`EXP-2026-00001`), que es el del enlace persistente. Queda en el registro de accesos. */
+    [CaseFilePatterns.getById]: {
+        payload: {
+            id: string;
+        } & CaseFileActorPayload;
+        response: CaseFileGetByIdResponseEntity;
+    };
+    [CaseFilePatterns.create]: {
+        payload: CaseFileWritePayload & {
+            actor: DocumentActor;
+        };
+        response: CaseFileCreateResponseEntity;
+    };
+    [CaseFilePatterns.update]: {
+        payload: CaseFileWritePayload & Pick<CaseFileEntity, 'id'> & {
+            actor: DocumentActor;
+        };
+        response: CaseFileUpdateResponseEntity;
+    };
+    /** Incorpora los documentos finalizados de un lote de firma, en su orden; omite los que ya están en el expediente. */
+    [CaseFilePatterns.addBatch]: {
+        payload: {
+            id: string;
+            batchId: string;
+            actuationType: CaseFileActuationType;
+        } & CaseFileActorPayload;
+        response: CaseFileAddBatchResponseEntity;
+    };
+    [CaseFilePatterns.addEntry]: {
+        payload: Pick<CaseFileEntity, 'id'> & {
+            entry: CaseFileEntryInput;
+            folder?: string | null;
+        } & CaseFileActorPayload;
+        response: CaseFileAddEntryResponseEntity;
+    };
+    /** Deja una actuación sin efecto, con su motivo. No se elimina del índice. */
+    /** Pasa una actuación a otra subcarpeta del índice (`null`: a la raíz). El orden de incorporación no cambia. */
+    [CaseFilePatterns.moveEntry]: {
+        payload: {
+            id: string;
+            entryId: string;
+            folder: string | null;
+        } & CaseFileActorPayload;
+        response: CaseFileUpdateResponseEntity;
+    };
+    [CaseFilePatterns.voidEntry]: {
+        payload: Pick<CaseFileEntity, 'id'> & {
+            entryId: string;
+            reason: string;
+            actor: DocumentActor;
+        };
+        response: CaseFileUpdateResponseEntity;
+    };
+    [CaseFilePatterns.share]: {
+        payload: Pick<CaseFileEntity, 'id'> & {
+            employeeIds: string[];
+            actor: DocumentActor;
+        };
+        response: CaseFileUpdateResponseEntity;
+    };
+    [CaseFilePatterns.unshare]: {
+        payload: Pick<CaseFileEntity, 'id'> & {
+            participantId: string;
+            actor: DocumentActor;
+        };
+        response: CaseFileUpdateResponseEntity;
+    };
+    [CaseFilePatterns.close]: {
+        payload: Pick<CaseFileEntity, 'id'> & {
+            note?: string | null;
+            actor: DocumentActor;
+        };
+        response: CaseFileUpdateResponseEntity;
+    };
+    /** Archivo de una actuación del índice. Queda en el registro de accesos. */
+    [CaseFilePatterns.getEntryFile]: {
+        payload: Pick<CaseFileEntity, 'id'> & {
+            entryId: string;
+        } & CaseFileActorPayload;
+        response: CaseFileEntryFileResponseEntity;
+    };
+    /** Metadatos y archivos para exportar el expediente completo. Queda en la trazabilidad y en el registro de accesos. */
+    [CaseFilePatterns.getExport]: {
+        payload: Pick<CaseFileEntity, 'id'> & CaseFileActorPayload;
+        response: CaseFileExportResponseEntity;
+    };
+    /** Crea un enlace temporal: solo su responsable. El token viaja solo en esta respuesta. */
+    [CaseFilePatterns.createShareLink]: {
+        payload: Pick<CaseFileEntity, 'id'> & CaseFileShareLinkPayload & {
+            actor: DocumentActor;
+        };
+        response: CaseFileShareLinkCreateResponseEntity;
+    };
+    /** Enlaces del expediente, vigentes o no, con cuántas veces se usaron: su responsable o quien ve todos. */
+    [CaseFilePatterns.getShareLinks]: {
+        payload: Pick<CaseFileEntity, 'id'> & CaseFileActorPayload;
+        response: CaseFileShareLinkResponseEntity[];
+    };
+    [CaseFilePatterns.revokeShareLink]: {
+        payload: Pick<CaseFileEntity, 'id'> & {
+            linkId: string;
+            actor: DocumentActor;
+        };
+        response: CaseFileUpdateResponseEntity;
+    };
+    /** Sin sesión, con el token del enlace: metadatos e índice. Queda en el registro de accesos. */
+    [CaseFilePatterns.getShared]: {
+        payload: {
+            token: string;
+        };
+        response: CaseFileSharedResponseEntity;
+    };
+    [CaseFilePatterns.getSharedEntryFile]: {
+        payload: {
+            token: string;
+            entryId: string;
+        };
+        response: CaseFileEntryFileResponseEntity;
+    };
+    /** El expediente completo, si el enlace lo permite. Queda en la trazabilidad y en el registro de accesos. */
+    /**
+     * Verificador público del ZIP exportado: sin sesión, con el identificador del expediente y la huella SHA-256 que
+     * calculó el navegador para cada actuación (el ZIP no se sube). Se compara con las huellas registradas al incorporar.
+     */
+    [CaseFilePatterns.verifyExport]: {
+        payload: {
+            code: string;
+            entries: {
+                sequence: number;
+                sha256: string;
+            }[];
+        };
+        response: CaseFileVerifyExportResponseEntity;
+    };
+    [CaseFilePatterns.getSharedExport]: {
+        payload: {
+            token: string;
+        };
+        response: CaseFileExportResponseEntity;
+    };
+}
+export {};

package/dist/contracts/caseFile.contract.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CaseFilePatterns = void 0;
+/** Patrones NATS de `caseFile`: `<servicio>.<recurso>.<acción>`. */
+exports.CaseFilePatterns = {
+    getAll: 'gestorDocumental.caseFile.getAll',
+    getById: 'gestorDocumental.caseFile.getById',
+    create: 'gestorDocumental.caseFile.create',
+    update: 'gestorDocumental.caseFile.update',
+    addEntry: 'gestorDocumental.caseFile.addEntry',
+    addBatch: 'gestorDocumental.caseFile.addBatch',
+    voidEntry: 'gestorDocumental.caseFile.voidEntry',
+    moveEntry: 'gestorDocumental.caseFile.moveEntry',
+    share: 'gestorDocumental.caseFile.share',
+    unshare: 'gestorDocumental.caseFile.unshare',
+    close: 'gestorDocumental.caseFile.close',
+    getEntryFile: 'gestorDocumental.caseFile.getEntryFile',
+    getExport: 'gestorDocumental.caseFile.getExport',
+    createShareLink: 'gestorDocumental.caseFile.createShareLink',
+    getShareLinks: 'gestorDocumental.caseFile.getShareLinks',
+    revokeShareLink: 'gestorDocumental.caseFile.revokeShareLink',
+    getShared: 'gestorDocumental.caseFile.getShared',
+    getSharedEntryFile: 'gestorDocumental.caseFile.getSharedEntryFile',
+    getSharedExport: 'gestorDocumental.caseFile.getSharedExport',
+    verifyExport: 'gestorDocumental.caseFile.verifyExport',
+};

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

@@ -0,0 +1,251 @@
+import { type CommunicationMeans, type DataBreachKind, type DataBreachNoticeMeans, type DataLegalBasis, type DataRight, type DataRightsChannel, type DataRightsResolution } from '../base/entities';
+import { type DataBreachResponseEntity, type DataProtectionPolicyEntity, type IndicatorsFileEntity, type DataRightsRequestDetailEntity, type DataRightsRequestListItemEntity, type DataRightsSummaryEntity, type DataTreatmentResponseEntity } from '../entities';
+import { type RpcPage } from './contract';
+/** Patrones NATS de `dataProtection`: tratamientos de datos y solicitudes de los titulares (Ley 19.628). */
+export declare const DataProtectionPatterns: {
+    readonly getTreatments: "gestorDocumental.dataProtection.getTreatments";
+    readonly createTreatment: "gestorDocumental.dataProtection.createTreatment";
+    readonly updateTreatment: "gestorDocumental.dataProtection.updateTreatment";
+    readonly setTreatmentEnabled: "gestorDocumental.dataProtection.setTreatmentEnabled";
+    readonly getPolicy: "gestorDocumental.dataProtection.getPolicy";
+    readonly getRequests: "gestorDocumental.dataProtection.getRequests";
+    readonly getRequest: "gestorDocumental.dataProtection.getRequest";
+    readonly getSummary: "gestorDocumental.dataProtection.getSummary";
+    readonly createRequest: "gestorDocumental.dataProtection.createRequest";
+    readonly updateRequest: "gestorDocumental.dataProtection.updateRequest";
+    readonly actOnRequest: "gestorDocumental.dataProtection.actOnRequest";
+    readonly getBreaches: "gestorDocumental.dataProtection.getBreaches";
+    readonly getBreach: "gestorDocumental.dataProtection.getBreach";
+    readonly createBreach: "gestorDocumental.dataProtection.createBreach";
+    readonly updateBreach: "gestorDocumental.dataProtection.updateBreach";
+    readonly actOnBreach: "gestorDocumental.dataProtection.actOnBreach";
+    readonly getBreachPdf: "gestorDocumental.dataProtection.getBreachPdf";
+};
+type TActor = {
+    employeeId: string;
+    fullName: string;
+};
+/** Datos de un tratamiento al crearlo o editarlo. */
+export interface DataTreatmentWritePayload {
+    name: string;
+    purpose: string;
+    legalBasis: DataLegalBasis;
+    legalBasisDetail?: string | null;
+    dataCategories: string[];
+    sensitiveData?: boolean;
+    dataSubjects: string;
+    recipients?: string | null;
+    source?: string | null;
+    retention?: string | null;
+    securityMeasures?: string | null;
+    internationalTransfer?: string | null;
+    responsibleUnit?: string | null;
+    published?: boolean;
+}
+/** Datos de una solicitud al ingresarla o corregirla. */
+export interface DataRightsRequestWritePayload {
+    channel: DataRightsChannel;
+    receivedAt: string;
+    rights: DataRight[];
+    requesterName: string;
+    requesterRut?: string | null;
+    requesterEmail?: string | null;
+    requesterAddress?: string | null;
+    representativeName?: string | null;
+    requestText: string;
+    treatmentId?: string | null;
+    /** Bloqueo temporal: solo con rectificación, supresión u oposición, y fundado. */
+    blockingRequested?: boolean;
+    blockingReason?: string | null;
+}
+/** Un paso de la tramitación. */
+export type DataRightsAction = {
+    type: 'acknowledge';
+    note?: string | null;
+} | {
+    type: 'verifyIdentity';
+    note?: string | null;
+} | {
+    type: 'assign';
+    employeeId: string;
+    fullName: string;
+    note?: string | null;
+}
+/** Bloqueo temporal, en 2 días hábiles; si se rechaza, fundado (y se comunica a la Agencia). */
+ | {
+    type: 'resolveBlocking';
+    granted: boolean;
+    note?: string | null;
+} | {
+    type: 'extend';
+    note: string;
+} | {
+    type: 'resolve';
+    resolution: DataRightsResolution;
+    grounds?: string[];
+    note?: string | null;
+    responseDocumentId?: string | null;
+}
+/** Respaldo del envío de la respuesta escrita (art. 11). */
+ | {
+    type: 'registerResponseSent';
+    sentAt?: string | null;
+    sentTo: string;
+    means: CommunicationMeans;
+    note?: string | null;
+} | {
+    type: 'registerComplaint';
+    complaintAt?: string | null;
+    note: string;
+};
+/** Datos de una vulneración al registrarla o corregirla. */
+export interface DataBreachWritePayload {
+    detectedAt: string;
+    occurredAt?: string | null;
+    kinds: DataBreachKind[];
+    description: string;
+    effects?: string | null;
+    dataCategories: string[];
+    affectedCount?: number | null;
+    measures?: string | null;
+    sensitiveData?: boolean;
+    minorsData?: boolean;
+    financialData?: boolean;
+    riskToRights?: boolean;
+    treatmentId?: string | null;
+}
+/** Un paso de la gestión de una vulneración. */
+export type DataBreachAction = 
+/** Reporte a la Agencia, con el medio y su número o folio. */
+{
+    type: 'reportAgency';
+    reportedAt?: string | null;
+    note: string;
+}
+/** Comunicación a los titulares: a cada uno o, si no es posible, un aviso en un medio masivo nacional. */
+ | {
+    type: 'notifyHolders';
+    notifiedAt?: string | null;
+    means: DataBreachNoticeMeans;
+    note: string;
+} | {
+    type: 'close';
+    note?: string | null;
+};
+export interface DataProtectionContract {
+    [DataProtectionPatterns.getTreatments]: {
+        payload: {
+            enabled?: boolean | null;
+        };
+        response: DataTreatmentResponseEntity[];
+    };
+    [DataProtectionPatterns.createTreatment]: {
+        payload: DataTreatmentWritePayload;
+        response: DataTreatmentResponseEntity;
+    };
+    [DataProtectionPatterns.updateTreatment]: {
+        payload: DataTreatmentWritePayload & {
+            id: string;
+        };
+        response: DataTreatmentResponseEntity;
+    };
+    [DataProtectionPatterns.setTreatmentEnabled]: {
+        payload: {
+            id: string;
+            enabled: boolean;
+        };
+        response: DataTreatmentResponseEntity;
+    };
+    /** Lo que se publica sin sesión (art. 14 ter): los tratamientos habilitados y publicados. */
+    [DataProtectionPatterns.getPolicy]: {
+        payload: Record<string, never>;
+        response: DataProtectionPolicyEntity;
+    };
+    [DataProtectionPatterns.getRequests]: {
+        payload: {
+            status?: 'open' | 'resolved' | 'all';
+            year?: number | null;
+            search?: string;
+            page?: number;
+            limit?: number;
+        };
+        response: RpcPage<DataRightsRequestListItemEntity[]>;
+    };
+    [DataProtectionPatterns.getRequest]: {
+        payload: {
+            id: string;
+        };
+        response: DataRightsRequestDetailEntity;
+    };
+    [DataProtectionPatterns.getSummary]: {
+        payload: {
+            year: number;
+        };
+        response: DataRightsSummaryEntity;
+    };
+    [DataProtectionPatterns.createRequest]: {
+        payload: DataRightsRequestWritePayload & {
+            actor: TActor;
+        };
+        response: DataRightsRequestDetailEntity;
+    };
+    [DataProtectionPatterns.updateRequest]: {
+        payload: DataRightsRequestWritePayload & {
+            id: string;
+            actor: TActor;
+        };
+        response: DataRightsRequestDetailEntity;
+    };
+    [DataProtectionPatterns.actOnRequest]: {
+        payload: {
+            id: string;
+            action: DataRightsAction;
+            actor: TActor;
+        };
+        response: DataRightsRequestDetailEntity;
+    };
+    /** Las vulneraciones del año (o todas las abiertas), de la más reciente a la más antigua. */
+    [DataProtectionPatterns.getBreaches]: {
+        payload: {
+            year?: number | null;
+            openOnly?: boolean;
+        };
+        response: DataBreachResponseEntity[];
+    };
+    [DataProtectionPatterns.getBreach]: {
+        payload: {
+            id: string;
+        };
+        response: DataBreachResponseEntity;
+    };
+    [DataProtectionPatterns.createBreach]: {
+        payload: DataBreachWritePayload & {
+            actor: TActor;
+        };
+        response: DataBreachResponseEntity;
+    };
+    [DataProtectionPatterns.updateBreach]: {
+        payload: DataBreachWritePayload & {
+            id: string;
+            actor: TActor;
+        };
+        response: DataBreachResponseEntity;
+    };
+    [DataProtectionPatterns.actOnBreach]: {
+        payload: {
+            id: string;
+            action: DataBreachAction;
+            actor: TActor;
+        };
+        response: DataBreachResponseEntity;
+    };
+    /** El registro de la vulneración en PDF, para reportarla o archivarla. */
+    [DataProtectionPatterns.getBreachPdf]: {
+        payload: {
+            id: string;
+            generatedBy: string;
+        };
+        response: IndicatorsFileEntity;
+    };
+}
+export {};

package/dist/contracts/dataProtection.contract.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataProtectionPatterns = void 0;
+/** Patrones NATS de `dataProtection`: tratamientos de datos y solicitudes de los titulares (Ley 19.628). */
+exports.DataProtectionPatterns = {
+    getTreatments: 'gestorDocumental.dataProtection.getTreatments',
+    createTreatment: 'gestorDocumental.dataProtection.createTreatment',
+    updateTreatment: 'gestorDocumental.dataProtection.updateTreatment',
+    setTreatmentEnabled: 'gestorDocumental.dataProtection.setTreatmentEnabled',
+    getPolicy: 'gestorDocumental.dataProtection.getPolicy',
+    getRequests: 'gestorDocumental.dataProtection.getRequests',
+    getRequest: 'gestorDocumental.dataProtection.getRequest',
+    getSummary: 'gestorDocumental.dataProtection.getSummary',
+    createRequest: 'gestorDocumental.dataProtection.createRequest',
+    updateRequest: 'gestorDocumental.dataProtection.updateRequest',
+    actOnRequest: 'gestorDocumental.dataProtection.actOnRequest',
+    getBreaches: 'gestorDocumental.dataProtection.getBreaches',
+    getBreach: 'gestorDocumental.dataProtection.getBreach',
+    createBreach: 'gestorDocumental.dataProtection.createBreach',
+    updateBreach: 'gestorDocumental.dataProtection.updateBreach',
+    actOnBreach: 'gestorDocumental.dataProtection.actOnBreach',
+    getBreachPdf: 'gestorDocumental.dataProtection.getBreachPdf',
+};

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

@@ -0,0 +1,86 @@
+import { type CaseFileActuationType, type DeskFileSource, type DocumentAccessLevel } from '../base/entities';
+import { type CaseFileAddEntryResponseEntity, type DeskFileResponseEntity, type DeskOkResponseEntity, type DeskSummaryEntity, type DocumentPublicFileResponseEntity } from '../entities';
+import { type DocumentActor } from './document.contract';
+/** Patrones NATS de `desk`: el escritorio de documentos de cada funcionario («Sin clasificar»). */
+export declare const DeskPatterns: {
+    readonly getFiles: "gestorDocumental.desk.getFiles";
+    readonly getSummary: "gestorDocumental.desk.getSummary";
+    readonly addFiles: "gestorDocumental.desk.addFiles";
+    readonly getFile: "gestorDocumental.desk.getFile";
+    readonly remove: "gestorDocumental.desk.remove";
+    readonly classify: "gestorDocumental.desk.classify";
+    readonly moveToCaseFile: "gestorDocumental.desk.moveToCaseFile";
+};
+export interface DeskContract {
+    /** Los archivos sin clasificar de quien tiene la sesión, del más reciente al más antiguo. */
+    [DeskPatterns.getFiles]: {
+        payload: {
+            actor: DocumentActor;
+        };
+        response: DeskFileResponseEntity[];
+    };
+    [DeskPatterns.getSummary]: {
+        payload: {
+            actor: DocumentActor;
+        };
+        response: DeskSummaryEntity;
+    };
+    /** Archivos ya subidos a la carpeta del gestor (por el gateway), que quedan en el escritorio. */
+    [DeskPatterns.addFiles]: {
+        payload: {
+            files: {
+                fileId: string;
+                fileName: string;
+            }[];
+            source?: DeskFileSource;
+            description?: string | null;
+            actor: DocumentActor;
+        };
+        response: DeskFileResponseEntity[];
+    };
+    /** El archivo, solo para su dueño. */
+    [DeskPatterns.getFile]: {
+        payload: {
+            id: string;
+            actor: DocumentActor;
+        };
+        response: DocumentPublicFileResponseEntity;
+    };
+    /** Lo quita del escritorio. El archivo no se borra. */
+    [DeskPatterns.remove]: {
+        payload: {
+            id: string;
+            actor: DocumentActor;
+        };
+        response: DeskOkResponseEntity;
+    };
+    /** Se redactó o firmó un documento con este archivo: deja el escritorio. El documento tiene que ser de su dueño. */
+    [DeskPatterns.classify]: {
+        payload: {
+            id: string;
+            documentId: string;
+            actor: DocumentActor;
+        };
+        response: DeskOkResponseEntity;
+    };
+    /** Lo incorpora como actuación a un expediente abierto en que puede incorporar, con sus metadatos. */
+    [DeskPatterns.moveToCaseFile]: {
+        payload: {
+            id: string;
+            caseFileId: string;
+            entry: {
+                actuationType: CaseFileActuationType;
+                title: string;
+                documentTypeName?: string | null;
+                originDate?: string | null;
+                author?: string | null;
+                keywords: string[];
+                accessLevel: DocumentAccessLevel;
+                hasSensitiveData: boolean;
+            };
+            folder?: string | null;
+            actor: DocumentActor;
+        };
+        response: CaseFileAddEntryResponseEntity;
+    };
+}

package/dist/contracts/desk.contract.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeskPatterns = void 0;
+/** Patrones NATS de `desk`: el escritorio de documentos de cada funcionario («Sin clasificar»). */
+exports.DeskPatterns = {
+    getFiles: 'gestorDocumental.desk.getFiles',
+    getSummary: 'gestorDocumental.desk.getSummary',
+    addFiles: 'gestorDocumental.desk.addFiles',
+    getFile: 'gestorDocumental.desk.getFile',
+    remove: 'gestorDocumental.desk.remove',
+    classify: 'gestorDocumental.desk.classify',
+    moveToCaseFile: 'gestorDocumental.desk.moveToCaseFile',
+};