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

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

@@ -0,0 +1,103 @@
+import { type IndicatorsFileEntity, type ManagementIndicatorsEntity, type QualityMetricSettingResponseEntity, type QualityReportEntity, type ServiceOutageRemoveResponseEntity, type ServiceOutageResponseEntity } from '../entities';
+import { type QualityMetricKey, type ServiceOutageKind } from '../base/entities';
+/** Patrones NATS de `indicators`: indicadores de gestión y Plan de Mejora Continua (DS 11/2023). */
+export declare const IndicatorsPatterns: {
+    readonly getManagement: "gestorDocumental.indicators.getManagement";
+    readonly getQuality: "gestorDocumental.indicators.getQuality";
+    readonly export: "gestorDocumental.indicators.export";
+    readonly updateQualityMetric: "gestorDocumental.indicators.updateQualityMetric";
+    readonly getOutages: "gestorDocumental.indicators.getOutages";
+    readonly createOutage: "gestorDocumental.indicators.createOutage";
+    readonly updateOutage: "gestorDocumental.indicators.updateOutage";
+    readonly removeOutage: "gestorDocumental.indicators.removeOutage";
+    readonly getOutageCertificate: "gestorDocumental.indicators.getOutageCertificate";
+};
+/** Período: días de Chile «AAAA-MM-DD», hasta dos años. */
+export interface IndicatorsPeriodQuery {
+    from: string;
+    to: string;
+}
+export interface ManagementIndicatorsQuery extends IndicatorsPeriodQuery {
+    documentTypeId?: string | null;
+    directorateCode?: number | null;
+}
+export interface ServiceOutageInput {
+    kind: ServiceOutageKind;
+    startedAt: string;
+    endedAt?: string | null;
+    cause: string;
+    affectedServices?: string | null;
+}
+export interface IndicatorsContract {
+    [IndicatorsPatterns.getManagement]: {
+        payload: ManagementIndicatorsQuery;
+        response: ManagementIndicatorsEntity;
+    };
+    [IndicatorsPatterns.getQuality]: {
+        payload: IndicatorsPeriodQuery;
+        response: QualityReportEntity;
+    };
+    /**
+     * Indicadores y Plan de Mejora en una planilla Excel. `generatedBy`: quién la descarga. `unitNames`: nombre de cada
+     * unidad (`c:<código de dirección>` o `d:<id de departamento>`), que el ms no conoce.
+     */
+    [IndicatorsPatterns.export]: {
+        payload: ManagementIndicatorsQuery & {
+            generatedBy: string;
+            unitNames?: Record<string, string>;
+        };
+        response: IndicatorsFileEntity;
+    };
+    /** Umbral y, en las métricas declaradas, su valor y respaldo. */
+    [IndicatorsPatterns.updateQualityMetric]: {
+        payload: {
+            key: QualityMetricKey;
+            threshold: number;
+            declaredValue?: number | null;
+            declaredNote?: string | null;
+            actor: {
+                fullName: string;
+            };
+        };
+        response: QualityMetricSettingResponseEntity;
+    };
+    [IndicatorsPatterns.getOutages]: {
+        payload: {
+            year: number;
+        };
+        response: ServiceOutageResponseEntity[];
+    };
+    [IndicatorsPatterns.createOutage]: {
+        payload: ServiceOutageInput & {
+            actor: {
+                employeeId: string;
+                fullName: string;
+            };
+        };
+        response: ServiceOutageResponseEntity;
+    };
+    [IndicatorsPatterns.updateOutage]: {
+        payload: ServiceOutageInput & {
+            id: string;
+            actor: {
+                employeeId: string;
+                fullName: string;
+            };
+        };
+        response: ServiceOutageResponseEntity;
+    };
+    [IndicatorsPatterns.removeOutage]: {
+        payload: {
+            id: string;
+        };
+        response: ServiceOutageRemoveResponseEntity;
+    };
+    /** Certificado de indisponibilidad (DS 10/2023) en PDF, de una caída ya terminada. */
+    [IndicatorsPatterns.getOutageCertificate]: {
+        payload: {
+            id: string;
+            generatedBy: string;
+        };
+        response: IndicatorsFileEntity;
+    };
+}

package/dist/contracts/indicators.contract.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndicatorsPatterns = void 0;
+/** Patrones NATS de `indicators`: indicadores de gestión y Plan de Mejora Continua (DS 11/2023). */
+exports.IndicatorsPatterns = {
+    getManagement: 'gestorDocumental.indicators.getManagement',
+    getQuality: 'gestorDocumental.indicators.getQuality',
+    export: 'gestorDocumental.indicators.export',
+    updateQualityMetric: 'gestorDocumental.indicators.updateQualityMetric',
+    getOutages: 'gestorDocumental.indicators.getOutages',
+    createOutage: 'gestorDocumental.indicators.createOutage',
+    updateOutage: 'gestorDocumental.indicators.updateOutage',
+    removeOutage: 'gestorDocumental.indicators.removeOutage',
+    getOutageCertificate: 'gestorDocumental.indicators.getOutageCertificate',
+};

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

