@muni-sanfer/types-gestor-documental 0.0.1-beta.4 → 0.0.1-beta.41

package/src/contracts/signatureBatch.contract.ts

@@ -0,0 +1,96 @@
+import { type DocumentAccessLevel } from '../base/entities';
+import {
+  type SignatureBatchCreateResponseEntity,
+  type SignatureBatchGetAllResponseEntity,
+  type SignatureBatchGetByIdResponseEntity,
+  type SignatureBatchRejectResponseEntity,
+  type SignatureBatchSignResponseEntity,
+  type SignatureBatchTab,
+  type SignatureBatchVisaResponseEntity,
+} from '../entities';
+import { type RpcPage } from './contract';
+import { type DocumentActor } from './document.contract';
+
+/** Patrones NATS de `signatureBatch` (lotes de firma): `<servicio>.<recurso>.<acción>`. */
+export const SignatureBatchPatterns = {
+  getAll: 'gestorDocumental.signatureBatch.getAll',
+  getById: 'gestorDocumental.signatureBatch.getById',
+  create: 'gestorDocumental.signatureBatch.create',
+  visa: 'gestorDocumental.signatureBatch.visa',
+  sign: 'gestorDocumental.signatureBatch.sign',
+  reject: 'gestorDocumental.signatureBatch.reject',
+} as const;
+
+/** Datos de quien firma, para el sello de la firma (los resuelve el gateway desde la sesión). */
+export interface SignatureBatchSigner {
+  rut: string;
+  fullName: string;
+  role: string;
+  areaName: string;
+}
+
+export interface SignatureBatchContract {
+  [SignatureBatchPatterns.getAll]: {
+    payload: {
+      pagination?: { page?: number; limit?: number };
+      filters?: { search?: string; tab?: SignatureBatchTab };
+      actor: DocumentActor;
+    };
+    response: RpcPage<SignatureBatchGetAllResponseEntity[]>;
+  };
+  /** Lo ven su redactor y quienes visan o firman sus documentos; con `viewAll`, quien lleva el registro. */
+  [SignatureBatchPatterns.getById]: {
+    payload: { id: string; actor: DocumentActor; viewAll?: boolean };
+    response: SignatureBatchGetByIdResponseEntity;
+  };
+  /**
+   * Crea el lote y lo envía a tramitación: un documento por cada PDF, todos del mismo tipo y con el mismo flujo.
+   * Cada documento recibe su código de verificación y, con su primera firma, su número (si el tipo lo lleva).
+   */
+  [SignatureBatchPatterns.create]: {
+    payload: {
+      name: string;
+      documentTypeId: string;
+      keywords: string[];
+      accessLevel?: DocumentAccessLevel;
+      hasSensitiveData?: boolean;
+      directorateCodeReference?: number | null;
+      departmentId?: string | null;
+      visaEmployeeIds?: string[];
+      // Etapa de cada visador: los de una misma etapa visan a la vez.
+      visaStages?: number[] | null;
+      signatureEmployeeIds: string[];
+      signatureSheet?: boolean;
+      documents: { subject: string; file: { fileId: string; name: string } }[];
+      actor: DocumentActor;
+    };
+    response: SignatureBatchCreateResponseEntity;
+  };
+  /** Visa de una vez los documentos del lote que el funcionario tiene en su turno de visación. */
+  [SignatureBatchPatterns.visa]: {
+    payload: { id: string; observation?: string | null; actor: DocumentActor };
+    response: SignatureBatchVisaResponseEntity;
+  };
+  /**
+   * Firma con un solo OTP los documentos del lote que el funcionario tiene en su turno de firma. FirmaGob admite 5 MB
+   * por solicitud: los que no caben quedan en `remaining`, para firmarlos con un OTP nuevo.
+   */
+  [SignatureBatchPatterns.sign]: {
+    payload: {
+      id: string;
+      observation?: string | null;
+      signer: SignatureBatchSigner;
+      otp?: string;
+      actor: DocumentActor;
+    };
+    response: SignatureBatchSignResponseEntity;
+  };
+  /**
+   * Devuelve a su redactor los documentos del lote que el funcionario tiene en su turno: todos, o los indicados en
+   * `documentIds`. Los demás siguen su curso.
+   */
+  [SignatureBatchPatterns.reject]: {
+    payload: { id: string; observation: string; documentIds?: string[]; actor: DocumentActor };
+    response: SignatureBatchRejectResponseEntity;
+  };
+}

