@muni-sanfer/types-gestor-documental 0.0.1-beta.4 → 0.0.1-beta.41

package/src/contracts/document.contract.ts

@@ -1,4 +1,5 @@
 import {
+  type DocumentAccessAction,
   type DocumentAccessLevel,
   type DocumentAttachmentEntity,
   type DocumentDeliveryEntity,
@@ -13,6 +14,9 @@ import {
   type DocumentCreateResponseEntity,
   type DocumentDeriveResponseEntity,
   type DocumentDiscardResponseEntity,
+  type DocumentEmailCopyIssuedEntity,
+  type DocumentEmailCopyViewEntity,
+  type DocumentReminderEntity,
   type DocumentGetAllResponseEntity,
   type DocumentGetByIdResponseEntity,
   type DocumentGetSummaryResponseEntity,
@@ -20,8 +24,17 @@ import {
   type DocumentPublicFileResponseEntity,
   type DocumentReassignResponseEntity,
   type DocumentReviewResponseEntity,
+  type DocumentSignManyResponseEntity,
+  type DocumentAgendaResponseEntity,
+  type DocumentComposeResponseEntity,
+  type DocumentComposition,
+  type DocumentTrailExportEntity,
   type DocumentUpdateResponseEntity,
   type DocumentVerifyResponseEntity,
+  type DocumentCommentResponseEntity,
+  type DocumentCommentsResponseEntity,
+  type DocumentVersionResponseEntity,
+  type DocumentDraftReviewResponseEntity,
 } from '../entities';
 import { type RpcPage } from './contract';
 
@@ -34,14 +47,29 @@ export const DocumentPatterns = {
   create: 'gestorDocumental.document.create',
   update: 'gestorDocumental.document.update',
   review: 'gestorDocumental.document.review',
+  signMany: 'gestorDocumental.document.signMany',
   reassign: 'gestorDocumental.document.reassign',
+  requestDraftReview: 'gestorDocumental.document.requestDraftReview',
+  resolveDraftReview: 'gestorDocumental.document.resolveDraftReview',
   discard: 'gestorDocumental.document.discard',
   annul: 'gestorDocumental.document.annul',
   derive: 'gestorDocumental.document.derive',
   closeDelivery: 'gestorDocumental.document.closeDelivery',
   verify: 'gestorDocumental.document.verify',
+  getVersions: 'gestorDocumental.document.getVersions',
+  getVersionFile: 'gestorDocumental.document.getVersionFile',
+  getComments: 'gestorDocumental.document.getComments',
+  addComment: 'gestorDocumental.document.addComment',
+  resolveComment: 'gestorDocumental.document.resolveComment',
   getPublicFile: 'gestorDocumental.document.getPublicFile',
   getFilesFolder: 'gestorDocumental.document.getFilesFolder',
+  getAgenda: 'gestorDocumental.document.getAgenda',
+  exportTrail: 'gestorDocumental.document.exportTrail',
+  compose: 'gestorDocumental.document.compose',
+  issueEmailCopies: 'gestorDocumental.document.issueEmailCopies',
+  getEmailCopy: 'gestorDocumental.document.getEmailCopy',
+  getEmailCopyFile: 'gestorDocumental.document.getEmailCopyFile',
+  claimReminders: 'gestorDocumental.document.claimReminders',
 } as const;
 
 /**
@@ -52,6 +80,11 @@ export interface DocumentActor {
   employeeId: string;
   directorateCodes: number[];
   departmentIds: string[];
+  /**
+   * Jefaturas para las que revisa (revisora de jefatura): ve los documentos que les esperan. Lo resuelve el gateway
+   * solo donde hace falta (el detalle y el PDF).
+   */
+  reviewFor?: string[];
 }
 
 /** Bandeja desde la que se lista. Todas son del funcionario (`actor`), salvo `all`. */
@@ -61,6 +94,7 @@ export type DocumentBucket =
   | 'toVisa' // le toca visarlos
   | 'toSign' // le toca firmarlos
   | 'participated' // ya los visó, firmó o rechazó
+  | 'toReview' // borradores que le toca revisar como jefatura de la dirección revisora
   | 'all'; // todos los que están en tramitación o finalizados (historial)
 
 /**
@@ -84,6 +118,10 @@ export type DocumentReviewAction = 'Visa' | 'Sign' | 'Reject';
  */
 export interface DocumentWritePayload extends Pick<DocumentEntity, 'subject' | 'documentTypeId'> {
   keywords: string[];
+  /** Qué cambió, si el guardado crea una versión nueva (otro PDF, otro texto u otro asunto). */
+  versionNote?: string | null;
+  /** Al crearlo: solicitud de redacción que atiende (la tomó quien redacta). */
+  draftingRequestId?: string | null;
   accessLevel?: DocumentAccessLevel;
   hasSensitiveData?: boolean;
   directorateCodeReference?: number | null;
@@ -93,6 +131,12 @@ export interface DocumentWritePayload extends Pick<DocumentEntity, 'subject' | '
   attachments?: Pick<DocumentAttachmentEntity, 'name' | 'type' | 'fileId' | 'url'>[];
   // Funcionarios que visan y que firman, en el orden en que les toca. Primero visan todos y después firman.
   visaEmployeeIds: string[];
+  // Etapa de cada visador, en su orden ([1, 1, 2]: los dos primeros visan a la vez). Sin etapas, visan en cadena.
+  visaStages?: number[] | null;
+  // Al reenviar un documento rechazado, pedir de nuevo las visaciones ya hechas en vez de seguir donde quedó.
+  restartFlow?: boolean;
+  // Contenido redactado con una plantilla (el PDF ya armado va en `file`): se guarda para volver a editarlo.
+  composition?: DocumentComposition | null;
   signatureEmployeeIds: string[];
   // Firmas y visaciones en una hoja aparte al final, en vez de al pie de la última página.
   signatureSheet?: boolean;
@@ -102,14 +146,71 @@ export interface DocumentWritePayload extends Pick<DocumentEntity, 'subject' | '
   responseDueAt?: string | null;
   // Documento al que este responde.
   replyToDocumentId?: string | null;
+  // Instituciones (y usuarios) de DocDigital a quienes va: al terminar la firma pasa a Oficina de Partes.
+  externalRecipients?: DocumentExternalRecipientInput[];
+  // Fin de la restricción de acceso (ISO 8601), si no es público.
+  restrictionEndsAt?: string | null;
+  // Copia por correo a quienes están fuera del Estado: sale al finalizar o, si también va por DocDigital, al despacharlo.
+  emailCopies?: DocumentEmailCopyInput[];
   action?: 'Submit';
   actor: DocumentActor;
 }
 
+/** Persona u organización fuera del Estado que recibe una copia por correo. */
+export interface DocumentEmailCopyInput {
+  name: string;
+  email: string;
+}
+
+/** Destinatario externo: una institución de DocDigital y, si se indica, uno de sus usuarios. */
+export interface DocumentExternalRecipientInput {
+  entityId: number;
+  userId?: number | null;
+}
+
 /**
  * Qué se envía y qué se responde en cada patrón. Generado desde los handlers y los DTO del microservicio.
  */
+/** Una lectura que queda en el registro de accesos del documento. */
+export interface DocumentAccessInput {
+  action: DocumentAccessAction;
+  fullName: string;
+}
+
 export interface DocumentContract {
+  /**
+   * Arma el PDF de un documento redactado con una plantilla oficial: membrete, estructura y espacio libre para el
+   * número, las visaciones, las firmas y el QR. Con `preview` lo entrega para verlo; si no, lo sube y entrega su
+   * `fileId` para guardarlo como el PDF del documento.
+   */
+  [DocumentPatterns.compose]: {
+    payload: {
+      documentTypeId: string;
+      subject: string;
+      composition: DocumentComposition;
+      visaCount: number;
+      signatureCount: number;
+      signatureSheet?: boolean;
+      /** Unidad que emite, para el membrete. */
+      issuingUnitName?: string | null;
+      preview?: boolean;
+      actor: DocumentActor;
+    };
+    response: DocumentComposeResponseEntity;
+  };
+  /** Plazos del funcionario entre `from` y `to` (hasta 62 días), y lo que tiene vencido sin atender. */
+  [DocumentPatterns.getAgenda]: {
+    payload: { from: string; to: string; actor: DocumentActor };
+    response: DocumentAgendaResponseEntity;
+  };
+  /**
+   * Trazabilidad del documento en PDF: datos, flujo, hechos y huella de sus archivos. Con las mismas reglas de acceso
+   * del detalle. `generatedBy`: quién la descarga (va al pie).
+   */
+  [DocumentPatterns.exportTrail]: {
+    payload: Pick<DocumentEntity, 'id'> & { actor?: DocumentActor; viewAll?: boolean; generatedBy: string };
+    response: DocumentTrailExportEntity;
+  };
   [DocumentPatterns.getAll]: {
     payload: {
       pagination?: { page?: number; limit?: number };
@@ -121,6 +222,14 @@ export interface DocumentContract {
         // Rango de fechas de creación (ISO 8601).
         dateFrom?: string;
         dateTo?: string;
+        // Búsqueda avanzada: número (del documento o folio de ingreso) y año, firmante, redactor y unidad emisora.
+        number?: number;
+        year?: number;
+        signerEmployeeId?: string;
+        authorEmployeeId?: string;
+        directorateCodeReference?: number;
+        // Texto completo, en el asunto y en el contenido del PDF.
+        text?: string;
       };
       // Obligatorio en todas las bandejas salvo `all`.
       actor?: DocumentActor;
@@ -143,8 +252,9 @@ export interface DocumentContract {
   [DocumentPatterns.getById]: {
     // Con `actor`, el documento solo se entrega a su redactor y a quienes lo visan o firman, y la respuesta dice qué
     // puede hacer con él. `viewAll` levanta esa restricción para quien tiene permiso de ver todos los documentos
-    // (historial), sin perder lo que puede hacer si además participa.
-    payload: Pick<DocumentEntity, 'id'> & { actor?: DocumentActor; viewAll?: boolean };
+    // (historial), sin perder lo que puede hacer si además participa. Con `access`, la lectura queda en el registro de
+    // accesos del documento a nombre de `fullName` (abrirlo varias veces seguidas cuenta una vez).
+    payload: Pick<DocumentEntity, 'id'> & { actor?: DocumentActor; viewAll?: boolean; access?: DocumentAccessInput };
     response: DocumentGetByIdResponseEntity;
   };
   [DocumentPatterns.create]: {
@@ -168,10 +278,42 @@ export interface DocumentContract {
     };
     response: DocumentReviewResponseEntity;
   };
+  /**
+   * Firma con un solo OTP varios documentos que el funcionario tiene en su turno de firma (los de un lote, o los que
+   * marcó en su bandeja). Cada uno queda firmado aparte; los que no caben en la solicitud quedan en `remaining`.
+   */
+  [DocumentPatterns.signMany]: {
+    payload: {
+      ids: DocumentEntity['id'][];
+      observation?: string | null;
+      // Datos de quien firma, para el sello de la firma (los resuelve el gateway desde la sesión).
+      signer: { rut: string; fullName: string; role: string; areaName: string };
+      otp?: string;
+      actor: DocumentActor;
+    };
+    response: DocumentSignManyResponseEntity;
+  };
   /**
    * Pasa un turno pendiente (de visación o de firma) a otro funcionario, por ausencia o por error, y lo deja en la
    * trazabilidad con su motivo. Puede hacerlo quien redactó el documento; con `anyDocument`, quien lleva el registro.
    */
+  /** El redactor pide la revisión del borrador; el gateway resuelve quién dirige hoy la dirección revisora. */
+  [DocumentPatterns.requestDraftReview]: {
+    payload: Pick<DocumentEntity, 'id'> & {
+      reviewer: { employeeId: string; fullName: string };
+      actor: DocumentActor;
+    };
+    response: DocumentDraftReviewResponseEntity;
+  };
+  /** La jefatura revisora aprueba o devuelve (con observaciones); el redactor puede retirar la solicitud. */
+  [DocumentPatterns.resolveDraftReview]: {
+    payload: Pick<DocumentEntity, 'id'> & {
+      decision: 'Approve' | 'Reject' | 'Cancel';
+      observation?: string | null;
+      actor: DocumentActor;
+    };
+    response: DocumentDraftReviewResponseEntity;
+  };
   [DocumentPatterns.reassign]: {
     payload: Pick<DocumentEntity, 'id'> & {
       participantId: DocumentParticipantEntity['id'];
@@ -204,6 +346,8 @@ export interface DocumentContract {
       note?: string | null;
       // Plazo para atenderlo (ISO 8601).
       dueAt?: string | null;
+      // O el plazo en días hábiles (Ley 19.880): el servicio calcula la fecha con los feriados cargados.
+      dueBusinessDays?: number | null;
       actor: DocumentActor;
       viewAll?: boolean;
     };
@@ -214,6 +358,37 @@ export interface DocumentContract {
     payload: { deliveryId: DocumentDeliveryEntity['id']; note?: string | null; actor: DocumentActor };
     response: DocumentCloseDeliveryResponseEntity;
   };
+  /** Versiones del documento, de la más reciente a la primera, con quién visó o firmó cada una. */
+  [DocumentPatterns.getVersions]: {
+    payload: { id: string; actor?: DocumentActor; viewAll?: boolean };
+    response: DocumentVersionResponseEntity[];
+  };
+  /** El PDF original de una versión (sin estampar), con las mismas reglas de acceso. */
+  [DocumentPatterns.getVersionFile]: {
+    payload: { id: string; number: number; actor?: DocumentActor; viewAll?: boolean };
+    response: DocumentPublicFileResponseEntity;
+  };
+  /** Comentarios de redacción: los ven el redactor y quienes tienen un turno (y quien ve todo el historial). */
+  [DocumentPatterns.getComments]: {
+    payload: { id: string; actor?: DocumentActor; viewAll?: boolean };
+    response: DocumentCommentsResponseEntity;
+  };
+  /** Comenta el redactor o quien tiene un turno, mientras el documento no termina, sobre la versión vigente. */
+  [DocumentPatterns.addComment]: {
+    payload: {
+      id: string;
+      section?: string | null;
+      quote?: string | null;
+      text: string;
+      actor: DocumentActor & { fullName: string };
+    };
+    response: DocumentCommentResponseEntity;
+  };
+  /** Lo marca como resuelto el redactor o quien lo escribió, con una nota opcional. */
+  [DocumentPatterns.resolveComment]: {
+    payload: { commentId: string; note?: string | null; actor: DocumentActor & { fullName: string } };
+    response: DocumentCommentResponseEntity;
+  };
   /** Comprobación pública de un documento con el código que lleva impreso. No exige sesión. */
   [DocumentPatterns.verify]: {
     payload: { code: string };
@@ -224,6 +399,31 @@ export interface DocumentContract {
     payload: { code: string };
     response: DocumentPublicFileResponseEntity;
   };
+  /**
+   * Emite las copias por correo pendientes de estos documentos, si ya corresponde (finalizado y, si va por DocDigital,
+   * despachado): genera el enlace de cada una. Se puede pedir de más: lo ya emitido no se repite.
+   */
+  [DocumentPatterns.issueEmailCopies]: {
+    payload: { documentIds: string[] };
+    response: DocumentEmailCopyIssuedEntity[];
+  };
+  /** Sin sesión, con el token de la copia: el documento y quién lo emitió. */
+  [DocumentPatterns.getEmailCopy]: {
+    payload: { token: string };
+    response: DocumentEmailCopyViewEntity;
+  };
+  /**
+   * Recordatorios de plazos que corresponde enviar ahora: lo que vence en un día hábil y lo vencido sin atender. Cada
+   * uno se entrega una sola vez (queda marcado al reclamarlo), aunque lo pidan varias instancias del gateway a la vez.
+   */
+  [DocumentPatterns.claimReminders]: {
+    payload: Record<string, never>;
+    response: DocumentReminderEntity[];
+  };
+  [DocumentPatterns.getEmailCopyFile]: {
+    payload: { token: string };
+    response: DocumentPublicFileResponseEntity;
+  };
   /** Carpeta de Drive de los documentos y sus anexos: el gateway la pide antes de subir cada archivo. */
   [DocumentPatterns.getFilesFolder]: {
     payload: Record<string, never>;

package/src/contracts/documentTemplate.contract.ts

@@ -0,0 +1,61 @@
+import { type DocumentTemplateEntity } from '../base/entities';
+import {
+  type DocumentTemplateAvailableResponseEntity,
+  type DocumentTemplateContent,
+  type DocumentTemplateCreateResponseEntity,
+  type DocumentTemplateGetAllResponseEntity,
+  type DocumentTemplateGetByIdResponseEntity,
+  type DocumentTemplateUpdateResponseEntity,
+} from '../entities';
+import { type RpcPage } from './contract';
+
+/** Patrones NATS de `documentTemplate` (plantillas propias del editor): `<servicio>.<recurso>.<acción>`. */
+export const DocumentTemplatePatterns = {
+  getAll: 'gestorDocumental.documentTemplate.getAll',
+  getById: 'gestorDocumental.documentTemplate.getById',
+  create: 'gestorDocumental.documentTemplate.create',
+  update: 'gestorDocumental.documentTemplate.update',
+  setEnabled: 'gestorDocumental.documentTemplate.setEnabled',
+  getAvailable: 'gestorDocumental.documentTemplate.getAvailable',
+} as const;
+
+/** Datos de una plantilla propia al crearla o editarla. */
+export interface DocumentTemplateWritePayload {
+  name: string;
+  description?: string | null;
+  documentTypeIds?: string[];
+  content: DocumentTemplateContent;
+  enabled?: boolean;
+}
+
+export interface DocumentTemplateContract {
+  [DocumentTemplatePatterns.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<DocumentTemplateGetAllResponseEntity[]>;
+  };
+  [DocumentTemplatePatterns.getById]: {
+    payload: Pick<DocumentTemplateEntity, 'id'>;
+    response: DocumentTemplateGetByIdResponseEntity;
+  };
+  [DocumentTemplatePatterns.create]: {
+    payload: DocumentTemplateWritePayload;
+    response: DocumentTemplateCreateResponseEntity;
+  };
+  [DocumentTemplatePatterns.update]: {
+    payload: DocumentTemplateWritePayload & Pick<DocumentTemplateEntity, 'id'>;
+    response: DocumentTemplateUpdateResponseEntity;
+  };
+  [DocumentTemplatePatterns.setEnabled]: {
+    payload: Pick<DocumentTemplateEntity, 'id' | 'enabled'>;
+    response: DocumentTemplateUpdateResponseEntity;
+  };
+  /** Las habilitadas que se ofrecen al redactar un documento del tipo (las de todos los tipos y las suyas). */
+  [DocumentTemplatePatterns.getAvailable]: {
+    payload: { documentTypeId: string };
+    response: DocumentTemplateAvailableResponseEntity[];
+  };
+}

package/src/contracts/documentType.contract.ts

@@ -21,9 +21,13 @@ export const DocumentTypePatterns = {
  * momento de redactar (su jefatura o, con subrogancia activa, el subrogante). El nombre de la dirección lo resuelve
  * el gateway; el navegador solo indica cuál es.
  */
-export type DocumentFlowStepInput =
+export type DocumentFlowStepInput = (
   | { role: DocumentParticipantRole; type: 'Employee'; employeeId: string }
-  | { role: DocumentParticipantRole; type: 'DirectorateHead'; directorateCodeReference: number; name: string };
+  | { role: DocumentParticipantRole; type: 'DirectorateHead'; directorateCodeReference: number; name: string }
+) & {
+  // Visa a la vez con el paso anterior (visación en paralelo). Solo en visaciones.
+  withPrevious?: boolean;
+};
 
 /** Datos de un tipo documental al crearlo o editarlo. */
 export interface DocumentTypeWritePayload {
@@ -34,7 +38,22 @@ export interface DocumentTypeWritePayload {
   // Próximo número que se asignará: permite partir desde el correlativo que la municipalidad ya lleva.
   nextCorrelative?: number;
   resetsYearly?: boolean;
+  // Sus documentos llevan número (por omisión, sí).
+  numbered?: boolean;
+  /** Transparencia Activa: sus documentos se publican cada mes, en esta sección del Portal. */
+  activeTransparency?: boolean;
+  transparencySection?: string | null;
   directorateCodeReference?: number | null;
+  // Dirección cuya jefatura revisa los borradores antes de enviarlos (sin valor: sin revisión). El nombre lo pone el
+  // gateway desde caschile-ms.
+  draftReviewDirectorateCode?: number | null;
+  draftReviewDirectorateName?: string | null;
+  // Serie documental del Cuadro de Clasificación (sin valor: sin clasificar).
+  archivalSeriesId?: string | null;
+  // Entidad emisora (sin valor: la municipalidad).
+  issuingEntityId?: string | null;
+  // Tipo cuyo correlativo comparte (sin valor: el suyo propio).
+  sharesNumberingWithId?: string | null;
   enabled?: boolean;
   // Flujo sugerido, en el orden en que les toca dentro de cada rol. Al editar, si no viene, el flujo no cambia.
   flowSteps?: DocumentFlowStepInput[];
@@ -48,7 +67,14 @@ export interface DocumentTypeContract {
     // sin `page` y `limit` responde todos los tipos en una sola página
     payload: {
       pagination?: { page?: number; limit?: number };
-      filters?: { search?: string; enabled?: boolean; category?: DocumentCategory };
+      filters?: {
+        search?: string;
+        enabled?: boolean;
+        category?: DocumentCategory;
+        // Solo los que puede usar quien redacta: los de toda la municipalidad y los de estas direcciones (o de una
+        // entidad emisora por la que actúan).
+        usableByDirectorates?: number[];
+      };
     };
     response: RpcPage<DocumentTypeGetAllResponseEntity[]>;
   };

package/src/contracts/draftingRequest.contract.ts

@@ -0,0 +1,73 @@
+import { type DraftingRequestDetailEntity, type DraftingRequestListItemEntity } from '../entities';
+import { type RpcPage } from './contract';
+
+/** Patrones NATS de `draftingRequest`: solicitudes de redacción entre áreas. */
+export const DraftingRequestPatterns = {
+  getAll: 'gestorDocumental.draftingRequest.getAll',
+  getById: 'gestorDocumental.draftingRequest.getById',
+  create: 'gestorDocumental.draftingRequest.create',
+  act: 'gestorDocumental.draftingRequest.act',
+  getAttachmentFile: 'gestorDocumental.draftingRequest.getAttachmentFile',
+} as const;
+
+/** Quien consulta o actúa: el funcionario de la sesión, con su nombre. */
+export interface DraftingRequestActor {
+  employeeId: string;
+  fullName: string;
+}
+
+/**
+ * Bandeja: las que le llegaron a su dirección, las que tomó o las que pidió. `state`: abiertas (sin tomar, tomadas o
+ * en redacción), cerradas (atendidas, devueltas o retiradas) o todas.
+ */
+export type DraftingRequestBox = 'received' | 'taken' | 'sent';
+
+export interface DraftingRequestCreatePayload {
+  subject: string;
+  details: string;
+  documentTypeId?: string | null;
+  dueAt?: string | null;
+  attachments?: { fileId: string; name: string }[];
+  /** Dirección a la que se pide, con el nombre que le pone el gateway. */
+  targetDirectorateCode: number;
+  targetDirectorateName: string;
+  /** Quienes la integran hoy, resueltos por el gateway (sin quien la pide). */
+  recipientEmployeeIds: string[];
+  requesterAreaName?: string | null;
+  actor: DraftingRequestActor;
+}
+
+/** Lo que se hace con una solicitud, un paso a la vez. */
+export type DraftingRequestAction =
+  | { type: 'take' }
+  | { type: 'release'; note?: string | null }
+  | { type: 'decline'; note: string }
+  | { type: 'cancel'; note?: string | null };
+
+export interface DraftingRequestContract {
+  [DraftingRequestPatterns.getAll]: {
+    payload: {
+      box: DraftingRequestBox;
+      state?: 'open' | 'closed' | 'all';
+      search?: string;
+      page?: number;
+      limit?: number;
+      actor: Pick<DraftingRequestActor, 'employeeId'>;
+    };
+    response: RpcPage<DraftingRequestListItemEntity[]>;
+  };
+  [DraftingRequestPatterns.getById]: {
+    payload: { id: string; actor: Pick<DraftingRequestActor, 'employeeId'> };
+    response: DraftingRequestDetailEntity;
+  };
+  [DraftingRequestPatterns.create]: { payload: DraftingRequestCreatePayload; response: DraftingRequestDetailEntity };
+  [DraftingRequestPatterns.act]: {
+    payload: { id: string; action: DraftingRequestAction; actor: DraftingRequestActor };
+    response: DraftingRequestDetailEntity;
+  };
+  /** Archivo adjunto, con las mismas reglas de acceso del detalle. */
+  [DraftingRequestPatterns.getAttachmentFile]: {
+    payload: { id: string; attachmentId: string; actor: Pick<DraftingRequestActor, 'employeeId'> };
+    response: { fileId: string; fileName: string };
+  };
+}

package/src/contracts/holiday.contract.ts

@@ -0,0 +1,16 @@
+import { type HolidayRemoveResponseEntity, type HolidayResponseEntity } from '../entities';
+
+/** Patrones NATS de `holiday`: feriados para contar días hábiles. */
+export const HolidayPatterns = {
+  getAll: 'gestorDocumental.holiday.getAll',
+  create: 'gestorDocumental.holiday.create',
+  remove: 'gestorDocumental.holiday.remove',
+} as const;
+
+export interface HolidayContract {
+  /** Feriados de un año, en orden. */
+  [HolidayPatterns.getAll]: { payload: { year: number }; response: HolidayResponseEntity[] };
+  /** `date` como «AAAA-MM-DD». */
+  [HolidayPatterns.create]: { payload: { date: string; name: string }; response: HolidayResponseEntity };
+  [HolidayPatterns.remove]: { payload: { id: string }; response: HolidayRemoveResponseEntity };
+}

package/src/contracts/index.ts

@@ -1,21 +1,116 @@
 import { CaseFilePatterns, type CaseFileContract } from './caseFile.contract';
 import { DocumentPatterns, type DocumentContract } from './document.contract';
 import { DocumentTypePatterns, type DocumentTypeContract } from './documentType.contract';
+import { IssuingEntityPatterns, type IssuingEntityContract } from './issuingEntity.contract';
+import { ArchivalSeriesPatterns, type ArchivalSeriesContract } from './archivalSeries.contract';
+import { TextSnippetPatterns, type TextSnippetContract } from './textSnippet.contract';
+import { DocumentTemplatePatterns, type DocumentTemplateContract } from './documentTemplate.contract';
+import { HolidayPatterns, type HolidayContract } from './holiday.contract';
+import { IndicatorsPatterns, type IndicatorsContract } from './indicators.contract';
+import { AuditPatterns, type AuditContract } from './audit.contract';
+import { SignatureCheckPatterns, type SignatureCheckContract } from './signatureCheck.contract';
+import { RepositoryExportPatterns, type RepositoryExportContract } from './repositoryExport.contract';
+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 { DeskPatterns, type DeskContract } from './desk.contract';
+import { MailIntakePatterns, type MailIntakeContract } from './mailIntake.contract';
+import { PushPatterns, type PushContract } from './push.contract';
+import { ScanPatterns, type ScanContract } from './scan.contract';
+import { PartsOfficePatterns, type PartsOfficeContract } from './partsOffice.contract';
 import { ProcedurePatterns, type ProcedureContract } from './procedure.contract';
+import { RegisterBookPatterns, type RegisterBookContract } from './registerBook.contract';
+import { SignatureBatchPatterns, type SignatureBatchContract } from './signatureBatch.contract';
+import { WorkFolderPatterns, type WorkFolderContract } from './workFolder.contract';
+import { DraftingRequestPatterns, type DraftingRequestContract } from './draftingRequest.contract';
+import { InternalReviewPatterns, type InternalReviewContract } from './internalReview.contract';
 
 export * from './contract';
 export * from './document.contract';
 export * from './documentType.contract';
 export * from './procedure.contract';
+export * from './issuingEntity.contract';
 export * from './caseFile.contract';
+export * from './partsOffice.contract';
+export * from './registerBook.contract';
+export * from './signatureBatch.contract';
+export * from './workFolder.contract';
+export * from './scan.contract';
+export * from './archivalSeries.contract';
+export * from './textSnippet.contract';
+export * from './documentTemplate.contract';
+export * from './holiday.contract';
+export * from './indicators.contract';
+export * from './audit.contract';
+export * from './signatureCheck.contract';
+export * from './repositoryExport.contract';
+export * from './retention.contract';
+export * from './accessRequest.contract';
+export * from './transparency.contract';
+export * from './dataProtection.contract';
+export * from './desk.contract';
+export * from './mailIntake.contract';
+export * from './push.contract';
+export * from './draftingRequest.contract';
+export * from './internalReview.contract';
 
 /** Patrones NATS de gestor-documental-ms, por recurso: `gestorDocumental.<recurso>.<acción>`. */
 export const GestorDocumentalPatterns = {
   documentType: DocumentTypePatterns,
   document: DocumentPatterns,
   procedure: ProcedurePatterns,
+  issuingEntity: IssuingEntityPatterns,
   caseFile: CaseFilePatterns,
+  partsOffice: PartsOfficePatterns,
+  registerBook: RegisterBookPatterns,
+  signatureBatch: SignatureBatchPatterns,
+  workFolder: WorkFolderPatterns,
+  scan: ScanPatterns,
+  archivalSeries: ArchivalSeriesPatterns,
+  textSnippet: TextSnippetPatterns,
+  documentTemplate: DocumentTemplatePatterns,
+  holiday: HolidayPatterns,
+  indicators: IndicatorsPatterns,
+  audit: AuditPatterns,
+  signatureCheck: SignatureCheckPatterns,
+  repositoryExport: RepositoryExportPatterns,
+  retention: RetentionPatterns,
+  accessRequest: AccessRequestPatterns,
+  transparency: TransparencyPatterns,
+  dataProtection: DataProtectionPatterns,
+  desk: DeskPatterns,
+  mailIntake: MailIntakePatterns,
+  push: PushPatterns,
+  draftingRequest: DraftingRequestPatterns,
+  internalReview: InternalReviewPatterns,
 } as const;
 
 /** Contrato completo de gestor-documental-ms: la unión de los contratos de sus recursos. */
-export type GestorDocumentalContract = DocumentTypeContract & DocumentContract & ProcedureContract & CaseFileContract;
+export type GestorDocumentalContract = DocumentTypeContract &
+  DocumentContract &
+  ProcedureContract &
+  IssuingEntityContract &
+  CaseFileContract &
+  PartsOfficeContract &
+  RegisterBookContract &
+  SignatureBatchContract &
+  WorkFolderContract &
+  ScanContract &
+  ArchivalSeriesContract &
+  TextSnippetContract &
+  DocumentTemplateContract &
+  HolidayContract &
+  IndicatorsContract &
+  AuditContract &
+  SignatureCheckContract &
+  RepositoryExportContract &
+  RetentionContract &
+  AccessRequestContract &
+  TransparencyContract &
+  DataProtectionContract &
+  DeskContract &
+  MailIntakeContract &
+  PushContract &
+  DraftingRequestContract &
+  InternalReviewContract;