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

package/src/contracts/accessRequest.contract.ts

@@ -0,0 +1,81 @@
+import { type AccessRequestChannel, type AccessRequestResolution } from '../base/entities';
+import {
+  type AccessRequestDetailEntity,
+  type AccessRequestListItemEntity,
+  type AccessRequestSummaryEntity,
+} from '../entities';
+import { type RpcPage } from './contract';
+
+/** Patrones NATS de `accessRequest`: solicitudes de acceso a la información pública (Ley 20.285). */
+export const AccessRequestPatterns = {
+  getAll: 'gestorDocumental.accessRequest.getAll',
+  getById: 'gestorDocumental.accessRequest.getById',
+  getSummary: 'gestorDocumental.accessRequest.getSummary',
+  create: 'gestorDocumental.accessRequest.create',
+  update: 'gestorDocumental.accessRequest.update',
+  act: 'gestorDocumental.accessRequest.act',
+} as const;
+
+export interface AccessRequestWritePayload {
+  externalFolio?: string | null;
+  channel: AccessRequestChannel;
+  /** Fecha y hora de ingreso (ISO): desde ahí corren los 20 días hábiles. */
+  receivedAt: string;
+  requesterName: string;
+  requesterEmail?: string | null;
+  requesterAddress?: string | null;
+  requestText: string;
+  deliveryFormat?: string | null;
+}
+
+/** Lo que se hace con una solicitud, un paso a la vez. */
+export type AccessRequestAction =
+  | { type: 'requestCorrection'; note: string }
+  | { type: 'registerCorrection'; correctedAt?: string | null; note?: string | null }
+  | { type: 'assign'; employeeId: string; fullName: string; note?: string | null }
+  | { type: 'notifyThirdParty'; note: string }
+  | { type: 'registerOpposition'; opposed: boolean; note?: string | null }
+  | { type: 'extend'; note: string }
+  | {
+      type: 'resolve';
+      resolution: AccessRequestResolution;
+      grounds?: string[];
+      derivedTo?: string | null;
+      note?: string | null;
+      responseDocumentId?: string | null;
+      documentIds?: string[];
+    }
+  | { type: 'registerAppeal'; appealedAt?: string | null; note: string };
+
+export interface AccessRequestActor {
+  employeeId: string;
+  fullName: string;
+}
+
+export interface AccessRequestContract {
+  [AccessRequestPatterns.getAll]: {
+    payload: {
+      status?: 'open' | 'resolved' | 'all';
+      year?: number | null;
+      search?: string;
+      page?: number;
+      limit?: number;
+    };
+    response: RpcPage<AccessRequestListItemEntity[]>;
+  };
+  [AccessRequestPatterns.getById]: { payload: { id: string }; response: AccessRequestDetailEntity };
+  [AccessRequestPatterns.getSummary]: { payload: { year: number }; response: AccessRequestSummaryEntity };
+  [AccessRequestPatterns.create]: {
+    payload: AccessRequestWritePayload & { actor: AccessRequestActor };
+    response: AccessRequestDetailEntity;
+  };
+  /** Corrige los datos mientras no está resuelta. */
+  [AccessRequestPatterns.update]: {
+    payload: AccessRequestWritePayload & { id: string; actor: AccessRequestActor };
+    response: AccessRequestDetailEntity;
+  };
+  [AccessRequestPatterns.act]: {
+    payload: { id: string; action: AccessRequestAction; actor: AccessRequestActor };
+    response: AccessRequestDetailEntity;
+  };
+}

package/src/contracts/archivalSeries.contract.ts

