@muni-sanfer/types-gestor-documental 0.0.1-beta.5 → 0.0.1-beta.50

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

@@ -0,0 +1,61 @@
+import { type DeskFileResponseEntity, type DeskOkResponseEntity, type DocumentPublicFileResponseEntity, type MailIntakeInboxEntity, type MailIntakeSyncEntity } from '../entities';
+import { type DocumentActor } from './document.contract';
+/**
+ * Patrones NATS de `mailIntake`: el ingreso por correo. Un funcionario reenvía un correo a la casilla del gestor y
+ * después elige qué adjuntos entran a su escritorio. `email` es el correo institucional de la sesión, que agrega el
+ * gateway: solo con él se ven los correos que envió.
+ */
+export declare const MailIntakePatterns: {
+    readonly getMine: "gestorDocumental.mailIntake.getMine";
+    readonly accept: "gestorDocumental.mailIntake.accept";
+    readonly discard: "gestorDocumental.mailIntake.discard";
+    readonly getEml: "gestorDocumental.mailIntake.getEml";
+    readonly sync: "gestorDocumental.mailIntake.sync";
+};
+export interface MailIntakeContract {
+    /** Los correos pendientes que envió quien tiene la sesión, del más reciente al más antiguo. */
+    [MailIntakePatterns.getMine]: {
+        payload: {
+            email: string | null;
+            actor: DocumentActor;
+        };
+        response: MailIntakeInboxEntity;
+    };
+    /**
+     * Lleva al escritorio los adjuntos elegidos (por su `index`) y, si se pide, el correo completo en EML. El correo
+     * queda aceptado: no se puede volver a procesar.
+     */
+    [MailIntakePatterns.accept]: {
+        payload: {
+            id: string;
+            email: string | null;
+            attachments: number[];
+            includeEml: boolean;
+            actor: DocumentActor;
+        };
+        response: DeskFileResponseEntity[];
+    };
+    /** Lo descarta sin traer nada. El EML se conserva. */
+    [MailIntakePatterns.discard]: {
+        payload: {
+            id: string;
+            email: string | null;
+            actor: DocumentActor;
+        };
+        response: DeskOkResponseEntity;
+    };
+    /** El correo completo (EML), para su remitente. */
+    [MailIntakePatterns.getEml]: {
+        payload: {
+            id: string;
+            email: string | null;
+            actor: DocumentActor;
+        };
+        response: DocumentPublicFileResponseEntity;
+    };
+    /** Revisa la casilla ahora, sin esperar a la revisión periódica. */
+    [MailIntakePatterns.sync]: {
+        payload: Record<string, never>;
+        response: MailIntakeSyncEntity;
+    };
+}

package/dist/contracts/mailIntake.contract.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MailIntakePatterns = void 0;
+/**
+ * Patrones NATS de `mailIntake`: el ingreso por correo. Un funcionario reenvía un correo a la casilla del gestor y
+ * después elige qué adjuntos entran a su escritorio. `email` es el correo institucional de la sesión, que agrega el
+ * gateway: solo con él se ven los correos que envió.
+ */
+exports.MailIntakePatterns = {
+    getMine: 'gestorDocumental.mailIntake.getMine',
+    accept: 'gestorDocumental.mailIntake.accept',
+    discard: 'gestorDocumental.mailIntake.discard',
+    getEml: 'gestorDocumental.mailIntake.getEml',
+    sync: 'gestorDocumental.mailIntake.sync',
+};

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

@@ -1,5 +1,5 @@
-import { type DocumentAccessLevel, type DocumentInstruction } from '../base/entities';
-import { type DocDigitalDocumentTypeEntity, type DocDigitalEntityEntity, type PartsOfficeInboundEntity, type DocDigitalUserEntity, type PartsOfficeDispatchEntity, type PartsOfficeFileEntity, type PartsOfficeOkResponseEntity, type PartsOfficeRegisterResponseEntity, type PartsOfficeStatusEntity, type PartsOfficeSummaryEntity, type PartsOfficeSyncResponseEntity } from '../entities';
+import { type CommunicationMeans, type DocumentAccessLevel, type DocumentInstruction } from '../base/entities';
+import { type CaseFileAddEntryResponseEntity, type DocDigitalDocumentTypeEntity, type DocDigitalEntityEntity, type PartsOfficeInboundEntity, type DocDigitalUserEntity, type EnablementPersonInput, type PartsOfficeEnablementEntity, type PartsOfficeDispatchEntity, type PartsOfficeFileEntity, type PartsOfficeOkResponseEntity, type PartsOfficeRegisterResponseEntity, type PartsOfficeStatusEntity, type PartsOfficeSummaryEntity, type PartsOfficeSyncResponseEntity } from '../entities';
 import { type RpcPage } from './contract';
 import { type DocumentActor, type DocumentExternalRecipientInput } from './document.contract';
 /** Patrones NATS de `partsOffice` (Oficina de Partes y DocDigital): `<servicio>.<recurso>.<acción>`. */
