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

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

@@ -0,0 +1,110 @@
+import { type PdfSignatureReportEntity } from '../signatureCheck';
+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[];
+  /** A nombre de quién sale: la entidad emisora del tipo documental o la municipalidad. */
+  issuerName: string;
+  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;
+  /** Entidad propia a la que llegó (la municipalidad o una entidad emisora). */
+  recipientEntityName: string | null;
+  senderEntityName: string | null;
+  senderName: string | null;
+  senderPosition: string | null;
+  fileName: string | null;
+  hasFile: boolean;
+  /** Revisión de las firmas del documento principal al recibirlo. */
+  signatureCheck: PdfSignatureReportEntity | null;
+  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,52 @@
+/** 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;
+  /** Numeración compartida: tipo documental del número (`null` en un salto o si el libro es de un solo tipo). */
+  documentTypeName: string | null;
+}
+
+export interface RegisterBookEntity {
+  kind: RegisterBookKind;
+  /** «Decreto alcaldicio exento» o «Ingresos de Oficina de Partes». */
+  title: string;
+  /** Quién lleva el libro: la entidad emisora del tipo o la municipalidad. */
+  issuerName: string;
+  /** Numeración compartida: los tipos que numeran en la serie del libro (vacío si es de un solo tipo). */
+  series: 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/scan/index.ts

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

package/src/entities/scan/scan.entity.ts

@@ -0,0 +1,32 @@
+/** Sesión recién abierta: el token y el QR viajan solo aquí. */
+export interface ScanSessionCreateResponseEntity {
+  id: string;
+  token: string;
+  /** Dirección que abre el celular, con el token. */
+  url: string;
+  /** El QR de esa dirección, como imagen PNG en data URL. */
+  qrDataUrl: string;
+  expiresAt: string;
+}
+
+/** Estado de la sesión, como lo ve en el escritorio quien la abrió. */
+export interface ScanSessionResponseEntity {
+  id: string;
+  status: 'Open' | 'Ready';
+  pageCount: number;
+  expiresAt: string;
+  fileName: string | null;
+}
+
+export interface ScanSessionFileResponseEntity {
+  fileId: string;
+  fileName: string;
+}
+
+/** La sesión como la ve el celular. */
+export interface ScanSessionPublicEntity {
+  status: 'Open' | 'Ready';
+  pageCount: number;
+  maxPages: number;
+  expiresAt: 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/signatureCheck/index.ts

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

package/src/entities/signatureCheck/signatureCheck.entity.ts

@@ -0,0 +1,51 @@
+/**
+ * Resultado de una firma o del archivo completo: válida, inválida (algo no cuadra) o indeterminada (lo firmado está
+ * íntegro, pero falta confirmar algo: la cadena de confianza, la vigencia o cambios posteriores sin firmar).
+ */
+export type PdfSignatureStatus = 'Valid' | 'Invalid' | 'Indeterminate';
+
+/** Una firma electrónica de un PDF, como se pudo comprobar. */
+export interface PdfSignatureEntity {
+  /** Orden en el archivo: 1 es la primera. */
+  index: number;
+  /** Firma de una persona o sello de tiempo del documento. */
+  kind: 'Signature' | 'Timestamp';
+  signerName: string | null;
+  /** Identificador del titular en el certificado (en Chile, suele ser el RUN). */
+  signerSerialNumber: string | null;
+  organization: string | null;
+  issuerName: string | null;
+  certificateSerial: string | null;
+  certificateValidFrom: string | null;
+  certificateValidTo: string | null;
+  signingTime: string | null;
+  /** De dónde sale la hora de la firma: sello de tiempo (la más confiable), el certificado firmado o el PDF. */
+  signingTimeSource: 'Timestamp' | 'SignedAttribute' | 'PdfDate' | null;
+  reason: string | null;
+  location: string | null;
+  hasTimestamp: boolean;
+  /** Lo firmado no cambió y la firma corresponde al certificado. */
+  intact: boolean;
+  /** La firma abarca el archivo completo (las anteriores a la última, solo su versión). */
+  coversWholeDocument: boolean;
+  /** El certificado estaba vigente al firmar. `null` si no se sabe cuándo se firmó. */
+  certificateValidAtSigning: boolean | null;
+  /** Cadena hasta un certificado raíz de confianza. `null` si no hay raíces configuradas. */
+  trusted: boolean | null;
+  status: PdfSignatureStatus;
+  /** Lo que no cuadra o no se pudo confirmar, en palabras. */
+  problems: string[];
+}
+
+/** Revisión de las firmas de un PDF. */
+export interface PdfSignatureReportEntity {
+  checkedAt: string;
+  status: 'NoSignatures' | PdfSignatureStatus;
+  signatures: PdfSignatureEntity[];
+  /** Hay contenido agregado después de la última firma, que no está firmado. */
+  modifiedAfterLastSignature: boolean;
+  /** Se configuraron certificados raíz para confirmar la cadena de confianza. */
+  trustConfigured: boolean;
+  /** Huella SHA-256 del archivo revisado. */
+  fileSha256: string;
+}

package/src/entities/textSnippet/index.ts

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

package/src/entities/textSnippet/textSnippet.entity.ts

@@ -0,0 +1,24 @@
+import { TextSnippetEntity } from '../../base/entities';
+
+/** Texto de la biblioteca de vistos y cláusulas. */
+export interface TextSnippetGetAllResponseEntity {
+  id: TextSnippetEntity['id'];
+  title: TextSnippetEntity['title'];
+  text: TextSnippetEntity['text'];
+  section: TextSnippetEntity['section'];
+  keywords: TextSnippetEntity['keywords'];
+  enabled: TextSnippetEntity['enabled'];
+  updatedAt: TextSnippetEntity['updatedAt'];
+}
+
+export type TextSnippetGetByIdResponseEntity = TextSnippetGetAllResponseEntity;
+
+export interface TextSnippetCreateResponseEntity {
+  id: TextSnippetEntity['id'];
+  ok: boolean;
+}
+
+export interface TextSnippetUpdateResponseEntity {
+  id: TextSnippetEntity['id'];
+  ok: boolean;
+}

package/src/entities/workFolder/index.ts

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

package/src/entities/workFolder/workFolder.entity.ts

@@ -0,0 +1,84 @@
+import {
+  type CaseFileActuationType,
+  type DocumentAccessLevel,
+  type DocumentStatus,
+  type WorkFolderItemKind,
+} from '../../base/entities';
+
+export interface WorkFolderGetAllResponseEntity {
+  id: string;
+  name: string;
+  description: string | null;
+  ownerEmployeeId: string;
+  ownerFullName: string;
+  itemCount: number;
+  participantCount: number;
+  /** Expediente en que se convirtió: desde ahí la carpeta queda solo de consulta. */
+  caseFile: { id: string; code: string } | null;
+  createdAt: string;
+  updatedAt: string;
+  /** Quien consulta es su responsable. */
+  isOwner: boolean;
+}
+
+export interface WorkFolderItemResponseEntity {
+  id: string;
+  kind: WorkFolderItemKind;
+  title: string;
+  /** Documento del gestor (si es uno). */
+  document: {
+    id: string;
+    status: DocumentStatus;
+    documentType: { name: string; abbreviation: string | null };
+    correlative: number | null;
+    correlativeYear: number | null;
+    intakeNumber: number | null;
+    intakeYear: number | null;
+  } | null;
+  /** Archivo subido (si es uno). Se descarga por la carpeta, que comprueba el acceso. */
+  fileId: string | null;
+  fileName: string | null;
+  addedByEmployeeId: string;
+  addedByFullName: string;
+  createdAt: string;
+  /** Lo puede quitar quien consulta: el responsable o quien lo agregó, mientras no se convierta en expediente. */
+  canRemove: boolean;
+}
+
+export interface WorkFolderGetByIdResponseEntity extends WorkFolderGetAllResponseEntity {
+  participants: { id: string; employeeId: string; fullName: string }[];
+  items: WorkFolderItemResponseEntity[];
+  /** Editar, compartir y convertir: solo el responsable, mientras no se haya convertido. */
+  canEdit: boolean;
+  /** Agregar ítems: el responsable y aquellos con quienes se compartió, mientras no se haya convertido. */
+  canAdd: boolean;
+}
+
+export interface WorkFolderWriteResponseEntity {
+  id: string;
+  ok: boolean;
+}
+
+/** La carpeta convertida en expediente: cuántos ítems entraron a su índice y cuántos no (documentos sin finalizar). */
+export interface WorkFolderConvertResponseEntity {
+  id: string;
+  caseFileId: string;
+  code: string;
+  added: number;
+  skipped: number;
+  ok: boolean;
+}
+
+/** Metadatos del expediente que nace de una carpeta (los mismos de un expediente nuevo). */
+export interface WorkFolderConvertInput {
+  title: string;
+  subject: string;
+  summary?: string | null;
+  procedureId: string;
+  accessLevel: DocumentAccessLevel;
+  hasSensitiveData: boolean;
+  /** Tipo de actuación con que entran los documentos al índice. */
+  actuationType: CaseFileActuationType;
+  /** Palabras clave de los archivos subidos (metadato obligatorio de cada actuación). */
+  keywords: string[];
+}

package/tsconfig.json

@@ -9,7 +9,5 @@
     "skipLibCheck": true,
     "rootDir": "./src"
   },
-  "include": [
-    "src"
-  ]
+  "include": ["src"]
 }