package/src/contracts/signatureCheck.contract.ts

@@ -0,0 +1,11 @@
+import { type PdfSignatureReportEntity } from '../entities';
+
+/** Patrones NATS de `signatureCheck`: revisión de las firmas electrónicas de un PDF. */
+export const SignatureCheckPatterns = {
+  check: 'gestorDocumental.signatureCheck.check',
+} as const;
+
+export interface SignatureCheckContract {
+  /** Revisa un PDF ya subido al gestor de archivos (la herramienta «Validar firmas» lo sube antes). */
+  [SignatureCheckPatterns.check]: { payload: { fileId: string }; response: PdfSignatureReportEntity };
+}

package/src/contracts/textSnippet.contract.ts

@@ -0,0 +1,53 @@
+import { type TextSnippetEntity, type TextSnippetSection } from '../base/entities';
+import {
+  type TextSnippetCreateResponseEntity,
+  type TextSnippetGetAllResponseEntity,
+  type TextSnippetGetByIdResponseEntity,
+  type TextSnippetUpdateResponseEntity,
+} from '../entities';
+import { type RpcPage } from './contract';
+
+/** Patrones NATS de `textSnippet` (biblioteca de vistos y cláusulas): `<servicio>.<recurso>.<acción>`. */
+export const TextSnippetPatterns = {
+  getAll: 'gestorDocumental.textSnippet.getAll',
+  getById: 'gestorDocumental.textSnippet.getById',
+  create: 'gestorDocumental.textSnippet.create',
+  update: 'gestorDocumental.textSnippet.update',
+  setEnabled: 'gestorDocumental.textSnippet.setEnabled',
+} as const;
+
+/** Datos de un texto de la biblioteca al crearlo o editarlo. */
+export interface TextSnippetWritePayload {
+  title: string;
+  text: string;
+  section: TextSnippetSection;
+  keywords?: string[];
+  enabled?: boolean;
+}
+
+export interface TextSnippetContract {
+  [TextSnippetPatterns.getAll]: {
+    // sin `page` y `limit` responde todas en una sola página
+    payload: {
+      pagination?: { page?: number; limit?: number };
+      filters?: { search?: string; enabled?: boolean; section?: TextSnippetSection };
+    };
+    response: RpcPage<TextSnippetGetAllResponseEntity[]>;
+  };
+  [TextSnippetPatterns.getById]: {
+    payload: Pick<TextSnippetEntity, 'id'>;
+    response: TextSnippetGetByIdResponseEntity;
+  };
+  [TextSnippetPatterns.create]: {
+    payload: TextSnippetWritePayload;
+    response: TextSnippetCreateResponseEntity;
+  };
+  [TextSnippetPatterns.update]: {
+    payload: TextSnippetWritePayload & Pick<TextSnippetEntity, 'id'>;
+    response: TextSnippetUpdateResponseEntity;
+  };
+  [TextSnippetPatterns.setEnabled]: {
+    payload: Pick<TextSnippetEntity, 'id' | 'enabled'>;
+    response: TextSnippetUpdateResponseEntity;
+  };
+}

package/src/contracts/transparency.contract.ts