@@ -7,6 +7,7 @@ export declare const PartsOfficePatterns: {
     readonly getStatus: "gestorDocumental.partsOffice.getStatus";
     readonly getSummary: "gestorDocumental.partsOffice.getSummary";
     readonly getEntities: "gestorDocumental.partsOffice.getEntities";
+    readonly getOwnEntities: "gestorDocumental.partsOffice.getOwnEntities";
     readonly getUsers: "gestorDocumental.partsOffice.getUsers";
     readonly getDocumentTypes: "gestorDocumental.partsOffice.getDocumentTypes";
     readonly getDispatches: "gestorDocumental.partsOffice.getDispatches";
@@ -20,6 +21,10 @@ export declare const PartsOfficePatterns: {
     readonly acknowledgeInbound: "gestorDocumental.partsOffice.acknowledgeInbound";
     readonly returnInbound: "gestorDocumental.partsOffice.returnInbound";
     readonly getInboundFile: "gestorDocumental.partsOffice.getInboundFile";
+    readonly checkEnablement: "gestorDocumental.partsOffice.checkEnablement";
+    readonly dispatchByContingency: "gestorDocumental.partsOffice.dispatchByContingency";
+    readonly registerManualIntake: "gestorDocumental.partsOffice.registerManualIntake";
+    readonly addCaseFileReceipt: "gestorDocumental.partsOffice.addCaseFileReceipt";
 };
 /** Destinatario interno de un ingreso, ya resuelto por el gateway (las áreas con sus integrantes). */
 export type PartsOfficeRecipientInput = {
@@ -46,6 +51,35 @@ interface IListPayload<S> {
         status?: S;
     };
 }
+/** Lo que llegó fuera de DocDigital y Oficina de Partes ingresa a mano. */
+export interface ManualIntakePayload {
+    file: {
+        fileId: string;
+        name: string;
+    };
+    attachments?: {
+        fileId: string;
+        name: string;
+    }[];
+    means: CommunicationMeans;
+    /** Cuándo llegó (ISO); sin él, ahora. */
+    receivedAt?: string | null;
+    senderEntityName: string;
+    senderName?: string | null;
+    externalFolio?: string | null;
+    externalDate?: string | null;
+    subject: string;
+    documentTypeId: string;
+    keywords: string[];
+    accessLevel?: DocumentAccessLevel;
+    hasSensitiveData?: boolean;
+    recipients: unknown[];
+    instruction: DocumentInstruction;
+    note?: string | null;
+    dueAt?: string | null;
+    dueBusinessDays?: number | null;
+    actor: DocumentActor;
+}
 export interface PartsOfficeContract {
     [PartsOfficePatterns.getStatus]: {
         payload: Record<string, never>;
@@ -62,6 +96,11 @@ export interface PartsOfficeContract {
         };
         response: DocDigitalEntityEntity[];
     };
+    /** Entidades asociadas a las credenciales del gestor: la del municipio y las de sus entidades emisoras. */
+    [PartsOfficePatterns.getOwnEntities]: {
+        payload: Record<string, never>;
+        response: DocDigitalEntityEntity[];
+    };
     [PartsOfficePatterns.getUsers]: {
         payload: {
             entityId: number;
@@ -111,6 +150,7 @@ export interface PartsOfficeContract {
     [PartsOfficePatterns.getDispatchFile]: {
         payload: {
             id: string;
+            receipt?: boolean;
         };
         response: PartsOfficeFileEntity;
     };
@@ -167,5 +207,57 @@ export interface PartsOfficeContract {
         };
         response: PartsOfficeFileEntity;
     };
+    /**
+     * Quiénes de `people` están habilitados como usuarios de DocDigital en la municipalidad o en sus entidades emisoras
+     * (por RUN). El directorio de cada entidad se guarda 10 minutos.
+     */
+    [PartsOfficePatterns.checkEnablement]: {
+        payload: {
+            people: EnablementPersonInput[];
+        };
+        response: PartsOfficeEnablementEntity;
+    };
+    /**
+     * Registro por contingencia: el documento no se pudo despachar por DocDigital y salió por otro medio. Queda
+     * despachado, con el medio, a quién, el motivo y el comprobante; si después se registra en DocDigital, su número.
+     */
+    [PartsOfficePatterns.dispatchByContingency]: {
+        payload: {
+            id: string;
+            means: CommunicationMeans;
+            sentAt: string;
+            sentTo: string;
+            reason: string;
+            receipt?: {
+                fileId: string;
+                name: string;
+            } | null;
+            docDigitalDocumentId?: string | null;
+            actor: DocumentActor;
+        };
+        response: PartsOfficeOkResponseEntity;
+    };
+    /**
+     * Ingreso manual: lo que llegó fuera de DocDigital (papel, correo) entra con folio de ingreso, como lo recibido
+     * por DocDigital, y se deriva.
+     */
+    [PartsOfficePatterns.registerManualIntake]: {
+        payload: ManualIntakePayload;
+        response: PartsOfficeRegisterResponseEntity;
+    };
+    /**
+     * Comprobante de trazabilidad de DocDigital de un documento del índice de un expediente (despachado o recibido por
+     * DocDigital): se arma con el estado y el historial que informa DocDigital y entra como comunicación oficial.
+     */
+    [PartsOfficePatterns.addCaseFileReceipt]: {
+        payload: {
+            caseFileId: string;
+            documentId: string;
+            actor: {
+                employeeId: string;
+            };
+        };
+        response: CaseFileAddEntryResponseEntity;
+    };
 }
 export {};

package/dist/contracts/partsOffice.contract.js

@@ -6,6 +6,7 @@ exports.PartsOfficePatterns = {
     getStatus: 'gestorDocumental.partsOffice.getStatus',
     getSummary: 'gestorDocumental.partsOffice.getSummary',
     getEntities: 'gestorDocumental.partsOffice.getEntities',
+    getOwnEntities: 'gestorDocumental.partsOffice.getOwnEntities',
     getUsers: 'gestorDocumental.partsOffice.getUsers',
     getDocumentTypes: 'gestorDocumental.partsOffice.getDocumentTypes',
     getDispatches: 'gestorDocumental.partsOffice.getDispatches',
@@ -19,4 +20,8 @@ exports.PartsOfficePatterns = {
     acknowledgeInbound: 'gestorDocumental.partsOffice.acknowledgeInbound',
     returnInbound: 'gestorDocumental.partsOffice.returnInbound',
     getInboundFile: 'gestorDocumental.partsOffice.getInboundFile',
+    checkEnablement: 'gestorDocumental.partsOffice.checkEnablement',
+    dispatchByContingency: 'gestorDocumental.partsOffice.dispatchByContingency',
+    registerManualIntake: 'gestorDocumental.partsOffice.registerManualIntake',
+    addCaseFileReceipt: 'gestorDocumental.partsOffice.addCaseFileReceipt',
 };

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

@@ -1,22 +1,16 @@
 import { type ProcedureEntity } from '../base/entities';
-import { type ProcedureCreateResponseEntity, type ProcedureGetAllResponseEntity, type ProcedureGetByIdResponseEntity, type ProcedureUpdateResponseEntity } from '../entities';
+import { type ProcedureCpatStatusEntity, type ProcedureGetAllResponseEntity, type ProcedureGetByIdResponseEntity, type ProcedureSyncResponseEntity } from '../entities';
 import { type RpcPage } from './contract';
-/** Patrones NATS de `procedure`: `<servicio>.<recurso>.<acción>`. */
+/**
+ * Patrones NATS de `procedure`: los procedimientos administrativos vienen del CPAT (nómina en datos.gob.cl) y no se
+ * crean ni editan en el gestor.
+ */
 export declare const ProcedurePatterns: {
     readonly getAll: "gestorDocumental.procedure.getAll";
     readonly getById: "gestorDocumental.procedure.getById";
-    readonly create: "gestorDocumental.procedure.create";
-    readonly update: "gestorDocumental.procedure.update";
-    readonly setEnabled: "gestorDocumental.procedure.setEnabled";
+    readonly getCpatStatus: "gestorDocumental.procedure.getCpatStatus";
+    readonly sync: "gestorDocumental.procedure.sync";
 };
-/** Datos de un procedimiento administrativo al crearlo o editarlo. */
-export interface ProcedureWritePayload {
-    name: string;
-    cpatId?: string | null;
-    cpatCode?: string | null;
-    description?: string | null;
-    enabled?: boolean;
-}
 export interface ProcedureContract {
     [ProcedurePatterns.getAll]: {
         payload: {
@@ -35,16 +29,13 @@ export interface ProcedureContract {
         payload: Pick<ProcedureEntity, 'id'>;
         response: ProcedureGetByIdResponseEntity;
     };
-    [ProcedurePatterns.create]: {
-        payload: ProcedureWritePayload;
-        response: ProcedureCreateResponseEntity;
-    };
-    [ProcedurePatterns.update]: {
-        payload: ProcedureWritePayload & Pick<ProcedureEntity, 'id'>;
-        response: ProcedureUpdateResponseEntity;
+    [ProcedurePatterns.getCpatStatus]: {
+        payload: Record<string, never>;
+        response: ProcedureCpatStatusEntity;
     };
-    [ProcedurePatterns.setEnabled]: {
-        payload: Pick<ProcedureEntity, 'id' | 'enabled'>;
-        response: ProcedureUpdateResponseEntity;
+    /** Trae del CPAT los procedimientos de la institución `CPAT_INSTITUTION_CODE`. */
+    [ProcedurePatterns.sync]: {
+        payload: Record<string, never>;
+        response: ProcedureSyncResponseEntity;
     };
 }

package/dist/contracts/procedure.contract.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProcedurePatterns = void 0;
-/** Patrones NATS de `procedure`: `<servicio>.<recurso>.<acción>`. */
+/**
+ * Patrones NATS de `procedure`: los procedimientos administrativos vienen del CPAT (nómina en datos.gob.cl) y no se
+ * crean ni editan en el gestor.
+ */
 exports.ProcedurePatterns = {
     getAll: 'gestorDocumental.procedure.getAll',
     getById: 'gestorDocumental.procedure.getById',
-    create: 'gestorDocumental.procedure.create',
-    update: 'gestorDocumental.procedure.update',
-    setEnabled: 'gestorDocumental.procedure.setEnabled',
+    getCpatStatus: 'gestorDocumental.procedure.getCpatStatus',
+    sync: 'gestorDocumental.procedure.sync',
 };

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

@@ -0,0 +1,59 @@
+import { type PushConfigResponseEntity, type PushNotificationInput, type PushOkResponseEntity, type PushSendResultEntity } from '../entities';
+import { type DocumentActor } from './document.contract';
+/**
+ * Patrones NATS de `push`: avisos en el celular o el computador (Web Push), además del correo. Cada funcionario los
+ * activa en sus dispositivos; el gateway los envía junto con los correos de aviso.
+ */
+export declare const PushPatterns: {
+    readonly getConfig: "gestorDocumental.push.getConfig";
+    readonly subscribe: "gestorDocumental.push.subscribe";
+    readonly unsubscribe: "gestorDocumental.push.unsubscribe";
+    readonly test: "gestorDocumental.push.test";
+    readonly send: "gestorDocumental.push.send";
+};
+export interface PushContract {
+    [PushPatterns.getConfig]: {
+        payload: {
+            actor: DocumentActor;
+        };
+        response: PushConfigResponseEntity;
+    };
+    /** Registra el dispositivo (o lo actualiza, si ya estaba) a nombre de quien tiene la sesión. */
+    [PushPatterns.subscribe]: {
+        payload: {
+            subscription: {
+                endpoint: string;
+                keys: {
+                    p256dh: string;
+                    auth: string;
+                };
+            };
+            userAgent?: string | null;
+            actor: DocumentActor;
+        };
+        response: PushOkResponseEntity;
+    };
+    /** Quita el dispositivo, solo si es de quien tiene la sesión. */
+    [PushPatterns.unsubscribe]: {
+        payload: {
+            endpoint: string;
+            actor: DocumentActor;
+        };
+        response: PushOkResponseEntity;
+    };
+    /** Un aviso de prueba a los dispositivos de quien tiene la sesión. */
+    [PushPatterns.test]: {
+        payload: {
+            actor: DocumentActor;
+        };
+        response: PushSendResultEntity;
+    };
+    /** Envía un aviso a los dispositivos de esos funcionarios. Lo usa el gateway, no el navegador. */
+    [PushPatterns.send]: {
+        payload: {
+            employeeIds: string[];
+            notification: PushNotificationInput;
+        };
+        response: PushSendResultEntity;
+    };
+}

package/dist/contracts/push.contract.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PushPatterns = void 0;
+/**
+ * Patrones NATS de `push`: avisos en el celular o el computador (Web Push), además del correo. Cada funcionario los
+ * activa en sus dispositivos; el gateway los envía junto con los correos de aviso.
+ */
+exports.PushPatterns = {
+    getConfig: 'gestorDocumental.push.getConfig',
+    subscribe: 'gestorDocumental.push.subscribe',
+    unsubscribe: 'gestorDocumental.push.unsubscribe',
+    test: 'gestorDocumental.push.test',
+    send: 'gestorDocumental.push.send',
+};

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

@@ -0,0 +1,27 @@
+import { type RegisterBookEntity, type RegisterBookExportEntity, type RegisterBookKind } from '../entities';
+/** Patrones NATS de `registerBook` (libros de registro): `<servicio>.<recurso>.<acción>`. */
+export declare const RegisterBookPatterns: {
+    readonly get: "gestorDocumental.registerBook.get";
+    readonly export: "gestorDocumental.registerBook.export";
+};
+/** Qué libro y qué período: un año y, si se indica, un mes. El de un tipo documental exige el tipo. */
+export interface RegisterBookQuery {
+    kind: RegisterBookKind;
+    documentTypeId?: string;
+    year: number;
+    month?: number | null;
+}
+export interface RegisterBookContract {
+    [RegisterBookPatterns.get]: {
+        payload: RegisterBookQuery;
+        response: RegisterBookEntity;
+    };
+    /** El libro en Excel o PDF. `generatedBy`: quién lo descarga (va en el encabezado). */
+    [RegisterBookPatterns.export]: {
+        payload: RegisterBookQuery & {
+            format: 'xlsx' | 'pdf';
+            generatedBy: string;
+        };
+        response: RegisterBookExportEntity;
+    };
+}

package/dist/contracts/registerBook.contract.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegisterBookPatterns = void 0;
+/** Patrones NATS de `registerBook` (libros de registro): `<servicio>.<recurso>.<acción>`. */
+exports.RegisterBookPatterns = {
+    get: 'gestorDocumental.registerBook.get',
+    export: 'gestorDocumental.registerBook.export',
+};

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/richImage.contract.d.ts

@@ -0,0 +1,33 @@
+import { type RichImageResponseEntity } from '../entities';
+/** Patrones NATS de `richImage`: imágenes del editor (logos de membrete e imágenes del texto). */
+export declare const RichImagePatterns: {
+    readonly register: "gestorDocumental.richImage.register";
+    readonly getFile: "gestorDocumental.richImage.getFile";
+};
+export interface RichImageContract {
+    /**
+     * Registra una imagen ya subida a Drive por el gateway (en la carpeta de los documentos). El ms descarga el archivo, comprueba que sea PNG o JPEG y de
+     * tamaño aceptable, y guarda sus medidas y su huella.
+     */
+    [RichImagePatterns.register]: {
+        payload: {
+            fileId: string;
+            name: string;
+            actor: {
+                employeeId: string;
+            };
+        };
+        response: RichImageResponseEntity;
+    };
+    /** El archivo de una imagen registrada, para mostrarla en el editor. */
+    [RichImagePatterns.getFile]: {
+        payload: {
+            id: string;
+        };
+        response: {
+            fileId: string;
+            fileName: string;
+            mimeType: string;
+        };
+    };
+}

package/dist/contracts/richImage.contract.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RichImagePatterns = void 0;
+/** Patrones NATS de `richImage`: imágenes del editor (logos de membrete e imágenes del texto). */
+exports.RichImagePatterns = {
+    register: 'gestorDocumental.richImage.register',
+    getFile: 'gestorDocumental.richImage.getFile',
+};