@@ -0,0 +1,52 @@
+import { type IssuingEntityEntity } from '../base/entities';
+import { type IssuingEntityCreateResponseEntity, type IssuingEntityGetAllResponseEntity, type IssuingEntityGetByIdResponseEntity, type IssuingEntityUpdateResponseEntity } from '../entities';
+import { type RpcPage } from './contract';
+/** Patrones NATS de `issuingEntity`: `<servicio>.<recurso>.<acción>`. */
+export declare const IssuingEntityPatterns: {
+    readonly getAll: "gestorDocumental.issuingEntity.getAll";
+    readonly getById: "gestorDocumental.issuingEntity.getById";
+    readonly create: "gestorDocumental.issuingEntity.create";
+    readonly update: "gestorDocumental.issuingEntity.update";
+    readonly setEnabled: "gestorDocumental.issuingEntity.setEnabled";
+};
+/** Datos de una entidad emisora al crearla o editarla. */
+export interface IssuingEntityWritePayload {
+    name: string;
+    shortName?: string | null;
+    /** Direcciones (código de caschile) cuyos funcionarios actúan por la entidad. */
+    directorateCodeReferences: number[];
+    /** Su entidad en DocDigital, entre las asociadas a las credenciales del gestor. */
+    docDigitalEntityId?: number | null;
+    enabled?: boolean;
+}
+export interface IssuingEntityContract {
+    [IssuingEntityPatterns.getAll]: {
+        payload: {
+            pagination?: {
+                page?: number;
+                limit?: number;
+            };
+            filters?: {
+                search?: string;
+                enabled?: boolean;
+            };
+        };
+        response: RpcPage<IssuingEntityGetAllResponseEntity[]>;
+    };
+    [IssuingEntityPatterns.getById]: {
+        payload: Pick<IssuingEntityEntity, 'id'>;
+        response: IssuingEntityGetByIdResponseEntity;
+    };
+    [IssuingEntityPatterns.create]: {
+        payload: IssuingEntityWritePayload;
+        response: IssuingEntityCreateResponseEntity;
+    };
+    [IssuingEntityPatterns.update]: {
+        payload: IssuingEntityWritePayload & Pick<IssuingEntityEntity, 'id'>;
+        response: IssuingEntityUpdateResponseEntity;
+    };
+    [IssuingEntityPatterns.setEnabled]: {
+        payload: Pick<IssuingEntityEntity, 'id' | 'enabled'>;
+        response: IssuingEntityUpdateResponseEntity;
+    };
+}

package/dist/contracts/issuingEntity.contract.js

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

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

