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

package/dist/contracts/signatureBatch.contract.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignatureBatchPatterns = void 0;
+/** Patrones NATS de `signatureBatch` (lotes de firma): `<servicio>.<recurso>.<acción>`. */
+exports.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',
+};

package/dist/contracts/signatureCheck.contract.d.ts

@@ -0,0 +1,14 @@
+import { type PdfSignatureReportEntity } from '../entities';
+/** Patrones NATS de `signatureCheck`: revisión de las firmas electrónicas de un PDF. */
+export declare const SignatureCheckPatterns: {
+    readonly check: "gestorDocumental.signatureCheck.check";
+};
+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/dist/contracts/signatureCheck.contract.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignatureCheckPatterns = void 0;
+/** Patrones NATS de `signatureCheck`: revisión de las firmas electrónicas de un PDF. */
+exports.SignatureCheckPatterns = {
+    check: 'gestorDocumental.signatureCheck.check',
+};

package/dist/contracts/textSnippet.contract.d.ts

@@ -0,0 +1,51 @@
+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 declare const TextSnippetPatterns: {
+    readonly getAll: "gestorDocumental.textSnippet.getAll";
+    readonly getById: "gestorDocumental.textSnippet.getById";
+    readonly create: "gestorDocumental.textSnippet.create";
+    readonly update: "gestorDocumental.textSnippet.update";
+    readonly setEnabled: "gestorDocumental.textSnippet.setEnabled";
+};
+/** 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]: {
+        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/dist/contracts/textSnippet.contract.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextSnippetPatterns = void 0;
+/** Patrones NATS de `textSnippet` (biblioteca de vistos y cláusulas): `<servicio>.<recurso>.<acción>`. */
+exports.TextSnippetPatterns = {
+    getAll: 'gestorDocumental.textSnippet.getAll',
+    getById: 'gestorDocumental.textSnippet.getById',
+    create: 'gestorDocumental.textSnippet.create',
+    update: 'gestorDocumental.textSnippet.update',
+    setEnabled: 'gestorDocumental.textSnippet.setEnabled',
+};

package/dist/contracts/workFolder.contract.d.ts

@@ -0,0 +1,114 @@
+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 declare const WorkFolderPatterns: {
+    readonly getAll: "gestorDocumental.workFolder.getAll";
+    readonly getById: "gestorDocumental.workFolder.getById";
+    readonly create: "gestorDocumental.workFolder.create";
+    readonly update: "gestorDocumental.workFolder.update";
+    readonly share: "gestorDocumental.workFolder.share";
+    readonly unshare: "gestorDocumental.workFolder.unshare";
+    readonly addItem: "gestorDocumental.workFolder.addItem";
+    readonly removeItem: "gestorDocumental.workFolder.removeItem";
+    readonly remove: "gestorDocumental.workFolder.remove";
+    readonly convert: "gestorDocumental.workFolder.convert";
+};
+/** 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;
+    };
+}
+export {};

package/dist/contracts/workFolder.contract.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkFolderPatterns = void 0;
+/** Patrones NATS de `workFolder` (carpetas de trabajo): `<servicio>.<recurso>.<acción>`. */
+exports.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',
+};

package/dist/entities/archivalSeries/archivalSeries.entity.d.ts

@@ -0,0 +1,27 @@
+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'];
+    /** 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/dist/entities/archivalSeries/archivalSeries.entity.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/entities/archivalSeries/index.d.ts

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

package/dist/entities/archivalSeries/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./archivalSeries.entity"), exports);

package/dist/entities/audit/audit.entity.d.ts

@@ -0,0 +1,27 @@
+import { type AuditEntity } from '../../base/entities';
+/** De dónde sale un hecho de la auditoría. */
+export type AuditSource = 'Document' | 'DocumentAccess' | 'CaseFile' | 'CaseFileAccess' | 'Configuration';
+/**
+ * Un hecho de la auditoría, de cualquiera de los registros: trazabilidad de documentos y expedientes, accesos y
+ * cambios de configuración. `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 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. */
+    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/dist/entities/audit/audit.entity.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/entities/audit/index.d.ts

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

package/dist/entities/audit/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./audit.entity"), exports);

package/dist/entities/caseFile/caseFile.entity.d.ts

@@ -0,0 +1,300 @@
+import { CaseFileAccessEntity, CaseFileActorEntity, CaseFileEntity, CaseFileEntryEntity, CaseFileMetadataChangeEntity, CaseFileParticipantEntity, CaseFileTrackingEntity, DocumentEntity, 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 {
+    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'];
+    /** 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'];
+    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'];
+    /** 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'];
+    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;
+    /** 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'];
+}
+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'];
+    /** 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[];
+    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;
+/** 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;
+    }[];
+}

package/dist/entities/caseFile/caseFile.entity.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/entities/caseFile/index.d.ts

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

package/dist/entities/caseFile/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./caseFile.entity"), exports);