@@ -0,0 +1,55 @@
+import {
+  type DocumentPublicFileResponseEntity,
+  type IndicatorsFileEntity,
+  type TransparencyItemEntity,
+  type TransparencyItemStatus,
+  type TransparencyMonthEntity,
+  type TransparencyPublicEntity,
+} from '../entities';
+
+/** Patrones NATS de `transparency`: Transparencia Activa de los documentos firmados (Ley 20.285, art. 7°). */
+export const TransparencyPatterns = {
+  getMonth: 'gestorDocumental.transparency.getMonth',
+  update: 'gestorDocumental.transparency.update',
+  export: 'gestorDocumental.transparency.export',
+  getRedactedFile: 'gestorDocumental.transparency.getRedactedFile',
+  getPublic: 'gestorDocumental.transparency.getPublic',
+  getPublicFile: 'gestorDocumental.transparency.getPublicFile',
+} as const;
+
+type TTransparencyActor = { employeeId: string; fullName: string };
+
+/** Lo que se decide sobre un documento en Transparencia Activa. */
+export type TransparencyUpdatePayload =
+  /** Publicarlo (o corregir el enlace): si el original no es público, exige antes la versión tarjada. */
+  | { action: 'publish'; documentId: string; url?: string | null; note?: string | null; actor: TTransparencyActor }
+  /** No se publica, con su motivo (p. ej. reservado por el art. 21 de la Ley 20.285). */
+  | { action: 'exclude'; documentId: string; reason: string; actor: TTransparencyActor }
+  /** Vuelve a pendiente: se retiró la publicación o se revisó la exclusión. */
+  | { action: 'withdraw'; documentId: string; reason: string; actor: TTransparencyActor }
+  /** Versión tarjada ya subida al gestor de archivos (PDF). */
+  | { action: 'setRedacted'; documentId: string; fileId: string; fileName: string; actor: TTransparencyActor }
+  | { action: 'removeRedacted'; documentId: string; actor: TTransparencyActor };
+
+export interface TransparencyContract {
+  /** Lo firmado en el mes (hora de Chile) de los tipos que se publican, y lo que ya se publicó aunque el tipo cambie. */
+  [TransparencyPatterns.getMonth]: {
+    payload: { year: number; month: number; status?: TransparencyItemStatus | null };
+    response: TransparencyMonthEntity;
+  };
+  [TransparencyPatterns.update]: { payload: TransparencyUpdatePayload; response: TransparencyItemEntity };
+  /** Planilla del mes (Excel) para cargar en el Portal de Transparencia. */
+  [TransparencyPatterns.export]: {
+    payload: { year: number; month: number; generatedBy: string };
+    response: IndicatorsFileEntity;
+  };
+  /** La versión tarjada cargada, para revisarla antes de publicar. */
+  [TransparencyPatterns.getRedactedFile]: {
+    payload: { documentId: string };
+    response: DocumentPublicFileResponseEntity;
+  };
+  /** Página pública de un documento publicado, por su código de verificación. No exige sesión. */
+  [TransparencyPatterns.getPublic]: { payload: { code: string }; response: TransparencyPublicEntity };
+  /** La versión publicada: la tarjada si existe; si no, el original público. Solo de un documento vigente. */
+  [TransparencyPatterns.getPublicFile]: { payload: { code: string }; response: DocumentPublicFileResponseEntity };
+}

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/accessRequest/accessRequest.entity.ts

@@ -0,0 +1,78 @@
+import {
+  type AccessRequestChannel,
+  type AccessRequestEventAction,
+  type AccessRequestResolution,
+  type AccessRequestStatus,
+} from '../../base/entities';
+
+/** Semáforo del plazo de respuesta: a tiempo, por vencer (2 días hábiles o menos) o vencido. */
+export type AccessRequestDueStatus = 'OnTime' | 'DueSoon' | 'Overdue';
+
+export interface AccessRequestListItemEntity {
+  id: string;
+  /** «N° 15/2026». */
+  label: string;
+  externalFolio: string | null;
+  channel: AccessRequestChannel;
+  requesterName: string;
+  requestText: string;
+  receivedAt: string;
+  dueAt: string;
+  status: AccessRequestStatus;
+  resolution: AccessRequestResolution | null;
+  assigneeFullName: string | null;
+  /** Solo mientras está abierta. */
+  dueStatus: AccessRequestDueStatus | null;
+  businessDaysLeft: number | null;
+  /** Ya resuelta: si se respondió dentro del plazo. */
+  resolvedOnTime: boolean | null;
+}
+
+export interface AccessRequestDocumentLinkEntity {
+  id: string;
+  folio: string | null;
+  subject: string;
+}
+
+export interface AccessRequestDetailEntity extends AccessRequestListItemEntity {
+  year: number;
+  number: number;
+  requesterEmail: string | null;
+  requesterAddress: string | null;
+  deliveryFormat: string | null;
+  correctionRequestedAt: string | null;
+  correctionDueAt: string | null;
+  correctedAt: string | null;
+  extendedAt: string | null;
+  extensionNote: string | null;
+  assigneeEmployeeId: string | null;
+  thirdPartyNotifiedAt: string | null;
+  oppositionDueAt: string | null;
+  thirdPartyOpposed: boolean | null;
+  resolvedAt: string | null;
+  denialGrounds: string[];
+  derivedTo: string | null;
+  resolutionNote: string | null;
+  responseDocument: AccessRequestDocumentLinkEntity | null;
+  documents: AccessRequestDocumentLinkEntity[];
+  appealedAt: string | null;
+  appealNote: string | null;
+  createdByFullName: string;
+  /** Se puede prorrogar: abierta, sin prórroga y antes de vencer. */
+  canExtend: boolean;
+  events: { action: AccessRequestEventAction; note: string | null; employeeFullName: string; createdAt: string }[];
+}
+
+export interface AccessRequestSummaryEntity {
+  year: number;
+  total: number;
+  open: number;
+  overdue: number;
+  dueSoon: number;
+  resolved: Record<AccessRequestResolution, number>;
+  /** Respondidas dentro del plazo sobre las respondidas, en %. */
+  onTimeRate: number | null;
+  /** Días hábiles promedio entre el ingreso (o la subsanación) y la respuesta. */
+  averageBusinessDays: number | null;
+  appealed: number;
+}

