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

package/src/contracts/partsOffice.contract.ts

@@ -0,0 +1,199 @@
+import { type CommunicationMeans, type DocumentAccessLevel, type DocumentInstruction } from '../base/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>`. */
+export const PartsOfficePatterns = {
+  getStatus: 'gestorDocumental.partsOffice.getStatus',
+  getSummary: 'gestorDocumental.partsOffice.getSummary',
+  getEntities: 'gestorDocumental.partsOffice.getEntities',
+  getOwnEntities: 'gestorDocumental.partsOffice.getOwnEntities',
+  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',
+  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). */
+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 };
+}
+
+/** Lo que llegó fuera de DocDigital y Oficina de Partes ingresa a mano. */
+export interface ManualIntakePayload {
+  file: { fileId: string; name: string };
+  attachments?: { fileId: string; name: string }[];
+  means: CommunicationMeans;
+  /** Cuándo llegó (ISO); sin él, ahora. */
+  receivedAt?: string | null;
+  senderEntityName: string;
+  senderName?: string | null;
+  externalFolio?: string | null;
+  externalDate?: string | null;
+  subject: string;
+  documentTypeId: string;
+  keywords: string[];
+  accessLevel?: DocumentAccessLevel;
+  hasSensitiveData?: boolean;
+  recipients: unknown[];
+  instruction: DocumentInstruction;
+  note?: string | null;
+  dueAt?: string | null;
+  dueBusinessDays?: number | null;
+  actor: DocumentActor;
+}
+
+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[] };
+  /** Entidades asociadas a las credenciales del gestor: la del municipio y las de sus entidades emisoras. */
+  [PartsOfficePatterns.getOwnEntities]: { payload: Record<string, never>; 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]: {
+    // con `receipt`, el comprobante del despacho por contingencia
+    payload: { id: string; receipt?: boolean };
+    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;
+  };
+  /**
+   * Quiénes de `people` están habilitados como usuarios de DocDigital en la municipalidad o en sus entidades emisoras
+   * (por RUN). El directorio de cada entidad se guarda 10 minutos.
+   */
+  [PartsOfficePatterns.checkEnablement]: {
+    payload: { people: EnablementPersonInput[] };
+    response: PartsOfficeEnablementEntity;
+  };
+  /**
+   * Registro por contingencia: el documento no se pudo despachar por DocDigital y salió por otro medio. Queda
+   * despachado, con el medio, a quién, el motivo y el comprobante; si después se registra en DocDigital, su número.
+   */
+  [PartsOfficePatterns.dispatchByContingency]: {
+    payload: {
+      id: string;
+      means: CommunicationMeans;
+      sentAt: string;
+      sentTo: string;
+      reason: string;
+      receipt?: { fileId: string; name: string } | null;
+      docDigitalDocumentId?: string | null;
+      actor: DocumentActor;
+    };
+    response: PartsOfficeOkResponseEntity;
+  };
+  /**
+   * Ingreso manual: lo que llegó fuera de DocDigital (papel, correo) entra con folio de ingreso, como lo recibido
+   * por DocDigital, y se deriva.
+   */
+  [PartsOfficePatterns.registerManualIntake]: {
+    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/contracts/procedure.contract.ts

@@ -0,0 +1,53 @@
+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 const ProcedurePatterns = {
+  getAll: 'gestorDocumental.procedure.getAll',
+  getById: 'gestorDocumental.procedure.getById',
+  create: 'gestorDocumental.procedure.create',
+  update: 'gestorDocumental.procedure.update',
+  setEnabled: 'gestorDocumental.procedure.setEnabled',
+} as const;
+
+/** 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]: {
+    // sin `page` y `limit` responde todos en una sola página
+    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/src/contracts/registerBook.contract.ts

@@ -0,0 +1,24 @@
+import { type RegisterBookEntity, type RegisterBookExportEntity, type RegisterBookKind } from '../entities';
+
+/** Patrones NATS de `registerBook` (libros de registro): `<servicio>.<recurso>.<acción>`. */
+export const RegisterBookPatterns = {
+  get: 'gestorDocumental.registerBook.get',
+  export: 'gestorDocumental.registerBook.export',
+} as const;
+
+/** 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/src/contracts/repositoryExport.contract.ts

@@ -0,0 +1,54 @@
+import {
+  type RepositoryExportCaseFilesPageEntity,
+  type RepositoryExportRecordResponseEntity,
+  type RepositoryExportDocumentsPageEntity,
+  type RepositoryExportScope,
+  type RepositoryExportSummaryEntity,
+} from '../entities';
+
+/**
+ * Patrones NATS de `repositoryExport`: exportación completa del repositorio (portabilidad). El ms entrega los datos
+ * por páginas, porque un mensaje NATS no admite más de 1 MB; el gateway arma el ZIP con ellos y los archivos.
+ */
+export const RepositoryExportPatterns = {
+  getSummary: 'gestorDocumental.repositoryExport.getSummary',
+  getDocuments: 'gestorDocumental.repositoryExport.getDocuments',
+  getCaseFiles: 'gestorDocumental.repositoryExport.getCaseFiles',
+  record: 'gestorDocumental.repositoryExport.record',
+} as const;
+
+/** Período por fecha de creación (días de Chile «AAAA-MM-DD»); sin él, todo. */
+export interface RepositoryExportQuery {
+  from?: string | null;
+  to?: string | null;
+  scope?: RepositoryExportScope;
+  /** Solo lo incluido en un acta de transferencia: el paquete para el Archivo Nacional. */
+  dispositionId?: string | null;
+}
+
+export interface RepositoryExportContract {
+  [RepositoryExportPatterns.getSummary]: { payload: RepositoryExportQuery; response: RepositoryExportSummaryEntity };
+  /** Hasta 50 documentos por página, en orden de creación. */
+  [RepositoryExportPatterns.getDocuments]: {
+    payload: RepositoryExportQuery & { cursor?: string | null; limit?: number };
+    response: RepositoryExportDocumentsPageEntity;
+  };
+  /** Hasta 10 expedientes por página; cada uno queda con «Exportó» en su trazabilidad, a nombre de quien exporta. */
+  [RepositoryExportPatterns.getCaseFiles]: {
+    payload: Omit<RepositoryExportQuery, 'scope'> & {
+      cursor?: string | null;
+      limit?: number;
+      actor: { employeeId: string | null; fullName: string };
+    };
+    response: RepositoryExportCaseFilesPageEntity;
+  };
+  /** Deja la exportación en la bitácora: quién, qué período y si llevó archivos. */
+  [RepositoryExportPatterns.record]: {
+    payload: RepositoryExportQuery & {
+      includeFiles: boolean;
+      complete: boolean;
+      actor: { employeeId: string | null; fullName: string };
+    };
+    response: RepositoryExportRecordResponseEntity;
+  };
+}

package/src/contracts/retention.contract.ts

@@ -0,0 +1,44 @@
+import { type DispositionKind } from '../base/entities';
+import {
+  type DispositionRecordResponseEntity,
+  type IndicatorsFileEntity,
+  type RetentionDueItemEntity,
+  type RetentionSummaryEntity,
+} from '../entities';
+import { type RpcPage } from './contract';
+
+/** Patrones NATS de `retention`: plazos de retención por serie y actas de transferencia o eliminación. */
+export const RetentionPatterns = {
+  getSummary: 'gestorDocumental.retention.getSummary',
+  getDueItems: 'gestorDocumental.retention.getDueItems',
+  createRecord: 'gestorDocumental.retention.createRecord',
+  getRecords: 'gestorDocumental.retention.getRecords',
+  getRecordPdf: 'gestorDocumental.retention.getRecordPdf',
+} as const;
+
+export interface RetentionContract {
+  [RetentionPatterns.getSummary]: { payload: Record<string, never>; response: RetentionSummaryEntity };
+  /** Lo vencido de una serie, de lo más antiguo a lo más reciente. */
+  [RetentionPatterns.getDueItems]: {
+    payload: { seriesId: string; page?: number; limit?: number };
+    response: RpcPage<RetentionDueItemEntity[]>;
+  };
+  /**
+   * Emite el acta con lo elegido (todo debe estar vencido y sin acta). Según la serie: conservación permanente →
+   * transferencia; eliminación → eliminación; selección → cualquiera de las dos.
+   */
+  [RetentionPatterns.createRecord]: {
+    payload: {
+      kind: DispositionKind;
+      seriesId: string;
+      documentIds: string[];
+      caseFileIds: string[];
+      observation?: string | null;
+      actor: { employeeId: string; fullName: string };
+    };
+    response: DispositionRecordResponseEntity;
+  };
+  [RetentionPatterns.getRecords]: { payload: { year: number }; response: DispositionRecordResponseEntity[] };
+  /** El acta en PDF, con lo que incluye, para firmarla y archivarla. */
+  [RetentionPatterns.getRecordPdf]: { payload: { id: string; generatedBy: string }; response: IndicatorsFileEntity };
+}

package/src/contracts/scan.contract.ts

@@ -0,0 +1,52 @@
+import {
+  type ScanSessionCreateResponseEntity,
+  type ScanSessionFileResponseEntity,
+  type ScanSessionPublicEntity,
+  type ScanSessionResponseEntity,
+} from '../entities';
+import { type DocumentActor } from './document.contract';
+
+/** Patrones NATS de `scan`: escanear con el celular. */
+export const ScanPatterns = {
+  create: 'gestorDocumental.scan.create',
+  getById: 'gestorDocumental.scan.getById',
+  getFile: 'gestorDocumental.scan.getFile',
+  getByToken: 'gestorDocumental.scan.getByToken',
+  addPage: 'gestorDocumental.scan.addPage',
+  finish: 'gestorDocumental.scan.finish',
+} as const;
+
+export interface ScanContract {
+  /**
+   * Abre una sesión de escaneo para el funcionario. `url` es la dirección pública del celular (sin el token): con ella
+   * se arma el QR que se muestra en el escritorio.
+   */
+  [ScanPatterns.create]: {
+    payload: { url: string; actor: DocumentActor };
+    response: ScanSessionCreateResponseEntity;
+  };
+  /** Estado de la sesión, para quien la abrió: el escritorio la consulta hasta que el PDF esté listo. */
+  [ScanPatterns.getById]: {
+    payload: { id: string; actor: DocumentActor };
+    response: ScanSessionResponseEntity;
+  };
+  [ScanPatterns.getFile]: {
+    payload: { id: string; actor: DocumentActor };
+    response: ScanSessionFileResponseEntity;
+  };
+  /** Sin sesión, desde el celular, con el token del QR. */
+  [ScanPatterns.getByToken]: {
+    payload: { token: string };
+    response: ScanSessionPublicEntity;
+  };
+  /** Agrega una foto ya subida al gestor de archivos (la sube el gateway). */
+  [ScanPatterns.addPage]: {
+    payload: { token: string; fileId: string; contentType: string; size: number };
+    response: ScanSessionPublicEntity;
+  };
+  /** Junta las fotos en un PDF y cierra la sesión. */
+  [ScanPatterns.finish]: {
+    payload: { token: string };
+    response: ScanSessionPublicEntity;
+  };
+}

package/src/contracts/signatureBatch.contract.ts

@@ -0,0 +1,96 @@
+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 const 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',
+} as const;
+
+/** 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[];
+      // Etapa de cada visador: los de una misma etapa visan a la vez.
+      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/src/contracts/signatureCheck.contract.ts

@@ -0,0 +1,11 @@
+import { type PdfSignatureReportEntity } from '../entities';
+
+/** Patrones NATS de `signatureCheck`: revisión de las firmas electrónicas de un PDF. */
+export const SignatureCheckPatterns = {
+  check: 'gestorDocumental.signatureCheck.check',
+} as const;
+
+export interface SignatureCheckContract {
+  /** Revisa un PDF ya subido al gestor de archivos (la herramienta «Validar firmas» lo sube antes). */
+  [SignatureCheckPatterns.check]: { payload: { fileId: string }; response: PdfSignatureReportEntity };
+}

