@muni-sanfer/types-gestor-documental 0.0.1-beta.1 → 0.0.1-beta.11

package/src/contracts/workFolder.contract.ts

@@ -0,0 +1,75 @@
+import {
+  type WorkFolderConvertInput,
+  type WorkFolderConvertResponseEntity,
+  type WorkFolderGetAllResponseEntity,
+  type WorkFolderGetByIdResponseEntity,
+  type WorkFolderWriteResponseEntity,
+} from '../entities';
+import { type RpcPage } from './contract';
+import { type DocumentActor } from './document.contract';
+
+/** Patrones NATS de `workFolder` (carpetas de trabajo): `<servicio>.<recurso>.<acción>`. */
+export const WorkFolderPatterns = {
+  getAll: 'gestorDocumental.workFolder.getAll',
+  getById: 'gestorDocumental.workFolder.getById',
+  create: 'gestorDocumental.workFolder.create',
+  update: 'gestorDocumental.workFolder.update',
+  share: 'gestorDocumental.workFolder.share',
+  unshare: 'gestorDocumental.workFolder.unshare',
+  addItem: 'gestorDocumental.workFolder.addItem',
+  removeItem: 'gestorDocumental.workFolder.removeItem',
+  remove: 'gestorDocumental.workFolder.remove',
+  convert: 'gestorDocumental.workFolder.convert',
+} as const;
+
+/** Lo que se agrega a una carpeta: un documento finalizado del gestor o un archivo ya subido. */
+export type WorkFolderItemInput =
+  { kind: 'Document'; documentId: string } | { kind: 'File'; fileId: string; fileName: string; title: string };
+
+type TActor = { actor: DocumentActor };
+
+/**
+ * Carpetas de trabajo: agrupan y comparten documentos y archivos sin procedimiento asociado. Las ven su responsable y
+ * aquellos con quienes la compartió.
+ */
+export interface WorkFolderContract {
+  [WorkFolderPatterns.getAll]: {
+    payload: { pagination?: { page?: number; limit?: number }; filters?: { search?: string } } & TActor;
+    response: RpcPage<WorkFolderGetAllResponseEntity[]>;
+  };
+  [WorkFolderPatterns.getById]: { payload: { id: string } & TActor; response: WorkFolderGetByIdResponseEntity };
+  [WorkFolderPatterns.create]: {
+    payload: { name: string; description?: string | null } & TActor;
+    response: WorkFolderWriteResponseEntity;
+  };
+  [WorkFolderPatterns.update]: {
+    payload: { id: string; name: string; description?: string | null } & TActor;
+    response: WorkFolderWriteResponseEntity;
+  };
+  [WorkFolderPatterns.share]: {
+    payload: { id: string; employeeIds: string[] } & TActor;
+    response: WorkFolderWriteResponseEntity;
+  };
+  [WorkFolderPatterns.unshare]: {
+    payload: { id: string; participantId: string } & TActor;
+    response: WorkFolderWriteResponseEntity;
+  };
+  [WorkFolderPatterns.addItem]: {
+    payload: { id: string; item: WorkFolderItemInput } & TActor;
+    response: WorkFolderWriteResponseEntity;
+  };
+  [WorkFolderPatterns.removeItem]: {
+    payload: { id: string; itemId: string } & TActor;
+    response: WorkFolderWriteResponseEntity;
+  };
+  /** La carpeta deja de verse. Lo que contiene no se toca: los documentos siguen en el gestor. */
+  [WorkFolderPatterns.remove]: { payload: { id: string } & TActor; response: WorkFolderWriteResponseEntity };
+  /**
+   * La convierte en expediente: lo crea con estos metadatos, lo comparte con los mismos funcionarios e incorpora sus
+   * ítems al índice en el orden en que se agregaron. Desde ahí la carpeta queda solo de consulta.
+   */
+  [WorkFolderPatterns.convert]: {
+    payload: { id: string } & WorkFolderConvertInput & TActor;
+    response: WorkFolderConvertResponseEntity;
+  };
+}

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