package/src/entities/accessRequest/index.ts

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

package/src/entities/archivalSeries/archivalSeries.entity.ts

@@ -0,0 +1,37 @@
+import { ArchivalSeriesEntity } from '../../base/entities';
+
+export interface ArchivalSeriesGetAllResponseEntity {
+  id: ArchivalSeriesEntity['id'];
+  code: ArchivalSeriesEntity['code'];
+  name: ArchivalSeriesEntity['name'];
+  section: ArchivalSeriesEntity['section'];
+  description: ArchivalSeriesEntity['description'];
+  enabled: ArchivalSeriesEntity['enabled'];
+  /** Tabla de Retención Documental: años en archivo de gestión y central, y qué se hace después. */
+  managementYears: ArchivalSeriesEntity['managementYears'];
+  centralYears: ArchivalSeriesEntity['centralYears'];
+  finalDisposition: ArchivalSeriesEntity['finalDisposition'];
+  retentionNote: ArchivalSeriesEntity['retentionNote'];
+  /** Cuántos tipos documentales y expedientes la usan. */
+  documentTypes: number;
+  caseFiles: number;
+}
+
+export type ArchivalSeriesGetByIdResponseEntity = ArchivalSeriesGetAllResponseEntity;
+
+/** Cómo se cita una serie donde se usa: código y nombre. */
+export interface ArchivalSeriesSummaryEntity {
+  id: string;
+  code: string;
+  name: string;
+}
+
+export interface ArchivalSeriesCreateResponseEntity {
+  id: ArchivalSeriesEntity['id'];
+  ok: boolean;
+}
+
+export interface ArchivalSeriesUpdateResponseEntity {
+  id: ArchivalSeriesEntity['id'];
+  ok: boolean;
+}

package/src/entities/archivalSeries/index.ts

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

package/src/entities/audit/audit.entity.ts

@@ -0,0 +1,41 @@
+import { type AuditEntity } from '../../base/entities';
+
+/** De dónde sale un hecho de la auditoría. */
+export type AuditSource =
+  | 'Document'
+  | 'DocumentAccess'
+  | 'CaseFile'
+  | 'CaseFileAccess'
+  | 'Configuration'
+  | 'AccessRequest'
+  | 'DataRights'
+  | 'DataBreach';
+
+/**
+ * Un hecho de la auditoría, de cualquiera de los registros: trazabilidad de documentos y expedientes, accesos,
+ * cambios de configuración y la tramitación de solicitudes de acceso, de datos personales y de vulneraciones. `action` es la acción del registro de origen (p. ej. `Signed`, `Viewed`, `Updated`).
+ */
+export interface AuditEventEntity {
+  id: string;
+  source: AuditSource;
+  action: string;
+  employeeId: string | null;
+  employeeFullName: string | null;
+  /** Documento, expediente, solicitud, vulneración o elemento de configuración al que se refiere. */
+  targetId: string | null;
+  /**
+   * Cómo se cita: folio o materia del documento, IUIe y título del expediente, nombre de lo configurado o número de la
+   * solicitud o vulneración (sin el nombre del titular).
+   */
+  reference: string;
+  /** Qué se configuró, en los cambios de configuración. */
+  entity: AuditEntity | null;
+  observation: string | null;
+  createdAt: string;
+}
+
+/** Quién hace un cambio de configuración, según la sesión. Lo agrega el gateway; el ms lo deja en la bitácora. */
+export interface AuditActorInput {
+  employeeId: string | null;
+  fullName: string;
+}

