@muni-sanfer/types-gestor-documental 0.0.1-beta.3 → 0.0.1-beta.30

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/transparency/index.ts

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

package/src/entities/transparency/transparency.entity.ts

@@ -0,0 +1,78 @@
+import { type DocumentAccessLevel, type DocumentStatus } from '../../base/entities';
+import { type PersonalDataHintsEntity } from '../dataProtection';
+
+/** En qué quedó un documento en Transparencia Activa: aún sin decidir, publicado o excluido con su motivo. */
+export type TransparencyItemStatus = 'Pending' | 'Published' | 'Excluded';
+
+/** Un documento que se publica en Transparencia Activa (Ley 20.285, art. 7°), con lo que se decidió de él. */
+export interface TransparencyItemEntity {
+  documentId: string;
+  documentStatus: DocumentStatus;
+  verificationCode: string | null;
+  documentTypeName: string;
+  documentTypeAbbreviation: string | null;
+  /** Sección del Portal en que se publica, según su tipo documental. */
+  section: string | null;
+  /** Folio del documento (`Decreto Alcaldicio N° 15/2026`), o el nombre del tipo si no lleva número. */
+  reference: string;
+  correlative: number | null;
+  correlativeYear: number | null;
+  subject: string;
+  finishedAt: string | null;
+  annulledAt: string | null;
+  accessLevel: DocumentAccessLevel;
+  hasSensitiveData: boolean;
+  /** El original se puede publicar tal cual: es público (o su restricción terminó) y no tiene datos sensibles. */
+  originalIsPublic: boolean;
+  /** Para publicarlo hace falta antes la versión tarjada. */
+  needsRedacted: boolean;
+  redactedFileName: string | null;
+  /** RUN, correos y teléfonos que se reconocen en el texto del original (`null` si no tiene texto): ayudan a tarjar. */
+  personalData: PersonalDataHintsEntity | null;
+  status: TransparencyItemStatus;
+  /** Dirección de la publicación en el Portal de Transparencia, si se anotó. */
+  transparencyUrl: string | null;
+  /** Motivo de la exclusión, u observación de la publicación. */
+  transparencyNote: string | null;
+  transparencyAt: string | null;
+  transparencyByFullName: string | null;
+  /** Enlace público estable a la versión que se publica (`<TRANSPARENCY_URL>/<código>`), si está configurado. */
+  publicLink: string | null;
+}
+
+export interface TransparencyMonthCountsEntity {
+  total: number;
+  pending: number;
+  published: number;
+  excluded: number;
+  /** Publicados que después se anularon: hay que retirarlos o actualizarlos en el Portal. */
+  annulledPublished: number;
+}
+
+/** Lo firmado en un mes de los tipos documentales que se publican, con lo que falta por decidir. */
+export interface TransparencyMonthEntity {
+  year: number;
+  month: number;
+  counts: TransparencyMonthCountsEntity;
+  /** Tipos documentales marcados para Transparencia Activa. Sin ninguno, la bandeja queda vacía. */
+  documentTypes: { id: string; name: string; section: string | null }[];
+  items: TransparencyItemEntity[];
+}
+
+/** Lo que muestra la página pública de un documento publicado en Transparencia Activa. No exige sesión. */
+export interface TransparencyPublicEntity {
+  verificationCode: string;
+  documentTypeName: string;
+  issuerName: string;
+  section: string | null;
+  reference: string;
+  /** La materia solo se muestra si el original es público; si se publicó tarjado, se lee en el archivo. */
+  subject: string | null;
+  finishedAt: string | null;
+  /** Anulado después de publicarse: se informa y ya no se descarga. */
+  annulled: boolean;
+  /** Se publicó una versión tarjada (sin datos personales o reservados). */
+  redacted: boolean;
+  canDownload: boolean;
+  publishedAt: string | null;
+}

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"]
 }