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

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

@@ -0,0 +1,57 @@
+import { type RepositoryExportCaseFilesPageEntity, type RepositoryExportRecordResponseEntity, type RepositoryExportDocumentsPageEntity, type RepositoryExportScope, type RepositoryExportSummaryEntity } from '../entities';
+/**
+ * Patrones NATS de `repositoryExport`: exportación completa del repositorio (portabilidad). El ms entrega los datos
+ * por páginas, porque un mensaje NATS no admite más de 1 MB; el gateway arma el ZIP con ellos y los archivos.
+ */
+export declare const RepositoryExportPatterns: {
+    readonly getSummary: "gestorDocumental.repositoryExport.getSummary";
+    readonly getDocuments: "gestorDocumental.repositoryExport.getDocuments";
+    readonly getCaseFiles: "gestorDocumental.repositoryExport.getCaseFiles";
+    readonly record: "gestorDocumental.repositoryExport.record";
+};
+/** Período por fecha de creación (días de Chile «AAAA-MM-DD»); sin él, todo. */
+export interface RepositoryExportQuery {
+    from?: string | null;
+    to?: string | null;
+    scope?: RepositoryExportScope;
+    /** Solo lo incluido en un acta de transferencia: el paquete para el Archivo Nacional. */
+    dispositionId?: string | null;
+}
+export interface RepositoryExportContract {
+    [RepositoryExportPatterns.getSummary]: {
+        payload: RepositoryExportQuery;
+        response: RepositoryExportSummaryEntity;
+    };
+    /** Hasta 50 documentos por página, en orden de creación. */
+    [RepositoryExportPatterns.getDocuments]: {
+        payload: RepositoryExportQuery & {
+            cursor?: string | null;
+            limit?: number;
+        };
+        response: RepositoryExportDocumentsPageEntity;
+    };
+    /** Hasta 10 expedientes por página; cada uno queda con «Exportó» en su trazabilidad, a nombre de quien exporta. */
+    [RepositoryExportPatterns.getCaseFiles]: {
+        payload: Omit<RepositoryExportQuery, 'scope'> & {
+            cursor?: string | null;
+            limit?: number;
+            actor: {
+                employeeId: string | null;
+                fullName: string;
+            };
+        };
+        response: RepositoryExportCaseFilesPageEntity;
+    };
+    /** Deja la exportación en la bitácora: quién, qué período y si llevó archivos. */
+    [RepositoryExportPatterns.record]: {
+        payload: RepositoryExportQuery & {
+            includeFiles: boolean;
+            complete: boolean;
+            actor: {
+                employeeId: string | null;
+                fullName: string;
+            };
+        };
+        response: RepositoryExportRecordResponseEntity;
+    };
+}

package/dist/contracts/repositoryExport.contract.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepositoryExportPatterns = void 0;
+/**
+ * Patrones NATS de `repositoryExport`: exportación completa del repositorio (portabilidad). El ms entrega los datos
+ * por páginas, porque un mensaje NATS no admite más de 1 MB; el gateway arma el ZIP con ellos y los archivos.
+ */
+exports.RepositoryExportPatterns = {
+    getSummary: 'gestorDocumental.repositoryExport.getSummary',
+    getDocuments: 'gestorDocumental.repositoryExport.getDocuments',
+    getCaseFiles: 'gestorDocumental.repositoryExport.getCaseFiles',
+    record: 'gestorDocumental.repositoryExport.record',
+};

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

@@ -0,0 +1,58 @@
+import { type DispositionKind } from '../base/entities';
+import { type DispositionRecordResponseEntity, type IndicatorsFileEntity, type RetentionDueItemEntity, type RetentionSummaryEntity } from '../entities';
+import { type RpcPage } from './contract';
+/** Patrones NATS de `retention`: plazos de retención por serie y actas de transferencia o eliminación. */
+export declare const RetentionPatterns: {
+    readonly getSummary: "gestorDocumental.retention.getSummary";
+    readonly getDueItems: "gestorDocumental.retention.getDueItems";
+    readonly createRecord: "gestorDocumental.retention.createRecord";
+    readonly getRecords: "gestorDocumental.retention.getRecords";
+    readonly getRecordPdf: "gestorDocumental.retention.getRecordPdf";
+};
+export interface RetentionContract {
+    [RetentionPatterns.getSummary]: {
+        payload: Record<string, never>;
+        response: RetentionSummaryEntity;
+    };
+    /** Lo vencido de una serie, de lo más antiguo a lo más reciente. */
+    [RetentionPatterns.getDueItems]: {
+        payload: {
+            seriesId: string;
+            page?: number;
+            limit?: number;
+        };
+        response: RpcPage<RetentionDueItemEntity[]>;
+    };
+    /**
+     * Emite el acta con lo elegido (todo debe estar vencido y sin acta). Según la serie: conservación permanente →
+     * transferencia; eliminación → eliminación; selección → cualquiera de las dos.
+     */
+    [RetentionPatterns.createRecord]: {
+        payload: {
+            kind: DispositionKind;
+            seriesId: string;
+            documentIds: string[];
+            caseFileIds: string[];
+            observation?: string | null;
+            actor: {
+                employeeId: string;
+                fullName: string;
+            };
+        };
+        response: DispositionRecordResponseEntity;
+    };
+    [RetentionPatterns.getRecords]: {
+        payload: {
+            year: number;
+        };
+        response: DispositionRecordResponseEntity[];
+    };
+    /** El acta en PDF, con lo que incluye, para firmarla y archivarla. */
+    [RetentionPatterns.getRecordPdf]: {
+        payload: {
+            id: string;
+            generatedBy: string;
+        };
+        response: IndicatorsFileEntity;
+    };
+}

