@muni-sanfer/types-gestor-documental 0.0.1-beta.27 → 0.0.1-beta.29

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

@@ -1,5 +1,5 @@
 import { type CommunicationMeans, type DocumentAccessLevel, type DocumentInstruction } from '../base/entities';
-import { type DocDigitalDocumentTypeEntity, type DocDigitalEntityEntity, type PartsOfficeInboundEntity, type DocDigitalUserEntity, type EnablementPersonInput, type PartsOfficeEnablementEntity, type PartsOfficeDispatchEntity, type PartsOfficeFileEntity, type PartsOfficeOkResponseEntity, type PartsOfficeRegisterResponseEntity, type PartsOfficeStatusEntity, type PartsOfficeSummaryEntity, type PartsOfficeSyncResponseEntity } from '../entities';
+import { type CaseFileAddEntryResponseEntity, type DocDigitalDocumentTypeEntity, type DocDigitalEntityEntity, type PartsOfficeInboundEntity, type DocDigitalUserEntity, type EnablementPersonInput, type PartsOfficeEnablementEntity, 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>`. */
@@ -24,6 +24,7 @@ export declare const PartsOfficePatterns: {
     readonly checkEnablement: "gestorDocumental.partsOffice.checkEnablement";
     readonly dispatchByContingency: "gestorDocumental.partsOffice.dispatchByContingency";
     readonly registerManualIntake: "gestorDocumental.partsOffice.registerManualIntake";
+    readonly addCaseFileReceipt: "gestorDocumental.partsOffice.addCaseFileReceipt";
 };
 /** Destinatario interno de un ingreso, ya resuelto por el gateway (las áreas con sus integrantes). */
 export type PartsOfficeRecipientInput = {
@@ -244,5 +245,19 @@ export interface PartsOfficeContract {
         payload: ManualIntakePayload;
         response: PartsOfficeRegisterResponseEntity;
     };
+    /**
+     * Comprobante de trazabilidad de DocDigital de un documento del índice de un expediente (despachado o recibido por
+     * DocDigital): se arma con el estado y el historial que informa DocDigital y entra como comunicación oficial.
+     */
+    [PartsOfficePatterns.addCaseFileReceipt]: {
+        payload: {
+            caseFileId: string;
+            documentId: string;
+            actor: {
+                employeeId: string;
+            };
+        };
+        response: CaseFileAddEntryResponseEntity;
+    };
 }
 export {};

package/dist/contracts/partsOffice.contract.js

@@ -23,4 +23,5 @@ exports.PartsOfficePatterns = {
     checkEnablement: 'gestorDocumental.partsOffice.checkEnablement',
     dispatchByContingency: 'gestorDocumental.partsOffice.dispatchByContingency',
     registerManualIntake: 'gestorDocumental.partsOffice.registerManualIntake',
+    addCaseFileReceipt: 'gestorDocumental.partsOffice.addCaseFileReceipt',
 };

package/dist/entities/caseFile/caseFile.entity.d.ts

@@ -29,6 +29,8 @@ export interface CaseFileEntryDocumentEntity {
     correlative: DocumentEntity['correlative'];
     correlativeYear: DocumentEntity['correlativeYear'];
     documentType: DocumentTypeSummaryEntity;
+    /** N° del documento en DocDigital, si se despachó o se recibió por ahí: tiene comprobante de trazabilidad. */
+    docDigitalDocumentId: string | null;
 }
 /** Entrada del índice electrónico: una actuación, en su orden de incorporación. */
 export interface CaseFileEntryResponseEntity {

package/dist/entities/dataProtection/dataProtection.entity.d.ts

@@ -0,0 +1,174 @@
+import { type CommunicationMeans, type DataBreachEventAction, type DataBreachKind, type DataBreachNoticeMeans, type DataBreachStatus, type DataLegalBasis, type DataRight, type DataRightsChannel, type DataRightsEventAction, type DataRightsRequestStatus, type DataRightsResolution } from '../../base/entities';
+/** Tratamiento de datos personales de la municipalidad: lo que se informa al público (Ley 19.628, art. 14 ter). */
+export interface DataTreatmentResponseEntity {
+    id: string;
+    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;
+    enabled: boolean;
+    /** Solicitudes de titulares que lo mencionan. */
+    requests: number;
+    updatedAt: string;
+}
+/** Página pública de protección de datos: quién es el responsable, cómo ejercer los derechos y qué se trata. */
+export interface DataProtectionPolicyEntity {
+    organ: string;
+    /** Correo o medio en que se reciben las solicitudes de los titulares (art. 14 ter letra c). */
+    contact: string | null;
+    /** Dirección de la política de tratamiento, si está publicada aparte. */
+    policyUrl: string | null;
+    treatments: Omit<DataTreatmentResponseEntity, 'published' | 'enabled' | 'requests' | 'securityMeasures'>[];
+}
+/** Semáforo del plazo: a tiempo, por vencer (5 días corridos o menos) o vencido. */
+export type DataRightsDueStatus = 'OnTime' | 'DueSoon' | 'Overdue';
+export interface DataRightsRequestListItemEntity {
+    id: string;
+    /** «N° 4/2026». */
+    label: string;
+    channel: DataRightsChannel;
+    rights: DataRight[];
+    requesterName: string;
+    requestText: string;
+    treatmentName: string | null;
+    receivedAt: string;
+    dueAt: string;
+    status: DataRightsRequestStatus;
+    resolution: DataRightsResolution | null;
+    assigneeFullName: string | null;
+    acknowledged: boolean;
+    identityVerified: boolean;
+    /** Bloqueo temporal pedido y sin resolver. */
+    blockingPending: boolean;
+    /** Solo mientras está abierta. */
+    dueStatus: DataRightsDueStatus | null;
+    daysLeft: number | null;
+    resolvedOnTime: boolean | null;
+}
+export interface DataRightsDocumentLinkEntity {
+    id: string;
+    folio: string | null;
+    subject: string;
+}
+export interface DataRightsRequestDetailEntity extends DataRightsRequestListItemEntity {
+    year: number;
+    number: number;
+    requesterRut: string | null;
+    requesterEmail: string | null;
+    requesterAddress: string | null;
+    representativeName: string | null;
+    identityVerifiedAt: string | null;
+    identityNote: string | null;
+    treatmentId: string | null;
+    acknowledgedAt: string | null;
+    extendedAt: string | null;
+    extensionNote: string | null;
+    blockingRequested: boolean;
+    blockingReason: string | null;
+    blockingDueAt: string | null;
+    blockingGranted: boolean | null;
+    blockingResolvedAt: string | null;
+    blockingNote: string | null;
+    assigneeEmployeeId: string | null;
+    resolvedAt: string | null;
+    denialGrounds: string[];
+    resolutionNote: string | null;
+    responseDocument: DataRightsDocumentLinkEntity | null;
+    responseSentAt: string | null;
+    responseSentTo: string | null;
+    responseSentMeans: CommunicationMeans | null;
+    /** Hasta cuándo el titular puede reclamar ante la Agencia (30 días hábiles), si se denegó en todo o en parte. */
+    complaintDeadline: string | null;
+    complaintAt: string | null;
+    complaintNote: string | null;
+    createdByFullName: string;
+    /** Se puede prorrogar: abierta, sin prórroga y antes de vencer. */
+    canExtend: boolean;
+    /** El titular ya puede reclamar ante la Agencia: denegación o plazo vencido sin respuesta. */
+    canRegisterComplaint: boolean;
+    events: {
+        action: DataRightsEventAction;
+        note: string | null;
+        employeeFullName: string;
+        createdAt: string;
+    }[];
+}
+export interface DataRightsSummaryEntity {
+    year: number;
+    total: number;
+    open: number;
+    overdue: number;
+    dueSoon: number;
+    /** Abiertas sin acuse de recibo. */
+    unacknowledged: number;
+    /** Bloqueos temporales pedidos y sin resolver. */
+    blockingPending: number;
+    byRight: Record<DataRight, number>;
+    resolved: Record<DataRightsResolution, number>;
+    /** Respondidas dentro del plazo sobre las respondidas, en %. */
+    onTimeRate: number | null;
+    complaints: number;
+}
+/** Datos personales que se reconocen en el texto de un documento, enmascarados: ayudan a tarjar. */
+export interface PersonalDataHintsEntity {
+    ruts: number;
+    emails: number;
+    phones: number;
+    /** Algunos ejemplos enmascarados («11.1••.•••-1»). */
+    samples: string[];
+}
+/** Vulneración de las medidas de seguridad que afecta datos personales (Ley 19.628, art. 14 sexies). */
+export interface DataBreachResponseEntity {
+    id: string;
+    /** «N° 2/2026». */
+    label: string;
+    year: number;
+    number: number;
+    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;
+    treatmentName: string | null;
+    status: DataBreachStatus;
+    /** Hay riesgo razonable para los titulares: se reporta a la Agencia sin dilaciones indebidas. */
+    mustReportAgency: boolean;
+    /** Además, datos sensibles, de menores de 14 o de obligaciones económicas: se comunica a los titulares. */
+    mustNotifyHolders: boolean;
+    agencyReportedAt: string | null;
+    agencyReportNote: string | null;
+    /** Horas entre la detección y el reporte a la Agencia (o hasta ahora, si falta reportarla). */
+    agencyDelayHours: number | null;
+    holdersNotifiedAt: string | null;
+    holdersNoticeMeans: DataBreachNoticeMeans | null;
+    holdersNoticeNote: string | null;
+    closedAt: string | null;
+    closeNote: string | null;
+    createdByFullName: string;
+    /** Por qué todavía no se puede cerrar, o `null` si se puede. */
+    closeBlock: string | null;
+    events: {
+        action: DataBreachEventAction;
+        note: string | null;
+        employeeFullName: string;
+        createdAt: string;
+    }[];
+}

package/dist/entities/dataProtection/dataProtection.entity.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/entities/dataProtection/index.d.ts

@@ -0,0 +1 @@
+export * from './dataProtection.entity';

package/dist/entities/dataProtection/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./dataProtection.entity"), exports);

package/dist/entities/index.d.ts

@@ -18,3 +18,4 @@ export * from './repositoryExport';
 export * from './retention';
 export * from './accessRequest';
 export * from './transparency';
+export * from './dataProtection';

package/dist/entities/index.js

@@ -34,3 +34,4 @@ __exportStar(require("./repositoryExport"), exports);
 __exportStar(require("./retention"), exports);
 __exportStar(require("./accessRequest"), exports);
 __exportStar(require("./transparency"), exports);
+__exportStar(require("./dataProtection"), exports);

package/dist/entities/transparency/transparency.entity.d.ts

@@ -1,4 +1,5 @@
 import { type DocumentAccessLevel, type DocumentStatus } from '../../base/entities';
+import { type PersonalDataHintsEntity } from '../dataProtection';
 /** En qué quedó un documento en Transparencia Activa: aún sin decidir, publicado o excluido con su motivo. */
 export type TransparencyItemStatus = 'Pending' | 'Published' | 'Excluded';
 /** Un documento que se publica en Transparencia Activa (Ley 20.285, art. 7°), con lo que se decidió de él. */
@@ -24,6 +25,8 @@ export interface TransparencyItemEntity {
     /** Para publicarlo hace falta antes la versión tarjada. */
     needsRedacted: boolean;
     redactedFileName: string | null;
+    /** RUN, correos y teléfonos que se reconocen en el texto del original (`null` si no tiene texto): ayudan a tarjar. */
+    personalData: PersonalDataHintsEntity | null;
     status: TransparencyItemStatus;
     /** Dirección de la publicación en el Portal de Transparencia, si se anotó. */
     transparencyUrl: string | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@muni-sanfer/types-gestor-documental",
-  "version": "0.0.1-beta.27",
+  "version": "0.0.1-beta.29",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {

package/src/base/entities.ts

@@ -518,6 +518,40 @@ export const DataRightsEventAction = {
   ComplaintRegistered: 'ComplaintRegistered',
 } satisfies Record<string, DataRightsEventAction>;
 
+export type DataBreachKind = 'Destruction' | 'Leak' | 'Loss' | 'Alteration' | 'UnauthorizedAccess';
+
+export const DataBreachKind = {
+  Destruction: 'Destruction',
+  Leak: 'Leak',
+  Loss: 'Loss',
+  Alteration: 'Alteration',
+  UnauthorizedAccess: 'UnauthorizedAccess',
+} satisfies Record<string, DataBreachKind>;
+
+export type DataBreachStatus = 'Open' | 'Closed';
+
+export const DataBreachStatus = {
+  Open: 'Open',
+  Closed: 'Closed',
+} satisfies Record<string, DataBreachStatus>;
+
+export type DataBreachEventAction = 'Registered' | 'Updated' | 'AgencyReported' | 'HoldersNotified' | 'Closed';
+
+export const DataBreachEventAction = {
+  Registered: 'Registered',
+  Updated: 'Updated',
+  AgencyReported: 'AgencyReported',
+  HoldersNotified: 'HoldersNotified',
+  Closed: 'Closed',
+} satisfies Record<string, DataBreachEventAction>;
+
+export type DataBreachNoticeMeans = 'Individual' | 'PublicNotice';
+
+export const DataBreachNoticeMeans = {
+  Individual: 'Individual',
+  PublicNotice: 'PublicNotice',
+} satisfies Record<string, DataBreachNoticeMeans>;
+
 export interface DocumentTypeEntity {
   id: string;
   name: string;
@@ -1263,6 +1297,7 @@ export interface DataTreatmentEntity {
   responsibleUnit?: string | null;
   published: boolean;
   requests?: DataRightsRequestEntity[];
+  breaches?: DataBreachEntity[];
   enabled: boolean;
   deleted: boolean;
   createdAt: string;
@@ -1328,4 +1363,48 @@ export interface DataRightsEventEntity {
   createdAt: string;
 }
 
+export interface DataBreachEntity {
+  id: string;
+  number: number;
+  year: number;
+  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;
+  treatment?: DataTreatmentEntity | null;
+  treatmentId?: string | null;
+  status: DataBreachStatus;
+  agencyReportedAt?: string | null;
+  agencyReportNote?: string | null;
+  holdersNotifiedAt?: string | null;
+  holdersNoticeMeans?: DataBreachNoticeMeans | null;
+  holdersNoticeNote?: string | null;
+  closedAt?: string | null;
+  closeNote?: string | null;
+  createdByEmployeeId: string;
+  createdByFullName: string;
+  events?: DataBreachEventEntity[];
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface DataBreachEventEntity {
+  id: string;
+  action: DataBreachEventAction;
+  note?: string | null;
+  employeeId?: string | null;
+  employeeFullName: string;
+  breach?: DataBreachEntity;
+  breachId: string;
+  createdAt: string;
+}
+
 type JsonValue = string | number | boolean | { [key in string]?: JsonValue } | Array<JsonValue> | null;

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/index.ts

@@ -12,6 +12,7 @@ import { RepositoryExportPatterns, type RepositoryExportContract } from './repos
 import { RetentionPatterns, type RetentionContract } from './retention.contract';
 import { AccessRequestPatterns, type AccessRequestContract } from './accessRequest.contract';
 import { TransparencyPatterns, type TransparencyContract } from './transparency.contract';
+import { DataProtectionPatterns, type DataProtectionContract } from './dataProtection.contract';
 import { ScanPatterns, type ScanContract } from './scan.contract';
 import { PartsOfficePatterns, type PartsOfficeContract } from './partsOffice.contract';
 import { ProcedurePatterns, type ProcedureContract } from './procedure.contract';
@@ -40,6 +41,7 @@ export * from './repositoryExport.contract';
 export * from './retention.contract';
 export * from './accessRequest.contract';
 export * from './transparency.contract';
+export * from './dataProtection.contract';
 
 /** Patrones NATS de gestor-documental-ms, por recurso: `gestorDocumental.<recurso>.<acción>`. */
 export const GestorDocumentalPatterns = {
@@ -63,6 +65,7 @@ export const GestorDocumentalPatterns = {
   retention: RetentionPatterns,
   accessRequest: AccessRequestPatterns,
   transparency: TransparencyPatterns,
+  dataProtection: DataProtectionPatterns,
 } as const;
 
 /** Contrato completo de gestor-documental-ms: la unión de los contratos de sus recursos. */
@@ -85,4 +88,5 @@ export type GestorDocumentalContract = DocumentTypeContract &
   RepositoryExportContract &
   RetentionContract &
   AccessRequestContract &
-  TransparencyContract;
+  TransparencyContract &
+  DataProtectionContract;

package/src/contracts/partsOffice.contract.ts

@@ -1,5 +1,6 @@
 import { type CommunicationMeans, type DocumentAccessLevel, type DocumentInstruction } from '../base/entities';
 import {
+  type CaseFileAddEntryResponseEntity,
   type DocDigitalDocumentTypeEntity,
   type DocDigitalEntityEntity,
   type PartsOfficeInboundEntity,
@@ -39,6 +40,7 @@ export const PartsOfficePatterns = {
   checkEnablement: 'gestorDocumental.partsOffice.checkEnablement',
   dispatchByContingency: 'gestorDocumental.partsOffice.dispatchByContingency',
   registerManualIntake: 'gestorDocumental.partsOffice.registerManualIntake',
+  addCaseFileReceipt: 'gestorDocumental.partsOffice.addCaseFileReceipt',
 } as const;
 
 /** Destinatario interno de un ingreso, ya resuelto por el gateway (las áreas con sus integrantes). */
@@ -186,4 +188,12 @@ export interface PartsOfficeContract {
     payload: ManualIntakePayload;
     response: PartsOfficeRegisterResponseEntity;
   };
+  /**
+   * Comprobante de trazabilidad de DocDigital de un documento del índice de un expediente (despachado o recibido por
+   * DocDigital): se arma con el estado y el historial que informa DocDigital y entra como comunicación oficial.
+   */
+  [PartsOfficePatterns.addCaseFileReceipt]: {
+    payload: { caseFileId: string; documentId: string; actor: { employeeId: string } };
+    response: CaseFileAddEntryResponseEntity;
+  };
 }

package/src/entities/caseFile/caseFile.entity.ts

@@ -42,6 +42,8 @@ export interface CaseFileEntryDocumentEntity {
   correlative: DocumentEntity['correlative'];
   correlativeYear: DocumentEntity['correlativeYear'];
   documentType: DocumentTypeSummaryEntity;
+  /** N° del documento en DocDigital, si se despachó o se recibió por ahí: tiene comprobante de trazabilidad. */
+  docDigitalDocumentId: string | null;
 }
 
 /** Entrada del índice electrónico: una actuación, en su orden de incorporación. */