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

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

@@ -0,0 +1,169 @@
+import { CaseFileAccessEntity, CaseFileActorEntity, CaseFileEntity, CaseFileEntryEntity, CaseFileMetadataChangeEntity, CaseFileParticipantEntity, CaseFileTrackingEntity, DocumentEntity, ProcedureEntity } from '../../base/entities';
+import { DocumentTypeSummaryEntity } from '../document';
+/** 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'];
+    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'];
+    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;
+    employeeFullName: CaseFileAccessEntity['employeeFullName'];
+    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'];
+    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;
+}
+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;

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

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

@@ -116,6 +116,13 @@ export interface DocumentGetByIdResponseEntity {
     deliveries: DocumentDeliveryResponseEntity[];
     replyTo: DocumentLinkEntity | null;
     replies: DocumentLinkEntity[];
+    /** Expedientes en que está incorporado y que quien consulta puede ver. */
+    caseFiles: {
+        id: string;
+        code: string;
+        title: string;
+        status: 'Open' | 'Closed';
+    }[];
     documentType: DocumentTypeSummaryEntity;
     participants: DocumentParticipantResponseEntity[];
     attachments: {

package/dist/entities/index.d.ts

@@ -1,2 +1,4 @@
 export * from './documentType';
 export * from './document';
+export * from './procedure';
+export * from './caseFile';

package/dist/entities/index.js

@@ -16,3 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./documentType"), exports);
 __exportStar(require("./document"), exports);
+__exportStar(require("./procedure"), exports);
+__exportStar(require("./caseFile"), exports);

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

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

package/dist/entities/procedure/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("./procedure.entity"), exports);

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