@@ -0,0 +1,204 @@
+import {
+  CaseFileAccessEntity,
+  CaseFileActorEntity,
+  CaseFileEntity,
+  CaseFileEntryEntity,
+  CaseFileMetadataChangeEntity,
+  CaseFileParticipantEntity,
+  CaseFileTrackingEntity,
+  DocumentEntity,
+  ProcedureEntity,
+} from '../../base/entities';
+import { DocumentTypeSummaryEntity } from '../document';
+
+/** Expediente al que se hace referencia desde otro lado: cómo se cita y en qué estado está. */
+export interface CaseFileLinkEntity {
+  id: CaseFileEntity['id'];
+  code: CaseFileEntity['code'];
+  title: CaseFileEntity['title'];
+  status: CaseFileEntity['status'];
+}
+
+export interface CaseFileGetAllResponseEntity extends CaseFileLinkEntity {
+  subject: CaseFileEntity['subject'];
+  accessLevel: CaseFileEntity['accessLevel'];
+  hasSensitiveData: CaseFileEntity['hasSensitiveData'];
+  procedure: Pick<ProcedureEntity, 'id' | 'name'>;
+  responsibleEmployeeId: CaseFileEntity['responsibleEmployeeId'];
+  responsibleFullName: CaseFileEntity['responsibleFullName'];
+  /** Actuaciones vigentes del índice (las que quedaron sin efecto no cuentan). */
+  entries: number;
+  participants: number;
+  createdAt: CaseFileEntity['createdAt'];
+  closedAt: CaseFileEntity['closedAt'];
+}
+
+/** Documento del gestor incorporado al expediente. */
+export interface CaseFileEntryDocumentEntity {
+  id: DocumentEntity['id'];
+  subject: DocumentEntity['subject'];
+  status: DocumentEntity['status'];
+  correlative: DocumentEntity['correlative'];
+  correlativeYear: DocumentEntity['correlativeYear'];
+  documentType: DocumentTypeSummaryEntity;
+}
+
+/** Entrada del índice electrónico: una actuación, en su orden de incorporación. */
+export interface CaseFileEntryResponseEntity {
+  id: CaseFileEntryEntity['id'];
+  sequence: CaseFileEntryEntity['sequence'];
+  kind: CaseFileEntryEntity['kind'];
+  actuationType: CaseFileEntryEntity['actuationType'];
+  title: CaseFileEntryEntity['title'];
+  document: CaseFileEntryDocumentEntity | null;
+  fileName: CaseFileEntryEntity['fileName'];
+  documentTypeName: CaseFileEntryEntity['documentTypeName'];
+  originDate: CaseFileEntryEntity['originDate'];
+  author: CaseFileEntryEntity['author'];
+  keywords: CaseFileEntryEntity['keywords'];
+  accessLevel: CaseFileEntryEntity['accessLevel'];
+  hasSensitiveData: CaseFileEntryEntity['hasSensitiveData'];
+  linkedCaseFile: CaseFileLinkEntity | null;
+  /** `true` si la entrada tiene un archivo que se puede abrir (un documento o un archivo subido). */
+  hasFile: boolean;
+  sha256: CaseFileEntryEntity['sha256'];
+  size: CaseFileEntryEntity['size'];
+  hasAdvancedSignature: CaseFileEntryEntity['hasAdvancedSignature'];
+  incorporatedByEmployeeId: CaseFileEntryEntity['incorporatedByEmployeeId'];
+  incorporatedByFullName: CaseFileEntryEntity['incorporatedByFullName'];
+  createdAt: CaseFileEntryEntity['createdAt'];
+  voidedAt: CaseFileEntryEntity['voidedAt'];
+  voidedByFullName: CaseFileEntryEntity['voidedByFullName'];
+  voidReason: CaseFileEntryEntity['voidReason'];
+  /** `true` si quien consulta puede dejarla sin efecto: el responsable o quien la incorporó, con el expediente abierto. */
+  canVoid: boolean;
+}
+
+export interface CaseFileParticipantResponseEntity {
+  id: CaseFileParticipantEntity['id'];
+  employeeId: CaseFileParticipantEntity['employeeId'];
+  fullName: CaseFileParticipantEntity['fullName'];
+  position: CaseFileParticipantEntity['position'];
+  addedByFullName: CaseFileParticipantEntity['addedByFullName'];
+  createdAt: CaseFileParticipantEntity['createdAt'];
+}
+
+export interface CaseFileActorResponseEntity {
+  id: CaseFileActorEntity['id'];
+  relation: CaseFileActorEntity['relation'];
+  actorType: CaseFileActorEntity['actorType'];
+  identifier: CaseFileActorEntity['identifier'];
+  name: CaseFileActorEntity['name'];
+}
+
+export interface CaseFileTrackingResponseEntity {
+  id: CaseFileTrackingEntity['id'];
+  action: CaseFileTrackingEntity['action'];
+  observation: CaseFileTrackingEntity['observation'];
+  employeeFullName: CaseFileTrackingEntity['employeeFullName'];
+  createdAt: CaseFileTrackingEntity['createdAt'];
+}
+
+export interface CaseFileMetadataChangeResponseEntity {
+  id: CaseFileMetadataChangeEntity['id'];
+  /** Código oficial del metadato. Ej: `MGDEE1_5`. */
+  field: CaseFileMetadataChangeEntity['field'];
+  previousValue: CaseFileMetadataChangeEntity['previousValue'];
+  newValue: CaseFileMetadataChangeEntity['newValue'];
+  employeeFullName: CaseFileMetadataChangeEntity['employeeFullName'];
+  createdAt: CaseFileMetadataChangeEntity['createdAt'];
+}
+
+export interface CaseFileAccessResponseEntity {
+  id: CaseFileAccessEntity['id'];
+  action: CaseFileAccessEntity['action'];
+  entryId: CaseFileAccessEntity['entryId'];
+  /** Título del documento que se abrió, si el acceso fue a uno. */
+  entryTitle: string | null;
+  employeeFullName: CaseFileAccessEntity['employeeFullName'];
+  createdAt: CaseFileAccessEntity['createdAt'];
+}
+
+export interface CaseFileGetByIdResponseEntity extends CaseFileGetAllResponseEntity {
+  summary: CaseFileEntity['summary'];
+  procedure: Pick<ProcedureEntity, 'id' | 'name' | 'cpatId' | 'cpatCode'>;
+  responsiblePosition: CaseFileEntity['responsiblePosition'];
+  incorporationMechanism: CaseFileEntity['incorporationMechanism'];
+  schemaVersion: CaseFileEntity['schemaVersion'];
+  /** Enlace persistente del expediente (MGDEE4_2). `null` si el servicio no tiene configurada la dirección. */
+  uri: string | null;
+  closedByFullName: CaseFileEntity['closedByFullName'];
+  closingNote: CaseFileEntity['closingNote'];
+  index: CaseFileEntryResponseEntity[];
+  sharedWith: CaseFileParticipantResponseEntity[];
+  actors: CaseFileActorResponseEntity[];
+  trackings: CaseFileTrackingResponseEntity[];
+  metadataChanges: CaseFileMetadataChangeResponseEntity[];
+  /** Registro de accesos. Solo lo recibe el responsable y quien puede ver todos los expedientes. */
+  accesses: CaseFileAccessResponseEntity[];
+  /** Qué puede hacer con el expediente quien lo consulta. Sin `actor` en la consulta, no viene. */
+  actorCapabilities?: {
+    isResponsible: boolean;
+    /** Editar sus metadatos y cerrarlo: el responsable, mientras esté abierto. */
+    canEdit: boolean;
+    /** Incorporar actuaciones: el responsable y aquellos con quienes se compartió, mientras esté abierto. */
+    canIncorporate: boolean;
+    /** Compartirlo con otros funcionarios: el responsable, también después de cerrado. */
+    canShare: boolean;
+  };
+}
+
+export interface CaseFileCreateResponseEntity {
+  id: CaseFileEntity['id'];
+  code: CaseFileEntity['code'];
+  ok: boolean;
+}
+
+export interface CaseFileUpdateResponseEntity {
+  id: CaseFileEntity['id'];
+  ok: boolean;
+}
+
+/** Lote incorporado: cuántos documentos entraron y cuántos se omitieron (ya estaban, o no finalizados). */
+export interface CaseFileAddBatchResponseEntity {
+  id: CaseFileEntity['id'];
+  added: number;
+  skipped: number;
+  ok: boolean;
+}
+
+export interface CaseFileAddEntryResponseEntity {
+  id: CaseFileEntity['id'];
+  entryId: CaseFileEntryEntity['id'];
+  sequence: CaseFileEntryEntity['sequence'];
+  ok: boolean;
+}
+
+/** Archivo de una entrada del índice, para servirlo a quien puede ver el expediente. */
+export interface CaseFileEntryFileResponseEntity {
+  fileId: string;
+  fileName: string;
+}
+
+/** Archivo que va dentro del expediente exportado, con la huella que tenía al incorporarse. */
+export interface CaseFileExportFileEntity {
+  entryId: CaseFileEntryEntity['id'];
+  sequence: CaseFileEntryEntity['sequence'];
+  /** Ruta dentro del ZIP. Ej: `documentos/001-decreto-alcaldicio-exento-590-2026.pdf`. */
+  path: string;
+  fileId: string;
+  sha256: string | null;
+}
+
+/**
+ * Expediente listo para exportar: los metadatos con sus códigos oficiales (va tal cual como `expediente.json`) y los
+ * archivos que hay que agregar. El ZIP lo arma el gateway.
+ */
+export interface CaseFileExportResponseEntity {
+  code: CaseFileEntity['code'];
+  manifest: Record<string, unknown>;
+  files: CaseFileExportFileEntity[];
+}
+
+/** Expediente en que está incorporado un documento, visto desde el documento. */
+export type DocumentCaseFileEntity = CaseFileLinkEntity;