package/src/contracts/textSnippet.contract.ts

@@ -0,0 +1,53 @@
+import { type TextSnippetEntity, type TextSnippetSection } from '../base/entities';
+import {
+  type TextSnippetCreateResponseEntity,
+  type TextSnippetGetAllResponseEntity,
+  type TextSnippetGetByIdResponseEntity,
+  type TextSnippetUpdateResponseEntity,
+} from '../entities';
+import { type RpcPage } from './contract';
+
+/** Patrones NATS de `textSnippet` (biblioteca de vistos y cláusulas): `<servicio>.<recurso>.<acción>`. */
+export const TextSnippetPatterns = {
+  getAll: 'gestorDocumental.textSnippet.getAll',
+  getById: 'gestorDocumental.textSnippet.getById',
+  create: 'gestorDocumental.textSnippet.create',
+  update: 'gestorDocumental.textSnippet.update',
+  setEnabled: 'gestorDocumental.textSnippet.setEnabled',
+} as const;
+
+/** Datos de un texto de la biblioteca al crearlo o editarlo. */
+export interface TextSnippetWritePayload {
+  title: string;
+  text: string;
+  section: TextSnippetSection;
+  keywords?: string[];
+  enabled?: boolean;
+}
+
+export interface TextSnippetContract {
+  [TextSnippetPatterns.getAll]: {
+    // sin `page` y `limit` responde todas en una sola página
+    payload: {
+      pagination?: { page?: number; limit?: number };
+      filters?: { search?: string; enabled?: boolean; section?: TextSnippetSection };
+    };
+    response: RpcPage<TextSnippetGetAllResponseEntity[]>;
+  };
+  [TextSnippetPatterns.getById]: {
+    payload: Pick<TextSnippetEntity, 'id'>;
+    response: TextSnippetGetByIdResponseEntity;
+  };
+  [TextSnippetPatterns.create]: {
+    payload: TextSnippetWritePayload;
+    response: TextSnippetCreateResponseEntity;
+  };
+  [TextSnippetPatterns.update]: {
+    payload: TextSnippetWritePayload & Pick<TextSnippetEntity, 'id'>;
+    response: TextSnippetUpdateResponseEntity;
+  };
+  [TextSnippetPatterns.setEnabled]: {
+    payload: Pick<TextSnippetEntity, 'id' | 'enabled'>;
+    response: TextSnippetUpdateResponseEntity;
+  };
+}