@@ -0,0 +1,20 @@
+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/dist/entities/procedure/procedure.entity.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@muni-sanfer/types-gestor-documental",
-  "version": "0.0.1-beta.3",
+  "version": "0.0.1-beta.4",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {

package/src/base/entities.ts

@@ -117,6 +117,101 @@ export const DocumentInstruction = {
   Archive: 'Archive',
 } satisfies Record<string, DocumentInstruction>;
 
+export type CaseFileStatus = 'Open' | 'Closed';
+
+export const CaseFileStatus = {
+  Open: 'Open',
+  Closed: 'Closed',
+} satisfies Record<string, CaseFileStatus>;
+
+export type CaseFileIncorporationMechanism =
+  'Manual' | 'WebService' | 'Mixed' | 'CitizenRepository' | 'Interoperability';
+
+export const CaseFileIncorporationMechanism = {
+  Manual: 'Manual',
+  WebService: 'WebService',
+  Mixed: 'Mixed',
+  CitizenRepository: 'CitizenRepository',
+  Interoperability: 'Interoperability',
+} satisfies Record<string, CaseFileIncorporationMechanism>;
+
+export type CaseFileActuationType =
+  | 'AdministrativeAct'
+  | 'Notification'
+  | 'OfficialCommunication'
+  | 'Interoperability'
+  | 'RequestReception'
+  | 'Subfolder'
+  | 'PowerRegistration';
+
+export const CaseFileActuationType = {
+  AdministrativeAct: 'AdministrativeAct',
+  Notification: 'Notification',
+  OfficialCommunication: 'OfficialCommunication',
+  Interoperability: 'Interoperability',
+  RequestReception: 'RequestReception',
+  Subfolder: 'Subfolder',
+  PowerRegistration: 'PowerRegistration',
+} satisfies Record<string, CaseFileActuationType>;
+
+export type CaseFileEntryKind = 'Document' | 'File' | 'CaseFile';
+
+export const CaseFileEntryKind = {
+  Document: 'Document',
+  File: 'File',
+  CaseFile: 'CaseFile',
+} satisfies Record<string, CaseFileEntryKind>;
+
+export type CaseFileActorRelation =
+  'Responsible' | 'Interested' | 'Author' | 'Referred' | 'Recipient' | 'MinisterOfFaith';
+
+export const CaseFileActorRelation = {
+  Responsible: 'Responsible',
+  Interested: 'Interested',
+  Author: 'Author',
+  Referred: 'Referred',
+  Recipient: 'Recipient',
+  MinisterOfFaith: 'MinisterOfFaith',
+} satisfies Record<string, CaseFileActorRelation>;
+
+export type CaseFileActorType = 'Citizen' | 'Foreigner' | 'PrivateInstitution' | 'Official';
+
+export const CaseFileActorType = {
+  Citizen: 'Citizen',
+  Foreigner: 'Foreigner',
+  PrivateInstitution: 'PrivateInstitution',
+  Official: 'Official',
+} satisfies Record<string, CaseFileActorType>;
+
+export type CaseFileTrackingAction =
+  | 'Created'
+  | 'Updated'
+  | 'EntryAdded'
+  | 'EntryVoided'
+  | 'ParticipantAdded'
+  | 'ParticipantRemoved'
+  | 'Closed'
+  | 'Exported';
+
+export const CaseFileTrackingAction = {
+  Created: 'Created',
+  Updated: 'Updated',
+  EntryAdded: 'EntryAdded',
+  EntryVoided: 'EntryVoided',
+  ParticipantAdded: 'ParticipantAdded',
+  ParticipantRemoved: 'ParticipantRemoved',
+  Closed: 'Closed',
+  Exported: 'Exported',
+} satisfies Record<string, CaseFileTrackingAction>;
+
+export type CaseFileAccessAction = 'Viewed' | 'FileDownloaded' | 'Exported';
+
+export const CaseFileAccessAction = {
+  Viewed: 'Viewed',
+  FileDownloaded: 'FileDownloaded',
+  Exported: 'Exported',
+} satisfies Record<string, CaseFileAccessAction>;
+
 export interface DocumentTypeEntity {
   id: string;
   name: string;
@@ -172,6 +267,7 @@ export interface DocumentEntity {
   annulledNumbers?: DocumentAnnulledNumberEntity[];
   recipients?: DocumentRecipientEntity[];
   deliveries?: DocumentDeliveryEntity[];
+  caseFileEntries?: CaseFileEntryEntity[];
   deleted: boolean;
   createdAt: string;
   updatedAt: string;
@@ -278,3 +374,143 @@ export interface DocumentTypeFlowStepEntity {
   documentTypeId: string;
   createdAt: string;
 }
+
+export interface ProcedureEntity {
+  id: string;
+  name: string;
+  cpatId?: string | null;
+  cpatCode?: string | null;
+  description?: string | null;
+  enabled: boolean;
+  caseFiles?: CaseFileEntity[];
+  deleted: boolean;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface CaseFileSequenceEntity {
+  year: number;
+  next: number;
+}
+
+export interface CaseFileEntity {
+  id: string;
+  code: string;
+  year: number;
+  number: number;
+  title: string;
+  subject: string;
+  summary?: string | null;
+  status: CaseFileStatus;
+  accessLevel: DocumentAccessLevel;
+  hasSensitiveData: boolean;
+  incorporationMechanism: CaseFileIncorporationMechanism;
+  schemaVersion: string;
+  procedure?: ProcedureEntity;
+  procedureId: string;
+  responsibleEmployeeId: string;
+  responsibleFullName: string;
+  responsiblePosition?: string | null;
+  closedAt?: string | null;
+  closedByEmployeeId?: string | null;
+  closedByFullName?: string | null;
+  closingNote?: string | null;
+  participants?: CaseFileParticipantEntity[];
+  actors?: CaseFileActorEntity[];
+  entries?: CaseFileEntryEntity[];
+  linkedFrom?: CaseFileEntryEntity[];
+  trackings?: CaseFileTrackingEntity[];
+  metadataChanges?: CaseFileMetadataChangeEntity[];
+  accesses?: CaseFileAccessEntity[];
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface CaseFileParticipantEntity {
+  id: string;
+  employeeId: string;
+  fullName: string;
+  position?: string | null;
+  addedByEmployeeId: string;
+  addedByFullName: string;
+  caseFile?: CaseFileEntity;
+  caseFileId: string;
+  createdAt: string;
+}
+
+export interface CaseFileActorEntity {
+  id: string;
+  relation: CaseFileActorRelation;
+  actorType: CaseFileActorType;
+  identifier?: string | null;
+  name: string;
+  caseFile?: CaseFileEntity;
+  caseFileId: string;
+  createdAt: string;
+}
+
+export interface CaseFileEntryEntity {
+  id: string;
+  sequence: number;
+  kind: CaseFileEntryKind;
+  actuationType: CaseFileActuationType;
+  title: string;
+  document?: DocumentEntity | null;
+  documentId?: string | null;
+  fileId?: string | null;
+  fileName?: string | null;
+  documentTypeName?: string | null;
+  originDate?: string | null;
+  author?: string | null;
+  keywords: string[];
+  accessLevel?: DocumentAccessLevel | null;
+  hasSensitiveData?: boolean | null;
+  linkedCaseFile?: CaseFileEntity | null;
+  linkedCaseFileId?: string | null;
+  sha256?: string | null;
+  size?: number | null;
+  hasAdvancedSignature: boolean;
+  incorporatedByEmployeeId: string;
+  incorporatedByFullName: string;
+  voidedAt?: string | null;
+  voidedByEmployeeId?: string | null;
+  voidedByFullName?: string | null;
+  voidReason?: string | null;
+  caseFile?: CaseFileEntity;
+  caseFileId: string;
+  createdAt: string;
+}
+
+export interface CaseFileTrackingEntity {
+  id: string;
+  action: CaseFileTrackingAction;
+  observation?: string | null;
+  employeeId?: string | null;
+  employeeFullName?: string | null;
+  caseFile?: CaseFileEntity;
+  caseFileId: string;
+  createdAt: string;
+}
+
+export interface CaseFileMetadataChangeEntity {
+  id: string;
+  field: string;
+  previousValue?: string | null;
+  newValue?: string | null;
+  employeeId: string;
+  employeeFullName: string;
+  caseFile?: CaseFileEntity;
+  caseFileId: string;
+  createdAt: string;
+}
+
+export interface CaseFileAccessEntity {
+  id: string;
+  action: CaseFileAccessAction;
+  entryId?: string | null;
+  employeeId: string;
+  employeeFullName: string;
+  caseFile?: CaseFileEntity;
+  caseFileId: string;
+  createdAt: string;
+}

package/src/contracts/caseFile.contract.ts

@@ -0,0 +1,134 @@
+import {
+  type CaseFileActorRelation,
+  type CaseFileActorType,
+  type CaseFileActuationType,
+  type CaseFileEntity,
+  type CaseFileStatus,
+  type DocumentAccessLevel,
+} from '../base/entities';
+import {
+  type CaseFileAddEntryResponseEntity,
+  type CaseFileCreateResponseEntity,
+  type CaseFileEntryFileResponseEntity,
+  type CaseFileExportResponseEntity,
+  type CaseFileGetAllResponseEntity,
+  type CaseFileGetByIdResponseEntity,
+  type CaseFileUpdateResponseEntity,
+} from '../entities';
+import { type RpcPage } from './contract';
+import { type DocumentActor } from './document.contract';
+
+/** Patrones NATS de `caseFile`: `<servicio>.<recurso>.<acción>`. */
+export const CaseFilePatterns = {
+  getAll: 'gestorDocumental.caseFile.getAll',
+  getById: 'gestorDocumental.caseFile.getById',
+  create: 'gestorDocumental.caseFile.create',
+  update: 'gestorDocumental.caseFile.update',
+  addEntry: 'gestorDocumental.caseFile.addEntry',
+  voidEntry: 'gestorDocumental.caseFile.voidEntry',
+  share: 'gestorDocumental.caseFile.share',
+  unshare: 'gestorDocumental.caseFile.unshare',
+  close: 'gestorDocumental.caseFile.close',
+  getEntryFile: 'gestorDocumental.caseFile.getEntryFile',
+  getExport: 'gestorDocumental.caseFile.getExport',
+} as const;
+
+/** Persona u organización relacionada con el expediente (MGDEE54). */
+export interface CaseFileActorInput {
+  relation: CaseFileActorRelation;
+  actorType: CaseFileActorType;
+  identifier?: string | null;
+  name: string;
+}
+
+/** Metadatos del expediente que se ingresan a mano. */
+export interface CaseFileWritePayload {
+  title: string;
+  subject: string;
+  summary?: string | null;
+  procedureId: string;
+  accessLevel: DocumentAccessLevel;
+  hasSensitiveData: boolean;
+  actors?: CaseFileActorInput[];
+}
+
+/** Actuación que se incorpora al índice: un documento del gestor, un archivo subido u otro expediente. */
+export type CaseFileEntryInput =
+  | { kind: 'Document'; actuationType: CaseFileActuationType; documentId: string }
+  | {
+      kind: 'File';
+      actuationType: CaseFileActuationType;
+      fileId: string;
+      fileName: string;
+      title: string;
+      documentTypeName?: string | null;
+      originDate?: string | null;
+      author?: string | null;
+      keywords: string[];
+      accessLevel: DocumentAccessLevel;
+      hasSensitiveData: boolean;
+    }
+  | { kind: 'CaseFile'; actuationType: CaseFileActuationType; linkedCaseFileId: string };
+
+/** Quién hace la operación (de la sesión) y si puede ver todos los expedientes. */
+interface CaseFileActorPayload {
+  actor: DocumentActor;
+  viewAll?: boolean;
+}
+
+/** Ámbito del listado: los expedientes del funcionario (responsable o compartidos con él) o todos. */
+export type CaseFileScope = 'mine' | 'all';
+
+export interface CaseFileContract {
+  [CaseFilePatterns.getAll]: {
+    payload: {
+      pagination?: { page?: number; limit?: number };
+      filters?: { search?: string; status?: CaseFileStatus; procedureId?: string; scope?: CaseFileScope };
+    } & CaseFileActorPayload;
+    response: RpcPage<CaseFileGetAllResponseEntity[]>;
+  };
+  /** Por id o por su identificador (`EXP-2026-00001`), que es el del enlace persistente. Queda en el registro de accesos. */
+  [CaseFilePatterns.getById]: {
+    payload: { id: string } & CaseFileActorPayload;
+    response: CaseFileGetByIdResponseEntity;
+  };
+  [CaseFilePatterns.create]: {
+    payload: CaseFileWritePayload & { actor: DocumentActor };
+    response: CaseFileCreateResponseEntity;
+  };
+  [CaseFilePatterns.update]: {
+    payload: CaseFileWritePayload & Pick<CaseFileEntity, 'id'> & { actor: DocumentActor };
+    response: CaseFileUpdateResponseEntity;
+  };
+  [CaseFilePatterns.addEntry]: {
+    payload: Pick<CaseFileEntity, 'id'> & { entry: CaseFileEntryInput } & CaseFileActorPayload;
+    response: CaseFileAddEntryResponseEntity;
+  };
+  /** Deja una actuación sin efecto, con su motivo. No se elimina del índice. */
+  [CaseFilePatterns.voidEntry]: {
+    payload: Pick<CaseFileEntity, 'id'> & { entryId: string; reason: string; actor: DocumentActor };
+    response: CaseFileUpdateResponseEntity;
+  };
+  [CaseFilePatterns.share]: {
+    payload: Pick<CaseFileEntity, 'id'> & { employeeIds: string[]; actor: DocumentActor };
+    response: CaseFileUpdateResponseEntity;
+  };
+  [CaseFilePatterns.unshare]: {
+    payload: Pick<CaseFileEntity, 'id'> & { participantId: string; actor: DocumentActor };
+    response: CaseFileUpdateResponseEntity;
+  };
+  [CaseFilePatterns.close]: {
+    payload: Pick<CaseFileEntity, 'id'> & { note?: string | null; actor: DocumentActor };
+    response: CaseFileUpdateResponseEntity;
+  };
+  /** Archivo de una actuación del índice. Queda en el registro de accesos. */
+  [CaseFilePatterns.getEntryFile]: {
+    payload: Pick<CaseFileEntity, 'id'> & { entryId: string } & CaseFileActorPayload;
+    response: CaseFileEntryFileResponseEntity;
+  };
+  /** Metadatos y archivos para exportar el expediente completo. Queda en la trazabilidad y en el registro de accesos. */
+  [CaseFilePatterns.getExport]: {
+    payload: Pick<CaseFileEntity, 'id'> & CaseFileActorPayload;
+    response: CaseFileExportResponseEntity;
+  };
+}