package/dist/contracts/retention.contract.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetentionPatterns = void 0;
+/** Patrones NATS de `retention`: plazos de retención por serie y actas de transferencia o eliminación. */
+exports.RetentionPatterns = {
+    getSummary: 'gestorDocumental.retention.getSummary',
+    getDueItems: 'gestorDocumental.retention.getDueItems',
+    createRecord: 'gestorDocumental.retention.createRecord',
+    getRecords: 'gestorDocumental.retention.getRecords',
+    getRecordPdf: 'gestorDocumental.retention.getRecordPdf',
+};

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

@@ -0,0 +1,63 @@
+import { type ScanSessionCreateResponseEntity, type ScanSessionFileResponseEntity, type ScanSessionPublicEntity, type ScanSessionResponseEntity } from '../entities';
+import { type DocumentActor } from './document.contract';
+/** Patrones NATS de `scan`: escanear con el celular. */
+export declare const ScanPatterns: {
+    readonly create: "gestorDocumental.scan.create";
+    readonly getById: "gestorDocumental.scan.getById";
+    readonly getFile: "gestorDocumental.scan.getFile";
+    readonly getByToken: "gestorDocumental.scan.getByToken";
+    readonly addPage: "gestorDocumental.scan.addPage";
+    readonly finish: "gestorDocumental.scan.finish";
+};
+export interface ScanContract {
+    /**
+     * Abre una sesión de escaneo para el funcionario. `url` es la dirección pública del celular (sin el token): con ella
+     * se arma el QR que se muestra en el escritorio.
+     */
+    [ScanPatterns.create]: {
+        payload: {
+            url: string;
+            actor: DocumentActor;
+        };
+        response: ScanSessionCreateResponseEntity;
+    };
+    /** Estado de la sesión, para quien la abrió: el escritorio la consulta hasta que el PDF esté listo. */
+    [ScanPatterns.getById]: {
+        payload: {
+            id: string;
+            actor: DocumentActor;
+        };
+        response: ScanSessionResponseEntity;
+    };
+    [ScanPatterns.getFile]: {
+        payload: {
+            id: string;
+            actor: DocumentActor;
+        };
+        response: ScanSessionFileResponseEntity;
+    };
+    /** Sin sesión, desde el celular, con el token del QR. */
+    [ScanPatterns.getByToken]: {
+        payload: {
+            token: string;
+        };
+        response: ScanSessionPublicEntity;
+    };
+    /** Agrega una foto ya subida al gestor de archivos (la sube el gateway). */
+    [ScanPatterns.addPage]: {
+        payload: {
+            token: string;
+            fileId: string;
+            contentType: string;
+            size: number;
+        };
+        response: ScanSessionPublicEntity;
+    };
+    /** Junta las fotos en un PDF y cierra la sesión. */
+    [ScanPatterns.finish]: {
+        payload: {
+            token: string;
+        };
+        response: ScanSessionPublicEntity;
+    };
+}

package/dist/contracts/scan.contract.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScanPatterns = void 0;
+/** Patrones NATS de `scan`: escanear con el celular. */
+exports.ScanPatterns = {
+    create: 'gestorDocumental.scan.create',
+    getById: 'gestorDocumental.scan.getById',
+    getFile: 'gestorDocumental.scan.getFile',
+    getByToken: 'gestorDocumental.scan.getByToken',
+    addPage: 'gestorDocumental.scan.addPage',
+    finish: 'gestorDocumental.scan.finish',
+};

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

@@ -0,0 +1,109 @@
+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 declare const SignatureBatchPatterns: {
+    readonly getAll: "gestorDocumental.signatureBatch.getAll";
+    readonly getById: "gestorDocumental.signatureBatch.getById";
+    readonly create: "gestorDocumental.signatureBatch.create";
+    readonly visa: "gestorDocumental.signatureBatch.visa";
+    readonly sign: "gestorDocumental.signatureBatch.sign";
+    readonly reject: "gestorDocumental.signatureBatch.reject";
+};
+/** 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[];
+            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/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/transparency.contract.d.ts

@@ -0,0 +1,96 @@
+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 declare const TransparencyPatterns: {
+    readonly getMonth: "gestorDocumental.transparency.getMonth";
+    readonly update: "gestorDocumental.transparency.update";
+    readonly export: "gestorDocumental.transparency.export";
+    readonly getRedactedFile: "gestorDocumental.transparency.getRedactedFile";
+    readonly getPublic: "gestorDocumental.transparency.getPublic";
+    readonly getPublicFile: "gestorDocumental.transparency.getPublicFile";
+};
+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;
+    };
+}
+export {};

package/dist/contracts/transparency.contract.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransparencyPatterns = void 0;
+/** Patrones NATS de `transparency`: Transparencia Activa de los documentos firmados (Ley 20.285, art. 7°). */
+exports.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',
+};

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',
+};