@muni-sanfer/types-gestor-documental 0.0.1-beta.2 → 0.0.1-beta.21

package/src/contracts/archivalSeries.contract.ts

@@ -0,0 +1,53 @@
+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;
+}
+
+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/document.contract.ts

@@ -1,9 +1,11 @@
 import {
+  type DocumentAccessAction,
   type DocumentAccessLevel,
   type DocumentAttachmentEntity,
   type DocumentDeliveryEntity,
   type DocumentEntity,
   type DocumentInstruction,
+  type DocumentParticipantEntity,
   type DocumentStatus,
 } from '../base/entities';
 import {
@@ -12,12 +14,21 @@ import {
   type DocumentCreateResponseEntity,
   type DocumentDeriveResponseEntity,
   type DocumentDiscardResponseEntity,
+  type DocumentEmailCopyIssuedEntity,
+  type DocumentEmailCopyViewEntity,
+  type DocumentReminderEntity,
   type DocumentGetAllResponseEntity,
   type DocumentGetByIdResponseEntity,
   type DocumentGetSummaryResponseEntity,
   type DocumentInboxItemEntity,
   type DocumentPublicFileResponseEntity,
+  type DocumentReassignResponseEntity,
   type DocumentReviewResponseEntity,
+  type DocumentSignManyResponseEntity,
+  type DocumentAgendaResponseEntity,
+  type DocumentComposeResponseEntity,
+  type DocumentComposition,
+  type DocumentTrailExportEntity,
   type DocumentUpdateResponseEntity,
   type DocumentVerifyResponseEntity,
 } from '../entities';
@@ -32,6 +43,8 @@ export const DocumentPatterns = {
   create: 'gestorDocumental.document.create',
   update: 'gestorDocumental.document.update',
   review: 'gestorDocumental.document.review',
+  signMany: 'gestorDocumental.document.signMany',
+  reassign: 'gestorDocumental.document.reassign',
   discard: 'gestorDocumental.document.discard',
   annul: 'gestorDocumental.document.annul',
   derive: 'gestorDocumental.document.derive',
@@ -39,6 +52,13 @@ export const DocumentPatterns = {
   verify: 'gestorDocumental.document.verify',
   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;
 
 /**
@@ -90,6 +110,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;
@@ -99,14 +125,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 };
@@ -118,6 +201,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;
@@ -140,8 +231,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]: {
@@ -165,6 +257,36 @@ 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.
+   */
+  [DocumentPatterns.reassign]: {
+    payload: Pick<DocumentEntity, 'id'> & {
+      participantId: DocumentParticipantEntity['id'];
+      // Funcionario que toma el turno.
+      employeeId: string;
+      reason: string;
+      actor: DocumentActor;
+      anyDocument?: boolean;
+    };
+    response: DocumentReassignResponseEntity;
+  };
   [DocumentPatterns.discard]: {
     payload: Pick<DocumentEntity, 'id'> & { actor: DocumentActor };
     response: DocumentDiscardResponseEntity;
@@ -186,6 +308,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;
     };
@@ -206,6 +330,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/documentType.contract.ts

@@ -1,4 +1,4 @@
-import { type DocumentCategory, type DocumentTypeEntity } from '../base/entities';
+import { type DocumentCategory, type DocumentParticipantRole, type DocumentTypeEntity } from '../base/entities';
 import {
   type DocumentTypeCreateResponseEntity,
   type DocumentTypeGetAllResponseEntity,
@@ -16,6 +16,19 @@ export const DocumentTypePatterns = {
   setEnabled: 'gestorDocumental.documentType.setEnabled',
 } as const;
 
+/**
+ * Paso del flujo sugerido de un tipo documental: un funcionario en particular, o quien dirija una dirección al
+ * 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 = (
+  | { role: DocumentParticipantRole; type: 'Employee'; employeeId: 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 {
   name: string;
@@ -25,8 +38,18 @@ 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;
   directorateCodeReference?: number | 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[];
 }
 
 /**
@@ -37,7 +60,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/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 };
+}