package/src/entities/audit/index.ts

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

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

@@ -10,6 +10,7 @@ import {
   ProcedureEntity,
 } from '../../base/entities';
 import { DocumentTypeSummaryEntity } from '../document';
+import { type PdfSignatureReportEntity } from '../signatureCheck';
 
 /** Expediente al que se hace referencia desde otro lado: cómo se cita y en qué estado está. */
 export interface CaseFileLinkEntity {
@@ -41,12 +42,20 @@ export interface CaseFileEntryDocumentEntity {
   correlative: DocumentEntity['correlative'];
   correlativeYear: DocumentEntity['correlativeYear'];
   documentType: DocumentTypeSummaryEntity;
+  /** N° del documento en DocDigital, si se despachó o se recibió por ahí: tiene comprobante de trazabilidad. */
+  docDigitalDocumentId: string | null;
 }
 
 /** Entrada del índice electrónico: una actuación, en su orden de incorporación. */
 export interface CaseFileEntryResponseEntity {
   id: CaseFileEntryEntity['id'];
   sequence: CaseFileEntryEntity['sequence'];
+  /** Subcarpeta del índice (sin valor: en la raíz). */
+  folder: CaseFileEntryEntity['folder'];
+  /** Documento en papel: dónde está, por qué no se digitalizó y cuántas páginas tiene. */
+  physicalLocation: CaseFileEntryEntity['physicalLocation'];
+  physicalReason: CaseFileEntryEntity['physicalReason'];
+  pageCount: CaseFileEntryEntity['pageCount'];
   kind: CaseFileEntryEntity['kind'];
   actuationType: CaseFileEntryEntity['actuationType'];
   title: CaseFileEntryEntity['title'];
@@ -64,6 +73,10 @@ export interface CaseFileEntryResponseEntity {
   sha256: CaseFileEntryEntity['sha256'];
   size: CaseFileEntryEntity['size'];
   hasAdvancedSignature: CaseFileEntryEntity['hasAdvancedSignature'];
+  /** Conformidad PDF/A que declara el archivo («PDF/A-2B»), «PDF», o `null` si no es un PDF o no se revisó. */
+  fileFormat: CaseFileEntryEntity['fileFormat'];
+  /** Revisión de sus firmas al incorporarlo, en los archivos externos en PDF. */
+  signatureCheck: PdfSignatureReportEntity | null;
   incorporatedByEmployeeId: CaseFileEntryEntity['incorporatedByEmployeeId'];
   incorporatedByFullName: CaseFileEntryEntity['incorporatedByFullName'];
   createdAt: CaseFileEntryEntity['createdAt'];
@@ -115,7 +128,10 @@ export interface CaseFileAccessResponseEntity {
   entryId: CaseFileAccessEntity['entryId'];
   /** Título del documento que se abrió, si el acceso fue a uno. */
   entryTitle: string | null;
+  /** El funcionario o, si fue por un enlace temporal, su destinatario externo. */
   employeeFullName: CaseFileAccessEntity['employeeFullName'];
+  /** Fue por un enlace temporal, sin sesión. */
+  external: boolean;
   createdAt: CaseFileAccessEntity['createdAt'];
 }
 
@@ -129,6 +145,12 @@ export interface CaseFileGetByIdResponseEntity extends CaseFileGetAllResponseEnt
   uri: string | null;
   closedByFullName: CaseFileEntity['closedByFullName'];
   closingNote: CaseFileEntity['closingNote'];
+  /** Expediente híbrido: tiene documentos en papel que no se pudieron digitalizar. */
+  isHybrid: boolean;
+  /** MGDEE1_2: serie del Cuadro de Clasificación. */
+  archivalSeries: { id: string; code: string; name: string } | null;
+  /** MGDEE8_2: fin de la restricción de acceso. */
+  restrictionEndsAt: string | null;
   index: CaseFileEntryResponseEntity[];
   sharedWith: CaseFileParticipantResponseEntity[];
   actors: CaseFileActorResponseEntity[];
@@ -159,6 +181,14 @@ export interface CaseFileUpdateResponseEntity {
   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'];
@@ -194,3 +224,105 @@ export interface CaseFileExportResponseEntity {
 
 /** Expediente en que está incorporado un documento, visto desde el documento. */
 export type DocumentCaseFileEntity = CaseFileLinkEntity;
+
+/** Estado de un enlace temporal: vigente, vencido o revocado. */
+export type CaseFileShareLinkStatus = 'Active' | 'Expired' | 'Revoked';
+
+/** Enlace temporal de un expediente, como lo ve su responsable. El token no se vuelve a mostrar. */
+export interface CaseFileShareLinkResponseEntity {
+  id: string;
+  recipient: string;
+  recipientEmail: string | null;
+  purpose: string | null;
+  allowExport: boolean;
+  expiresAt: string;
+  status: CaseFileShareLinkStatus;
+  createdByFullName: string;
+  createdAt: string;
+  revokedAt: string | null;
+  revokedByFullName: string | null;
+  /** Cuántas consultas, descargas y exportaciones se hicieron con él. */
+  accessCount: number;
+  lastAccessAt: string | null;
+}
+
+/** Enlace recién creado: el token va solo aquí; la dirección la arma quien lo muestra. */
+export interface CaseFileShareLinkCreateResponseEntity {
+  id: string;
+  token: string;
+  recipient: string;
+  recipientEmail: string | null;
+  purpose: string | null;
+  expiresAt: string;
+  /** Para avisarle al destinatario: qué expediente, de qué órgano y quién se lo comparte. */
+  caseFile: { code: string; title: string };
+  organName: string;
+  createdByFullName: string;
+}
+
+/** Actuación del índice como la ve el destinatario externo. */
+export interface CaseFileSharedEntryEntity {
+  id: string;
+  sequence: number;
+  folder: string | null;
+  kind: CaseFileEntryEntity['kind'];
+  actuationType: CaseFileEntryEntity['actuationType'];
+  title: string;
+  /** Tipo y número del documento («D.E. N° 590/2026») o el tipo declarado del archivo. */
+  reference: string | null;
+  originDate: string | null;
+  createdAt: string;
+  hasFile: boolean;
+  sha256: string | null;
+  hasAdvancedSignature: boolean;
+  physicalLocation: string | null;
+  pageCount: number | null;
+  voidedAt: string | null;
+  voidReason: string | null;
+}
+
+/** Expediente abierto con un enlace temporal: metadatos e índice, sin participantes ni registros internos. */
+export interface CaseFileSharedResponseEntity {
+  code: string;
+  title: string;
+  subject: string;
+  summary: string | null;
+  procedureName: string;
+  status: CaseFileEntity['status'];
+  organName: string;
+  responsibleFullName: string;
+  responsiblePosition: string | null;
+  createdAt: string;
+  closedAt: string | null;
+  recipient: string;
+  purpose: string | null;
+  expiresAt: string;
+  allowExport: boolean;
+  entries: CaseFileSharedEntryEntity[];
+}
+
+/** Resultado de una actuación al verificar un ZIP exportado. */
+export type CaseFileVerifyEntryResult =
+  /** La huella coincide con la registrada al incorporarla. */
+  | 'Match'
+  /** La huella no coincide: el archivo cambió. */
+  | 'Altered'
+  /** El ZIP trae una actuación con esa secuencia que el expediente no tiene. */
+  | 'NotInRegistry'
+  /** El expediente tiene esa actuación con archivo, pero el ZIP no la trae. */
+  | 'Missing'
+  /** La actuación no tiene huella registrada (incorporada antes de que se guardaran). */
+  | 'NoFingerprint';
+
+export interface CaseFileVerifyExportResponseEntity {
+  code: string;
+  status: CaseFileEntity['status'];
+  closedAt: string | null;
+  /** Solo si el expediente es público y sin datos sensibles. */
+  title: string | null;
+  /** Cuántas actuaciones con archivo tiene el expediente registradas. */
+  registeredFiles: number;
+  /** `true` si todo lo registrado está en el ZIP y todo coincide. */
+  intact: boolean;
+  entries: { sequence: number; result: CaseFileVerifyEntryResult; voided: boolean }[];
+}