@muni-sanfer/types-gestor-documental 0.0.1-beta.0 → 0.0.1-beta.10

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

@@ -1,7 +1,10 @@
 import {
+  DocumentAnnulledNumberEntity,
   DocumentAttachmentEntity,
+  DocumentDeliveryEntity,
   DocumentEntity,
   DocumentParticipantEntity,
+  DocumentRecipientEntity,
   DocumentTrackingEntity,
   DocumentTypeEntity,
 } from '../../base/entities';
@@ -18,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'];
@@ -26,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'];
@@ -39,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 {
@@ -64,6 +155,46 @@ export interface DocumentGetByIdResponseEntity {
   createdAt: DocumentEntity['createdAt'];
   submittedAt: DocumentEntity['submittedAt'];
   finishedAt: DocumentEntity['finishedAt'];
+  // Código con que se comprueba el documento en la página pública. Null mientras no se envía a tramitación.
+  verificationCode: DocumentEntity['verificationCode'];
+  // Dirección de esa página para este documento. Null si el servicio no la tiene configurada.
+  verificationUrl: string | null;
+  // El redactor pidió una hoja aparte para firmas y visaciones.
+  signatureSheet: DocumentEntity['signatureSheet'];
+  // Anulación de un documento ya finalizado.
+  annulledAt: DocumentEntity['annulledAt'];
+  annulmentReason: DocumentEntity['annulmentReason'];
+  // Números que el documento tuvo y perdió: lo rechazaron cuando ya estaba numerado.
+  annulledNumbers: {
+    correlative: DocumentAnnulledNumberEntity['correlative'];
+    correlativeYear: DocumentAnnulledNumberEntity['correlativeYear'];
+    reason: DocumentAnnulledNumberEntity['reason'];
+    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;
+  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: {
@@ -87,6 +218,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;
@@ -96,12 +236,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 {
@@ -120,7 +268,130 @@ 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;
 }
+
+export interface DocumentAnnulResponseEntity {
+  id: DocumentEntity['id'];
+  ok: boolean;
+}
+
+/**
+ * Qué se le dice a quien comprueba un documento con su código, sin sesión:
+ *  - `Finished`: es un documento oficial vigente;
+ *  - `Annulled`: lo fue, pero quedó sin efecto;
+ *  - `InProgress`: todavía se está firmando, así que la copia que tiene no es el documento oficial.
+ */
+export type DocumentVerificationState = 'Finished' | 'Annulled' | 'InProgress';
+
+/**
+ * Respuesta pública de la verificación. Dice lo necesario para comprobar la autenticidad (tipo, número, fecha y
+ * quiénes firmaron); la materia y la descarga solo se entregan si el documento es de acceso público.
+ */
+export interface DocumentVerifyResponseEntity {
+  state: DocumentVerificationState;
+  verificationCode: string;
+  documentType: Pick<DocumentTypeSummaryEntity, 'name' | 'abbreviation'>;
+  correlative: DocumentEntity['correlative'];
+  correlativeYear: DocumentEntity['correlativeYear'];
+  numberedAt: DocumentEntity['numberedAt'];
+  finishedAt: DocumentEntity['finishedAt'];
+  annulledAt: DocumentEntity['annulledAt'];
+  // Quiénes firmaron (o deben firmar, si aún está en tramitación), en su orden.
+  signers: {
+    fullName: DocumentParticipantEntity['fullName'];
+    position: DocumentParticipantEntity['position'];
+    signedAt: DocumentParticipantEntity['resolvedAt'];
+  }[];
+  // Solo en documentos de acceso público y sin datos sensibles.
+  subject: DocumentEntity['subject'] | null;
+  canDownload: boolean;
+}
+
+/** Archivo de un documento público, para que el gateway lo entregue a quien lo verifica. */
+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;
+}

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';

package/src/entities/partsOffice/partsOffice.entity.ts

@@ -0,0 +1,103 @@
+import {
+  type DocumentDispatchResponseEntity,
+  type DocumentExternalRecipientResponseEntity,
+  type DocumentLinkEntity,
+} from '../document';
+
+/** Institución del Estado en DocDigital. */
+export interface DocDigitalEntityEntity {
+  id: number;
+  name: string;
+  /** Organismo al que pertenece (la entidad padre). */
+  organism: string | null;
+}
+
+/** Usuario habilitado de una institución en DocDigital. */
+export interface DocDigitalUserEntity {
+  id: number;
+  name: string;
+  position: string | null;
+}
+
+export interface DocDigitalDocumentTypeEntity {
+  id: number;
+  name: string;
+}
+
+/** Si DocDigital está configurado en el gestor y cada cuánto se revisa lo recibido. */
+export interface PartsOfficeStatusEntity {
+  configured: boolean;
+  syncMinutes: number;
+}
+
+/** Totales del Panel de Partes. */
+export interface PartsOfficeSummaryEntity {
+  toDispatch: number;
+  received: number;
+}
+
+/** Documento firmado que va a otras instituciones: lo despacha Oficina de Partes. */
+export interface PartsOfficeDispatchEntity extends DocumentDispatchResponseEntity {
+  document: DocumentLinkEntity & { accessLevel: string };
+  externalRecipients: DocumentExternalRecipientResponseEntity[];
+  createdAt: string;
+}
+
+/** Documento que llegó por DocDigital. */
+export interface PartsOfficeInboundEntity {
+  id: string;
+  docDigitalDocumentId: string;
+  status: 'Pending' | 'Registered' | 'Returned';
+  subject: string;
+  description: string | null;
+  folio: string | null;
+  folioDate: string | null;
+  typeName: string | null;
+  reserved: boolean;
+  senderEntityName: string | null;
+  senderName: string | null;
+  senderPosition: string | null;
+  fileName: string | null;
+  hasFile: boolean;
+  attachments: { name: string; url: string | null; hasFile: boolean }[];
+  createdAt: string;
+  registeredAt: string | null;
+  registeredByFullName: string | null;
+  acknowledgedAt: string | null;
+  acknowledgeError: string | null;
+  returnedAt: string | null;
+  returnedByFullName: string | null;
+  returnReason: string | null;
+  /** El documento con que quedó ingresado al gestor. */
+  document: { id: string; intakeNumber: number | null; intakeYear: number | null } | null;
+}
+
+export interface PartsOfficeOkResponseEntity {
+  id: string;
+  ok: boolean;
+  /** Documento al que corresponde el despacho (al despachar o devolver). */
+  documentId?: string;
+}
+
+export interface PartsOfficeSyncResponseEntity {
+  /** Recibidos nuevos que se trajeron. */
+  created: number;
+  /** Los que no se pudieron traer (se reintentan en la próxima revisión). */
+  failed: number;
+}
+
+export interface PartsOfficeRegisterResponseEntity {
+  id: string;
+  documentId: string;
+  intakeNumber: number;
+  intakeYear: number;
+  /** `false` si DocDigital no aceptó el acuse de recibo: se puede reintentar. */
+  acknowledged: boolean;
+  ok: boolean;
+}
+
+/** Archivo de un recibido, ya copiado al gestor. */
+export interface PartsOfficeFileEntity {
+  fileId: string;
+  fileName: string;
+}

package/src/entities/procedure/index.ts

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

package/src/entities/procedure/procedure.entity.ts

@@ -0,0 +1,24 @@
+import { ProcedureEntity } from '../../base/entities';
+
+export interface ProcedureGetAllResponseEntity {
+  id: ProcedureEntity['id'];
+  name: ProcedureEntity['name'];
+  cpatId: ProcedureEntity['cpatId'];
+  cpatCode: ProcedureEntity['cpatCode'];
+  description: ProcedureEntity['description'];
+  enabled: ProcedureEntity['enabled'];
+  /** Cuántos expedientes pertenecen a este procedimiento. */
+  caseFiles: number;
+}
+
+export type ProcedureGetByIdResponseEntity = ProcedureGetAllResponseEntity;
+
+export interface ProcedureCreateResponseEntity {
+  id: ProcedureEntity['id'];
+  ok: boolean;
+}
+
+export interface ProcedureUpdateResponseEntity {
+  id: ProcedureEntity['id'];
+  ok: boolean;
+}

package/src/entities/registerBook/index.ts

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

package/src/entities/registerBook/registerBook.entity.ts

@@ -0,0 +1,46 @@
+/** Libro de registro: el de un tipo documental (sus números) o el de ingresos de Oficina de Partes. */
+export type RegisterBookKind = 'documentType' | 'intake';
+
+/**
+ * Estado de un número en el libro: vigente, en tramitación (numerado con la primera firma, aún sin todas las firmas),
+ * documento anulado, número anulado por un rechazo, o número sin registro en el gestor (un salto en la numeración).
+ */
+export type RegisterBookRowState = 'Valid' | 'InProgress' | 'Annulled' | 'NumberAnnulled' | 'Unused';
+
+export interface RegisterBookRowEntity {
+  number: number;
+  /** Fecha del número (o del ingreso), en ISO 8601. `null` en un salto. */
+  date: string | null;
+  state: RegisterBookRowState;
+  documentId: string | null;
+  subject: string | null;
+  /** Quién redactó el documento (o, en el libro de ingresos, quién lo ingresó). */
+  author: string | null;
+  signers: string[];
+  /** Libro de ingresos: institución que lo envió y su folio. */
+  sender: string | null;
+  externalFolio: string | null;
+  /** Libro de ingresos: a quiénes se derivó. */
+  recipients: string[];
+  /** Despacho por DocDigital: «DocDigital N° 777001 · 14-10-2026». */
+  dispatch: string | null;
+  /** Motivo de la anulación (del documento o del número). */
+  observation: string | null;
+}
+
+export interface RegisterBookEntity {
+  kind: RegisterBookKind;
+  /** «Decreto alcaldicio exento» o «Ingresos de Oficina de Partes». */
+  title: string;
+  year: number;
+  month: number | null;
+  rows: RegisterBookRowEntity[];
+  totals: Record<RegisterBookRowState, number>;
+}
+
+/** Libro exportado, listo para descargar. */
+export interface RegisterBookExportEntity {
+  fileName: string;
+  contentType: string;
+  contentBase64: string;
+}

package/src/entities/signatureBatch/index.ts

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

package/src/entities/signatureBatch/signatureBatch.entity.ts

@@ -0,0 +1,110 @@
+import {
+  type DocumentAccessLevel,
+  type DocumentEntity,
+  type DocumentParticipantRole,
+  type DocumentStatus,
+  type SignatureBatchEntity,
+} from '../../base/entities';
+import { type DocumentSignManyResponseEntity, type DocumentSignManyResultEntity } from '../document';
+
+/**
+ * Estado de un lote, deducido del de sus documentos: en tramitación mientras alguno lo esté; devuelto si no queda
+ * ninguno en tramitación y alguno volvió a su redactor; finalizado si todos terminaron (o se anularon después).
+ */
+export type SignatureBatchStatus = 'InProgress' | 'Returned' | 'Finished';
+
+/** Lista de lotes: los que esperan al funcionario, los que redactó o todos en que participa. */
+export type SignatureBatchTab = 'pending' | 'created' | 'participated';
+
+/** Cuántos documentos del lote hay en cada situación. */
+export interface SignatureBatchCountsEntity {
+  total: number;
+  inProgress: number;
+  finished: number;
+  /** Devueltos a su redactor (rechazados), para corregirlos y reenviarlos. */
+  returned: number;
+  annulled: number;
+}
+
+export interface SignatureBatchGetAllResponseEntity {
+  id: string;
+  name: string;
+  documentType: { id: string; name: string };
+  createdByEmployeeId: string;
+  createdByFullName: string;
+  createdAt: SignatureBatchEntity['createdAt'];
+  status: SignatureBatchStatus;
+  counts: SignatureBatchCountsEntity;
+  /** Documentos del lote que esperan al funcionario que consulta, por rol. */
+  myPending: { visa: number; signature: number };
+}
+
+/** Un documento del lote, con su turno vigente. */
+export interface SignatureBatchDocumentEntity {
+  id: string;
+  subject: string;
+  status: DocumentStatus;
+  correlative: number | null;
+  correlativeYear: number | null;
+  numberedAt: DocumentEntity['numberedAt'];
+  verificationCode: string | null;
+  originalFileName: string;
+  currentTurn: { employeeId: string; fullName: string; role: DocumentParticipantRole } | null;
+  /** Si el turno vigente es del funcionario que consulta, qué le toca hacer. */
+  myTurn: DocumentParticipantRole | null;
+}
+
+export interface SignatureBatchGetByIdResponseEntity extends SignatureBatchGetAllResponseEntity {
+  documentType: { id: string; name: string; abbreviation: string | null; numbered: boolean };
+  keywords: string[];
+  accessLevel: DocumentAccessLevel;
+  hasSensitiveData: boolean;
+  /** Visadores y firmantes del lote, en orden (los del primer documento: todos parten con el mismo flujo). */
+  flow: {
+    role: DocumentParticipantRole;
+    stage: number;
+    employeeId: string;
+    fullName: string;
+    position: string | null;
+  }[];
+  documents: SignatureBatchDocumentEntity[];
+}
+
+/** A quién le quedó el turno después de una operación sobre el lote: para avisarle una sola vez por lote. */
+export interface SignatureBatchTurnEntity {
+  employeeId: string;
+  fullName: string;
+  role: DocumentParticipantRole;
+  count: number;
+}
+
+/** Lo que el gateway necesita para avisar: el lote, su redactor, a quién le toca ahora y cuántos terminaron. */
+export interface SignatureBatchOutcomeEntity {
+  id: string;
+  name: string;
+  createdByEmployeeId: string;
+  nextTurns: SignatureBatchTurnEntity[];
+  /** Documentos que quedaron finalizados con esta operación. */
+  finished: number;
+}
+
+export interface SignatureBatchCreateResponseEntity extends SignatureBatchOutcomeEntity {
+  ok: boolean;
+  documentIds: string[];
+}
+
+export interface SignatureBatchVisaResponseEntity extends SignatureBatchOutcomeEntity {
+  ok: boolean;
+  visaed: number;
+  /** Los que no se pudieron visar, con el motivo. */
+  failures: DocumentSignManyResultEntity[];
+}
+
+export type SignatureBatchSignResponseEntity = SignatureBatchOutcomeEntity & DocumentSignManyResponseEntity;
+
+export interface SignatureBatchRejectResponseEntity extends SignatureBatchOutcomeEntity {
+  ok: boolean;
+  /** Documentos devueltos a su redactor. */
+  rejected: number;
+  observation: string;
+}

package/src/entities/workFolder/index.ts

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