package/src/entities/caseFile/index.ts

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

package/src/entities/document/document.entity.ts

@@ -1,8 +1,10 @@
 import {
   DocumentAnnulledNumberEntity,
   DocumentAttachmentEntity,
+  DocumentDeliveryEntity,
   DocumentEntity,
   DocumentParticipantEntity,
+  DocumentRecipientEntity,
   DocumentTrackingEntity,
   DocumentTypeEntity,
 } from '../../base/entities';
@@ -19,6 +21,8 @@ export interface DocumentParticipantResponseEntity {
   id: DocumentParticipantEntity['id'];
   role: DocumentParticipantEntity['role'];
   order: DocumentParticipantEntity['order'];
+  /** Los visadores de una misma etapa visan a la vez. */
+  stage: DocumentParticipantEntity['stage'];
   status: DocumentParticipantEntity['status'];
   employeeId: DocumentParticipantEntity['employeeId'];
   fullName: DocumentParticipantEntity['fullName'];
@@ -27,6 +31,78 @@ export interface DocumentParticipantResponseEntity {
   resolvedAt: DocumentParticipantEntity['resolvedAt'];
 }
 
+/** Destinatario de un documento, como lo eligió el redactor: una persona o un área completa. */
+export interface DocumentRecipientResponseEntity {
+  id: DocumentRecipientEntity['id'];
+  type: DocumentRecipientEntity['type'];
+  employeeId: DocumentRecipientEntity['employeeId'];
+  directorateCodeReference: DocumentRecipientEntity['directorateCodeReference'];
+  departmentId: DocumentRecipientEntity['departmentId'];
+  name: DocumentRecipientEntity['name'];
+  position: DocumentRecipientEntity['position'];
+}
+
+/** Un documento en la bandeja de un funcionario: como destinatario o porque se lo derivaron. */
+export interface DocumentDeliveryResponseEntity {
+  id: DocumentDeliveryEntity['id'];
+  origin: DocumentDeliveryEntity['origin'];
+  employeeId: DocumentDeliveryEntity['employeeId'];
+  fullName: DocumentDeliveryEntity['fullName'];
+  position: DocumentDeliveryEntity['position'];
+  // Área por la que le llegó, si el documento iba dirigido a un área.
+  areaName: DocumentDeliveryEntity['areaName'];
+  // Quién se lo derivó. Null si es uno de los destinatarios originales.
+  sentByEmployeeId: DocumentDeliveryEntity['sentByEmployeeId'];
+  sentByFullName: DocumentDeliveryEntity['sentByFullName'];
+  instruction: DocumentDeliveryEntity['instruction'];
+  note: DocumentDeliveryEntity['note'];
+  dueAt: DocumentDeliveryEntity['dueAt'];
+  // Null mientras el documento no termina su tramitación.
+  deliveredAt: DocumentDeliveryEntity['deliveredAt'];
+  readAt: DocumentDeliveryEntity['readAt'];
+  closedAt: DocumentDeliveryEntity['closedAt'];
+  closingNote: DocumentDeliveryEntity['closingNote'];
+}
+
+/** Lo necesario para citar otro documento y enlazarlo (el que se responde, o las respuestas). */
+export interface DocumentLinkEntity {
+  id: DocumentEntity['id'];
+  subject: DocumentEntity['subject'];
+  status: DocumentEntity['status'];
+  correlative: DocumentEntity['correlative'];
+  correlativeYear: DocumentEntity['correlativeYear'];
+  createdByFullName: DocumentEntity['createdByFullName'];
+  finishedAt: DocumentEntity['finishedAt'];
+  documentType: DocumentTypeSummaryEntity;
+  /** Folio de ingreso de Oficina de Partes, si llegó por DocDigital. */
+  intakeNumber: DocumentEntity['intakeNumber'];
+  intakeYear: DocumentEntity['intakeYear'];
+}
+
+/** Institución (y usuario) de DocDigital a la que va dirigido un documento. */
+export interface DocumentExternalRecipientResponseEntity {
+  id: string;
+  entityId: number;
+  entityName: string;
+  userId: number | null;
+  userName: string | null;
+  userPosition: string | null;
+}
+
+/** Despacho de un documento por DocDigital. */
+export interface DocumentDispatchResponseEntity {
+  id: string;
+  status: 'Pending' | 'Dispatched' | 'Returned';
+  folio: string | null;
+  docDigitalTypeName: string | null;
+  docDigitalDocumentId: string | null;
+  dispatchedAt: string | null;
+  dispatchedByFullName: string | null;
+  returnedAt: string | null;
+  returnedByFullName: string | null;
+  returnReason: string | null;
+}
+
 export interface DocumentGetAllResponseEntity {
   id: DocumentEntity['id'];
   subject: DocumentEntity['subject'];
@@ -40,8 +116,22 @@ export interface DocumentGetAllResponseEntity {
   createdByEmployeeId: DocumentEntity['createdByEmployeeId'];
   createdByFullName: DocumentEntity['createdByFullName'];
   documentType: DocumentTypeSummaryEntity;
+  intakeNumber: DocumentEntity['intakeNumber'];
+  intakeYear: DocumentEntity['intakeYear'];
+  origin: DocumentEntity['origin'];
+  /** Con búsqueda de texto completo: el fragmento donde aparece lo buscado, con lo encontrado entre ⟦ y ⟧. */
+  snippet?: string | null;
   // A quién le toca visar o firmar (null si el documento no está en tramitación).
   currentParticipant: Pick<DocumentParticipantResponseEntity, 'role' | 'employeeId' | 'fullName'> | null;
+  // Cuántos más tienen el turno a la vez (visación en paralelo).
+  otherCurrentCount: number;
+  // A cuántos funcionarios llegó y cuántos ya lo abrieron (null si aún no se distribuye a nadie).
+  distribution: { total: number; read: number } | null;
+}
+
+/** Una entrada de la bandeja de recibidos: la entrega y el documento al que corresponde. */
+export interface DocumentInboxItemEntity extends DocumentDeliveryResponseEntity {
+  document: DocumentLinkEntity;
 }
 
 export interface DocumentGetByIdResponseEntity {
@@ -82,6 +172,31 @@ export interface DocumentGetByIdResponseEntity {
     employeeFullName: DocumentAnnulledNumberEntity['employeeFullName'];
     createdAt: DocumentAnnulledNumberEntity['createdAt'];
   }[];
+  // Plazo en que el redactor espera respuesta de los destinatarios.
+  responseDueAt: DocumentEntity['responseDueAt'];
+  // A quién va dirigido, como lo indicó el redactor (personas y áreas).
+  recipients: DocumentRecipientResponseEntity[];
+  // En la bandeja de quién está: destinatarios y derivaciones, con su lectura y atención.
+  deliveries: DocumentDeliveryResponseEntity[];
+  // Documento al que este responde, y los que le responden (solo los ya finalizados, más los propios de quien consulta).
+  replyTo: DocumentLinkEntity | null;
+  /** Lote de firma al que pertenece. */
+  batch: { id: string; name: string } | null;
+  /** Contenido redactado en el sistema con una plantilla, para volver a editarlo (sin valor si se subió un PDF). */
+  composition: DocumentComposition | null;
+  replies: DocumentLinkEntity[];
+  /** Expedientes en que está incorporado y que quien consulta puede ver. */
+  caseFiles: { id: string; code: string; title: string; status: 'Open' | 'Closed' }[];
+  /** De dónde viene: del gestor o recibido por DocDigital, con su folio de ingreso y los datos de quien lo envió. */
+  origin: DocumentEntity['origin'];
+  intakeNumber: DocumentEntity['intakeNumber'];
+  intakeYear: DocumentEntity['intakeYear'];
+  externalFolio: DocumentEntity['externalFolio'];
+  externalSender: DocumentEntity['externalSender'];
+  externalDate: DocumentEntity['externalDate'];
+  /** Instituciones de DocDigital a quienes va dirigido, y su despacho por Oficina de Partes. */
+  externalRecipients: DocumentExternalRecipientResponseEntity[];
+  dispatch: DocumentDispatchResponseEntity | null;
   documentType: DocumentTypeSummaryEntity;
   participants: DocumentParticipantResponseEntity[];
   attachments: {
@@ -105,6 +220,15 @@ export interface DocumentGetByIdResponseEntity {
     turn: Pick<DocumentParticipantResponseEntity, 'id' | 'role'> | null;
     canEdit: boolean;
     canDiscard: boolean;
+    // Puede derivarlo a otros funcionarios y responderlo: el documento ya es oficial y está a su alcance.
+    canDerive: boolean;
+    canReply: boolean;
+    // Es quien redactó un documento en tramitación: puede pasar un turno pendiente a otro funcionario.
+    canReassign: boolean;
+    /** Quien consulta redactó el documento (o lo ingresó, si llegó por DocDigital). */
+    isAuthor: boolean;
+    // Sus propias entregas de este documento (puede tener más de una si además se lo derivaron).
+    inbox: DocumentDeliveryResponseEntity[];
   };
   // Firmar exige el código OTP de quien firma (firma atendida).
   signatureRequiresOtp: boolean;
@@ -114,12 +238,20 @@ export interface DocumentGetByIdResponseEntity {
 export interface DocumentGetSummaryResponseEntity {
   toVisa: number;
   toSign: number;
+  /** Lotes de firma con documentos en su turno (los documentos de un lote no se cuentan en `toVisa` ni `toSign`). */
+  batches: { toVisa: number; toSign: number };
   created: {
     drafted: number;
     inProgress: number;
     rejected: number;
     finished: number;
   };
+  // Su bandeja de recibidos: sin abrir, sin atender y, de estos, con el plazo vencido.
+  received: {
+    unread: number;
+    pending: number;
+    overdue: number;
+  };
 }
 
 export interface DocumentCreateResponseEntity {
@@ -138,6 +270,29 @@ export interface DocumentReviewResponseEntity {
   status: DocumentEntity['status'];
 }
 
+/** Resultado de un documento en una firma de varios documentos. */
+export interface DocumentSignManyResultEntity {
+  id: DocumentEntity['id'];
+  ok: boolean;
+  /** Estado en que quedó, si se firmó. */
+  status?: DocumentEntity['status'];
+  /** Por qué no se firmó. */
+  message?: string;
+}
+
+/**
+ * Firma de varios documentos con un solo OTP. FirmaGob admite 5 MB por solicitud: los que no cupieron quedan en
+ * `remaining`, en el turno del firmante, para firmarlos con un OTP nuevo.
+ */
+export interface DocumentSignManyResponseEntity {
+  results: DocumentSignManyResultEntity[];
+  signed: number;
+  failed: number;
+  remaining: DocumentEntity['id'][];
+  /** FirmaGob avisó que el OTP venció antes de firmar todos los documentos de la solicitud. */
+  otpExpired: boolean;
+}
+
 export interface DocumentDiscardResponseEntity {
   id: DocumentEntity['id'];
   ok: boolean;
@@ -185,3 +340,107 @@ export interface DocumentPublicFileResponseEntity {
   fileId: string;
   fileName: string;
 }
+
+export interface DocumentDeriveResponseEntity {
+  id: DocumentEntity['id'];
+  ok: boolean;
+  // A cuántos funcionarios llegó la derivación.
+  delivered: number;
+}
+
+export interface DocumentCloseDeliveryResponseEntity {
+  id: DocumentDeliveryEntity['id'];
+  ok: boolean;
+}
+
+export interface DocumentReassignResponseEntity {
+  id: DocumentEntity['id'];
+  ok: boolean;
+}
+
+/**
+ * Un plazo en la agenda de un funcionario: lo que recibió (como destinatario o por derivación) y debe atender, o un
+ * documento que envió y del que espera respuesta.
+ */
+export interface DocumentAgendaItemEntity {
+  kind: 'Received' | 'Sent';
+  /** La entrega (lo recibido) o el documento (lo enviado). */
+  id: string;
+  documentId: DocumentEntity['id'];
+  subject: DocumentEntity['subject'];
+  documentType: { name: string; abbreviation: string | null };
+  correlative: DocumentEntity['correlative'];
+  correlativeYear: DocumentEntity['correlativeYear'];
+  intakeNumber: DocumentEntity['intakeNumber'];
+  intakeYear: DocumentEntity['intakeYear'];
+  /** Plazo, en ISO 8601. */
+  dueAt: string;
+  /** Lo recibido: cuándo lo marcó como atendido (sin valor si sigue pendiente). */
+  closedAt: string | null;
+  /** Lo recibido: la providencia y quién lo derivó. */
+  instruction: DocumentDeliveryEntity['instruction'] | null;
+  sentByFullName: string | null;
+  /** Lo enviado: a cuántos les llegó y cuántos aún no lo atienden. */
+  recipients: { total: number; pending: number } | null;
+}
+
+export interface DocumentAgendaResponseEntity {
+  /** Plazos dentro del período pedido. */
+  items: DocumentAgendaItemEntity[];
+  /** Lo recibido con el plazo vencido y sin atender, de cualquier fecha (los 50 más antiguos). */
+  overdue: DocumentAgendaItemEntity[];
+}
+
+/** Trazabilidad de un documento en PDF, lista para descargar. */
+export interface DocumentTrailExportEntity {
+  fileName: string;
+  contentType: string;
+  contentBase64: string;
+}
+
+/** Plantilla oficial con que se redacta un documento en el sistema. */
+export type DocumentTemplateKind = 'Decree' | 'Office' | 'Memorandum' | 'General';
+
+/**
+ * Contenido de un documento redactado en el sistema. Cada plantilla tiene su estructura; los párrafos son texto
+ * (un salto de línea dentro de un párrafo se respeta). La materia es el asunto del documento.
+ */
+export type DocumentComposition =
+  | {
+      template: 'Decree';
+      /** VISTOS: las normas y antecedentes. */
+      vistos: string[];
+      /** CONSIDERANDO: cada fundamento, numerado. */
+      considerando: string[];
+      /** DECRETO: cada punto resolutivo, numerado. */
+      resolutive: string[];
+      /** Fórmula de cierre: «Anótese, comuníquese y archívese». */
+      closing: string;
+      distribution: string[];
+    }
+  | {
+      template: 'Office';
+      /** ANT.: antecedentes (otro oficio, una solicitud). */
+      antecedents?: string | null;
+      from: string;
+      to: string;
+      body: string[];
+      closing: string;
+      distribution: string[];
+    }
+  | {
+      template: 'Memorandum';
+      from: string;
+      to: string;
+      body: string[];
+      closing?: string | null;
+      distribution: string[];
+    }
+  | { template: 'General'; title: string; body: string[]; closing?: string | null };
+
+/** PDF armado con una plantilla: para la vista previa (`contentBase64`) o ya subido (`fileId`). */
+export interface DocumentComposeResponseEntity {
+  fileName: string;
+  fileId?: string;
+  contentBase64?: string;
+}

package/src/entities/documentType/documentType.entity.ts

@@ -1,4 +1,17 @@
-import { DocumentTypeEntity } from '../../base/entities';
+import { DocumentTypeEntity, DocumentTypeFlowStepEntity } from '../../base/entities';
+
+/** Paso del flujo sugerido de un tipo documental: quién visa o firma, en su orden. */
+export interface DocumentTypeFlowStepResponseEntity {
+  id: DocumentTypeFlowStepEntity['id'];
+  role: DocumentTypeFlowStepEntity['role'];
+  order: DocumentTypeFlowStepEntity['order'];
+  type: DocumentTypeFlowStepEntity['type'];
+  employeeId: DocumentTypeFlowStepEntity['employeeId'];
+  directorateCodeReference: DocumentTypeFlowStepEntity['directorateCodeReference'];
+  // Nombre del funcionario o de la dirección, como estaba al definir el flujo.
+  name: DocumentTypeFlowStepEntity['name'];
+  position: DocumentTypeFlowStepEntity['position'];
+}
 
 export interface DocumentTypeGetAllResponseEntity {
   id: DocumentTypeEntity['id'];
@@ -9,14 +22,20 @@ export interface DocumentTypeGetAllResponseEntity {
   nextCorrelative: DocumentTypeEntity['nextCorrelative'];
   correlativeYear: DocumentTypeEntity['correlativeYear'];
   resetsYearly: DocumentTypeEntity['resetsYearly'];
+  // Sin numeración, sus documentos solo llevan fecha, código de verificación y QR.
+  numbered: DocumentTypeEntity['numbered'];
   directorateCodeReference: DocumentTypeEntity['directorateCodeReference'];
   enabled: DocumentTypeEntity['enabled'];
+  // Cuántos visadores y firmantes tiene su flujo sugerido.
+  flow: { visa: number; signature: number };
 }
 
 export interface DocumentTypeGetByIdResponseEntity extends DocumentTypeGetAllResponseEntity {
   // Último número ya asignado en el año vigente del correlativo (null si aún no se numera ninguno): el próximo
   // correlativo no puede quedar por debajo de él.
   lastCorrelative: number | null;
+  // Flujo sugerido: primero los visadores y después los firmantes, cada grupo en su orden.
+  flowSteps: DocumentTypeFlowStepResponseEntity[];
 }
 
 export interface DocumentTypeCreateResponseEntity {

package/src/entities/index.ts

@@ -1,2 +1,8 @@
 export * from './documentType';
 export * from './document';
+export * from './procedure';
+export * from './caseFile';
+export * from './partsOffice';
+export * from './registerBook';
+export * from './signatureBatch';
+export * from './workFolder';

package/src/entities/partsOffice/index.ts

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