package/src/contracts/transparency.contract.ts

@@ -0,0 +1,55 @@
+import {
+  type DocumentPublicFileResponseEntity,
+  type IndicatorsFileEntity,
+  type TransparencyItemEntity,
+  type TransparencyItemStatus,
+  type TransparencyMonthEntity,
+  type TransparencyPublicEntity,
+} from '../entities';
+
+/** Patrones NATS de `transparency`: Transparencia Activa de los documentos firmados (Ley 20.285, art. 7°). */
+export const TransparencyPatterns = {
+  getMonth: 'gestorDocumental.transparency.getMonth',
+  update: 'gestorDocumental.transparency.update',
+  export: 'gestorDocumental.transparency.export',
+  getRedactedFile: 'gestorDocumental.transparency.getRedactedFile',
+  getPublic: 'gestorDocumental.transparency.getPublic',
+  getPublicFile: 'gestorDocumental.transparency.getPublicFile',
+} as const;
+
+type TTransparencyActor = { employeeId: string; fullName: string };
+
+/** Lo que se decide sobre un documento en Transparencia Activa. */
+export type TransparencyUpdatePayload =
+  /** Publicarlo (o corregir el enlace): si el original no es público, exige antes la versión tarjada. */
+  | { action: 'publish'; documentId: string; url?: string | null; note?: string | null; actor: TTransparencyActor }
+  /** No se publica, con su motivo (p. ej. reservado por el art. 21 de la Ley 20.285). */
+  | { action: 'exclude'; documentId: string; reason: string; actor: TTransparencyActor }
+  /** Vuelve a pendiente: se retiró la publicación o se revisó la exclusión. */
+  | { action: 'withdraw'; documentId: string; reason: string; actor: TTransparencyActor }
+  /** Versión tarjada ya subida al gestor de archivos (PDF). */
+  | { action: 'setRedacted'; documentId: string; fileId: string; fileName: string; actor: TTransparencyActor }
+  | { action: 'removeRedacted'; documentId: string; actor: TTransparencyActor };
+
+export interface TransparencyContract {
+  /** Lo firmado en el mes (hora de Chile) de los tipos que se publican, y lo que ya se publicó aunque el tipo cambie. */
+  [TransparencyPatterns.getMonth]: {
+    payload: { year: number; month: number; status?: TransparencyItemStatus | null };
+    response: TransparencyMonthEntity;
+  };
+  [TransparencyPatterns.update]: { payload: TransparencyUpdatePayload; response: TransparencyItemEntity };
+  /** Planilla del mes (Excel) para cargar en el Portal de Transparencia. */
+  [TransparencyPatterns.export]: {
+    payload: { year: number; month: number; generatedBy: string };
+    response: IndicatorsFileEntity;
+  };
+  /** La versión tarjada cargada, para revisarla antes de publicar. */
+  [TransparencyPatterns.getRedactedFile]: {
+    payload: { documentId: string };
+    response: DocumentPublicFileResponseEntity;
+  };
+  /** Página pública de un documento publicado, por su código de verificación. No exige sesión. */
+  [TransparencyPatterns.getPublic]: { payload: { code: string }; response: TransparencyPublicEntity };
+  /** La versión publicada: la tarjada si existe; si no, el original público. Solo de un documento vigente. */
+  [TransparencyPatterns.getPublicFile]: { payload: { code: string }; response: DocumentPublicFileResponseEntity };
+}