@@ -0,0 +1,263 @@
+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>`. */
+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";
+    readonly dispatch: "gestorDocumental.partsOffice.dispatch";
+    readonly returnDispatch: "gestorDocumental.partsOffice.returnDispatch";
+    readonly resendDispatch: "gestorDocumental.partsOffice.resendDispatch";
+    readonly getDispatchFile: "gestorDocumental.partsOffice.getDispatchFile";
+    readonly getInbound: "gestorDocumental.partsOffice.getInbound";
+    readonly syncInbound: "gestorDocumental.partsOffice.syncInbound";
+    readonly registerInbound: "gestorDocumental.partsOffice.registerInbound";
+    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 = {
+    type: 'Employee';
+    employeeId: string;
+} | {
+    type: 'Directorate';
+    directorateCodeReference: number;
+    name: string;
+    memberEmployeeIds: string[];
+} | {
+    type: 'Department';
+    departmentId: string;
+    name: string;
+    memberEmployeeIds: string[];
+};
+interface IListPayload<S> {
+    pagination?: {
+        page?: number;
+        limit?: number;
+    };
+    filters?: {
+        search?: string;
+        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>;
+        response: PartsOfficeStatusEntity;
+    };
+    [PartsOfficePatterns.getSummary]: {
+        payload: Record<string, never>;
+        response: PartsOfficeSummaryEntity;
+    };
+    /** Directorio de DocDigital: instituciones por nombre. */
+    [PartsOfficePatterns.getEntities]: {
+        payload: {
+            search?: string;
+        };
+        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;
+            search?: string;
+        };
+        response: DocDigitalUserEntity[];
+    };
+    [PartsOfficePatterns.getDocumentTypes]: {
+        payload: Record<string, never>;
+        response: DocDigitalDocumentTypeEntity[];
+    };
+    [PartsOfficePatterns.getDispatches]: {
+        payload: IListPayload<'Pending' | 'Dispatched' | 'Returned'>;
+        response: RpcPage<PartsOfficeDispatchEntity[]>;
+    };
+    /** Despacha por DocDigital, con el número del documento como folio. `operatorRun`: RUN de quien despacha. */
+    [PartsOfficePatterns.dispatch]: {
+        payload: {
+            id: string;
+            docDigitalTypeId: number;
+            operatorRun?: string | null;
+            actor: DocumentActor;
+        };
+        response: PartsOfficeOkResponseEntity & {
+            docDigitalDocumentId: string;
+        };
+    };
+    /** Devuelve el despacho al redactor, con el motivo (por ejemplo, un destinatario equivocado). */
+    [PartsOfficePatterns.returnDispatch]: {
+        payload: {
+            id: string;
+            reason: string;
+            actor: DocumentActor;
+        };
+        response: PartsOfficeOkResponseEntity;
+    };
+    /** El redactor corrige las instituciones de destino de un despacho devuelto y lo envía de nuevo a Partes. */
+    [PartsOfficePatterns.resendDispatch]: {
+        payload: {
+            id: string;
+            externalRecipients: DocumentExternalRecipientInput[];
+            actor: DocumentActor;
+        };
+        response: PartsOfficeOkResponseEntity;
+    };
+    /** PDF firmado de un documento por despachar, para que Oficina de Partes lo revise. */
+    [PartsOfficePatterns.getDispatchFile]: {
+        payload: {
+            id: string;
+            receipt?: boolean;
+        };
+        response: PartsOfficeFileEntity;
+    };
+    [PartsOfficePatterns.getInbound]: {
+        payload: IListPayload<'Pending' | 'Registered' | 'Returned'>;
+        response: RpcPage<PartsOfficeInboundEntity[]>;
+    };
+    /** Trae de DocDigital lo recibido que aún no tiene acuse de recibo. */
+    [PartsOfficePatterns.syncInbound]: {
+        payload: Record<string, never>;
+        response: PartsOfficeSyncResponseEntity;
+    };
+    /**
+     * Ingresa un recibido al gestor: le da folio de ingreso, lo deriva a quienes corresponda y da el acuse de recibo
+     * en DocDigital.
+     */
+    [PartsOfficePatterns.registerInbound]: {
+        payload: {
+            id: string;
+            documentTypeId: string;
+            keywords: string[];
+            accessLevel: DocumentAccessLevel;
+            hasSensitiveData: boolean;
+            recipients: PartsOfficeRecipientInput[];
+            instruction: DocumentInstruction;
+            note?: string | null;
+            dueAt?: string | null;
+            actor: DocumentActor;
+        };
+        response: PartsOfficeRegisterResponseEntity;
+    };
+    /** Reintenta el acuse de recibo de un recibido ya ingresado. */
+    [PartsOfficePatterns.acknowledgeInbound]: {
+        payload: {
+            id: string;
+            actor: DocumentActor;
+        };
+        response: PartsOfficeOkResponseEntity;
+    };
+    /** Devuelve el recibido a la institución que lo envió, con el motivo (entre 3 y 255 caracteres). */
+    [PartsOfficePatterns.returnInbound]: {
+        payload: {
+            id: string;
+            reason: string;
+            actor: DocumentActor;
+        };
+        response: PartsOfficeOkResponseEntity;
+    };
+    /** Archivo de un recibido: el principal o, con `attachment`, uno de sus anexos (por su posición). */
+    [PartsOfficePatterns.getInboundFile]: {
+        payload: {
+            id: string;
+            attachment?: number;
+        };
+        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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PartsOfficePatterns = void 0;
+/** Patrones NATS de `partsOffice` (Oficina de Partes y DocDigital): `<servicio>.<recurso>.<acción>`. */
+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',
+    dispatch: 'gestorDocumental.partsOffice.dispatch',
+    returnDispatch: 'gestorDocumental.partsOffice.returnDispatch',
+    resendDispatch: 'gestorDocumental.partsOffice.resendDispatch',
+    getDispatchFile: 'gestorDocumental.partsOffice.getDispatchFile',
+    getInbound: 'gestorDocumental.partsOffice.getInbound',
+    syncInbound: 'gestorDocumental.partsOffice.syncInbound',
+    registerInbound: 'gestorDocumental.partsOffice.registerInbound',
+    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

@@ -0,0 +1,50 @@
+import { type ProcedureEntity } from '../base/entities';
+import { type ProcedureCreateResponseEntity, type ProcedureGetAllResponseEntity, type ProcedureGetByIdResponseEntity, type ProcedureUpdateResponseEntity } from '../entities';
+import { type RpcPage } from './contract';
+/** Patrones NATS de `procedure`: `<servicio>.<recurso>.<acción>`. */
+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";
+};
+/** 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: {
+            pagination?: {
+                page?: number;
+                limit?: number;
+            };
+            filters?: {
+                search?: string;
+                enabled?: boolean;
+            };
+        };
+        response: RpcPage<ProcedureGetAllResponseEntity[]>;
+    };
+    [ProcedurePatterns.getById]: {
+        payload: Pick<ProcedureEntity, 'id'>;
+        response: ProcedureGetByIdResponseEntity;
+    };
+    [ProcedurePatterns.create]: {
+        payload: ProcedureWritePayload;
+        response: ProcedureCreateResponseEntity;
+    };
+    [ProcedurePatterns.update]: {
+        payload: ProcedureWritePayload & Pick<ProcedureEntity, 'id'>;
+        response: ProcedureUpdateResponseEntity;
+    };
+    [ProcedurePatterns.setEnabled]: {
+        payload: Pick<ProcedureEntity, 'id' | 'enabled'>;
+        response: ProcedureUpdateResponseEntity;
+    };
+}

package/dist/contracts/procedure.contract.js

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

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