@@ -0,0 +1,59 @@
+import { type FinalDisposition } from '../base/entities';
+import { type ArchivalSeriesEntity } from '../base/entities';
+import {
+  type ArchivalSeriesCreateResponseEntity,
+  type ArchivalSeriesGetAllResponseEntity,
+  type ArchivalSeriesGetByIdResponseEntity,
+  type ArchivalSeriesUpdateResponseEntity,
+} from '../entities';
+import { type RpcPage } from './contract';
+
+/** Patrones NATS de `archivalSeries` (series del Cuadro de Clasificación): `<servicio>.<recurso>.<acción>`. */
+export const ArchivalSeriesPatterns = {
+  getAll: 'gestorDocumental.archivalSeries.getAll',
+  getById: 'gestorDocumental.archivalSeries.getById',
+  create: 'gestorDocumental.archivalSeries.create',
+  update: 'gestorDocumental.archivalSeries.update',
+  setEnabled: 'gestorDocumental.archivalSeries.setEnabled',
+} as const;
+
+/** Datos de una serie documental al crearla o editarla. */
+export interface ArchivalSeriesWritePayload {
+  code: string;
+  name: string;
+  section?: string | null;
+  description?: string | null;
+  enabled?: boolean;
+  /** Tabla de Retención Documental: los tres juntos o ninguno. */
+  managementYears?: number | null;
+  centralYears?: number | null;
+  finalDisposition?: FinalDisposition | null;
+  retentionNote?: string | null;
+}
+
+export interface ArchivalSeriesContract {
+  [ArchivalSeriesPatterns.getAll]: {
+    // sin `page` y `limit` responde todas en una sola página
+    payload: {
+      pagination?: { page?: number; limit?: number };
+      filters?: { search?: string; enabled?: boolean };
+    };
+    response: RpcPage<ArchivalSeriesGetAllResponseEntity[]>;
+  };
+  [ArchivalSeriesPatterns.getById]: {
+    payload: Pick<ArchivalSeriesEntity, 'id'>;
+    response: ArchivalSeriesGetByIdResponseEntity;
+  };
+  [ArchivalSeriesPatterns.create]: {
+    payload: ArchivalSeriesWritePayload;
+    response: ArchivalSeriesCreateResponseEntity;
+  };
+  [ArchivalSeriesPatterns.update]: {
+    payload: ArchivalSeriesWritePayload & Pick<ArchivalSeriesEntity, 'id'>;
+    response: ArchivalSeriesUpdateResponseEntity;
+  };
+  [ArchivalSeriesPatterns.setEnabled]: {
+    payload: Pick<ArchivalSeriesEntity, 'id' | 'enabled'>;
+    response: ArchivalSeriesUpdateResponseEntity;
+  };
+}

package/src/contracts/audit.contract.ts

@@ -0,0 +1,30 @@
+import { type AuditEventEntity, type AuditSource, type IndicatorsFileEntity } from '../entities';
+import { type RpcPage } from './contract';
+
+/** Patrones NATS de `audit`: la auditoría reúne todos los registros del gestor en una sola vista. */
+export const AuditPatterns = {
+  getEvents: 'gestorDocumental.audit.getEvents',
+  export: 'gestorDocumental.audit.export',
+} as const;
+
+/** Qué hechos: período (días de Chile «AAAA-MM-DD», hasta un año) y filtros optativos. */
+export interface AuditQuery {
+  from: string;
+  to: string;
+  sources?: AuditSource[];
+  /** Parte del nombre de quien actuó. */
+  person?: string;
+  /** Parte del folio, materia, IUIe, título o nombre de lo afectado. */
+  reference?: string;
+  page?: number;
+  limit?: number;
+}
+
+export interface AuditContract {
+  [AuditPatterns.getEvents]: { payload: AuditQuery; response: RpcPage<AuditEventEntity[]> };
+  /** Los hechos filtrados (hasta 10.000) en Excel. `generatedBy`: quién la descarga. */
+  [AuditPatterns.export]: {
+    payload: Omit<AuditQuery, 'page' | 'limit'> & { generatedBy: string };
+    response: IndicatorsFileEntity;
+  };
+}

package/src/contracts/caseFile.contract.ts

@@ -0,0 +1,228 @@
+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 const 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',
+} as const;
+
+/** 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]: {
+    // `folder`: subcarpeta del índice en que queda (sin valor: en la raíz)
+    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;
+  };
+}

package/src/contracts/dataProtection.contract.ts

@@ -0,0 +1,195 @@
+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 const 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',
+} as const;
+
+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;
+  };
+}

package/src/contracts/desk.contract.ts

@@ -0,0 +1,68 @@
+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 const 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',
+} as const;
+
+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;
+  };
+}