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

package/dist/contracts/caseFile.contract.js

@@ -8,10 +8,20 @@ exports.CaseFilePatterns = {
     create: 'gestorDocumental.caseFile.create',
     update: 'gestorDocumental.caseFile.update',
     addEntry: 'gestorDocumental.caseFile.addEntry',
+    addBatch: 'gestorDocumental.caseFile.addBatch',
     voidEntry: 'gestorDocumental.caseFile.voidEntry',
+    moveEntry: 'gestorDocumental.caseFile.moveEntry',
     share: 'gestorDocumental.caseFile.share',
     unshare: 'gestorDocumental.caseFile.unshare',
     close: 'gestorDocumental.caseFile.close',
     getEntryFile: 'gestorDocumental.caseFile.getEntryFile',
     getExport: 'gestorDocumental.caseFile.getExport',
+    getIntegratedPdf: 'gestorDocumental.caseFile.getIntegratedPdf',
+    createShareLink: 'gestorDocumental.caseFile.createShareLink',
+    getShareLinks: 'gestorDocumental.caseFile.getShareLinks',
+    revokeShareLink: 'gestorDocumental.caseFile.revokeShareLink',
+    getShared: 'gestorDocumental.caseFile.getShared',
+    getSharedEntryFile: 'gestorDocumental.caseFile.getSharedEntryFile',
+    getSharedExport: 'gestorDocumental.caseFile.getSharedExport',
+    verifyExport: 'gestorDocumental.caseFile.verifyExport',
 };

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

@@ -0,0 +1,256 @@
+import { type CommunicationMeans, type DataBreachKind, type DataBreachNoticeMeans, type DataLegalBasis, type DataRight, type DataRightsChannel, type DataRightsResolution } from '../base/entities';
+import { type DataBreachResponseEntity, type DataProtectionPolicyEntity, type IndicatorsFileEntity, type DataRightsRequestDetailEntity, type DataRightsRequestListItemEntity, type DataRightsSummaryEntity, type DataTreatmentResponseEntity } from '../entities';
+import { type RpcPage } from './contract';
+/** Patrones NATS de `dataProtection`: tratamientos de datos y solicitudes de los titulares (Ley 19.628). */
+export declare const DataProtectionPatterns: {
+    readonly getTreatments: "gestorDocumental.dataProtection.getTreatments";
+    readonly createTreatment: "gestorDocumental.dataProtection.createTreatment";
+    readonly updateTreatment: "gestorDocumental.dataProtection.updateTreatment";
+    readonly setTreatmentEnabled: "gestorDocumental.dataProtection.setTreatmentEnabled";
+    readonly getPolicy: "gestorDocumental.dataProtection.getPolicy";
+    readonly getRequests: "gestorDocumental.dataProtection.getRequests";
+    readonly getRequest: "gestorDocumental.dataProtection.getRequest";
+    readonly getSummary: "gestorDocumental.dataProtection.getSummary";
+    readonly createRequest: "gestorDocumental.dataProtection.createRequest";
+    readonly updateRequest: "gestorDocumental.dataProtection.updateRequest";
+    readonly actOnRequest: "gestorDocumental.dataProtection.actOnRequest";
+    readonly getBreaches: "gestorDocumental.dataProtection.getBreaches";
+    readonly getBreach: "gestorDocumental.dataProtection.getBreach";
+    readonly createBreach: "gestorDocumental.dataProtection.createBreach";
+    readonly updateBreach: "gestorDocumental.dataProtection.updateBreach";
+    readonly actOnBreach: "gestorDocumental.dataProtection.actOnBreach";
+    readonly getBreachPdf: "gestorDocumental.dataProtection.getBreachPdf";
+};
+type TActor = {
+    employeeId: string;
+    fullName: string;
+};
+/** Datos de un tratamiento al crearlo o editarlo. */
+export interface DataTreatmentWritePayload {
+    name: string;
+    purpose: string;
+    legalBasis: DataLegalBasis;
+    legalBasisDetail?: string | null;
+    dataCategories: string[];
+    sensitiveData?: boolean;
+    dataSubjects: string;
+    recipients?: string | null;
+    source?: string | null;
+    retention?: string | null;
+    securityMeasures?: string | null;
+    internationalTransfer?: string | null;
+    responsibleUnit?: string | null;
+    published?: boolean;
+}
+/** Datos de una solicitud al ingresarla o corregirla. */
+export interface DataRightsRequestWritePayload {
+    channel: DataRightsChannel;
+    receivedAt: string;
+    rights: DataRight[];
+    requesterName: string;
+    requesterRut?: string | null;
+    requesterEmail?: string | null;
+    requesterAddress?: string | null;
+    representativeName?: string | null;
+    requestText: string;
+    treatmentId?: string | null;
+    /** Bloqueo temporal: solo con rectificación, supresión u oposición, y fundado. */
+    blockingRequested?: boolean;
+    blockingReason?: string | null;
+}
+/** Un paso de la tramitación. */
+export type DataRightsAction = {
+    type: 'acknowledge';
+    note?: string | null;
+} | {
+    type: 'verifyIdentity';
+    note?: string | null;
+} | {
+    type: 'assign';
+    employeeId: string;
+    fullName: string;
+    note?: string | null;
+}
+/** Bloqueo temporal, en 2 días hábiles; si se rechaza, fundado (y se comunica a la Agencia). */
+ | {
+    type: 'resolveBlocking';
+    granted: boolean;
+    note?: string | null;
+}
+/** Levanta el bloqueo concedido (también después de responder): esos datos se vuelven a tratar. */
+ | {
+    type: 'liftBlocking';
+    note?: string | null;
+} | {
+    type: 'extend';
+    note: string;
+} | {
+    type: 'resolve';
+    resolution: DataRightsResolution;
+    grounds?: string[];
+    note?: string | null;
+    responseDocumentId?: string | null;
+}
+/** Respaldo del envío de la respuesta escrita (art. 11). */
+ | {
+    type: 'registerResponseSent';
+    sentAt?: string | null;
+    sentTo: string;
+    means: CommunicationMeans;
+    note?: string | null;
+} | {
+    type: 'registerComplaint';
+    complaintAt?: string | null;
+    note: string;
+};
+/** Datos de una vulneración al registrarla o corregirla. */
+export interface DataBreachWritePayload {
+    detectedAt: string;
+    occurredAt?: string | null;
+    kinds: DataBreachKind[];
+    description: string;
+    effects?: string | null;
+    dataCategories: string[];
+    affectedCount?: number | null;
+    measures?: string | null;
+    sensitiveData?: boolean;
+    minorsData?: boolean;
+    financialData?: boolean;
+    riskToRights?: boolean;
+    treatmentId?: string | null;
+}
+/** Un paso de la gestión de una vulneración. */
+export type DataBreachAction = 
+/** Reporte a la Agencia, con el medio y su número o folio. */
+{
+    type: 'reportAgency';
+    reportedAt?: string | null;
+    note: string;
+}
+/** Comunicación a los titulares: a cada uno o, si no es posible, un aviso en un medio masivo nacional. */
+ | {
+    type: 'notifyHolders';
+    notifiedAt?: string | null;
+    means: DataBreachNoticeMeans;
+    note: string;
+} | {
+    type: 'close';
+    note?: string | null;
+};
+export interface DataProtectionContract {
+    [DataProtectionPatterns.getTreatments]: {
+        payload: {
+            enabled?: boolean | null;
+        };
+        response: DataTreatmentResponseEntity[];
+    };
+    [DataProtectionPatterns.createTreatment]: {
+        payload: DataTreatmentWritePayload;
+        response: DataTreatmentResponseEntity;
+    };
+    [DataProtectionPatterns.updateTreatment]: {
+        payload: DataTreatmentWritePayload & {
+            id: string;
+        };
+        response: DataTreatmentResponseEntity;
+    };
+    [DataProtectionPatterns.setTreatmentEnabled]: {
+        payload: {
+            id: string;
+            enabled: boolean;
+        };
+        response: DataTreatmentResponseEntity;
+    };
+    /** Lo que se publica sin sesión (art. 14 ter): los tratamientos habilitados y publicados. */
+    [DataProtectionPatterns.getPolicy]: {
+        payload: Record<string, never>;
+        response: DataProtectionPolicyEntity;
+    };
+    [DataProtectionPatterns.getRequests]: {
+        payload: {
+            status?: 'open' | 'resolved' | 'all';
+            year?: number | null;
+            search?: string;
+            page?: number;
+            limit?: number;
+        };
+        response: RpcPage<DataRightsRequestListItemEntity[]>;
+    };
+    [DataProtectionPatterns.getRequest]: {
+        payload: {
+            id: string;
+        };
+        response: DataRightsRequestDetailEntity;
+    };
+    [DataProtectionPatterns.getSummary]: {
+        payload: {
+            year: number;
+        };
+        response: DataRightsSummaryEntity;
+    };
+    [DataProtectionPatterns.createRequest]: {
+        payload: DataRightsRequestWritePayload & {
+            actor: TActor;
+        };
+        response: DataRightsRequestDetailEntity;
+    };
+    [DataProtectionPatterns.updateRequest]: {
+        payload: DataRightsRequestWritePayload & {
+            id: string;
+            actor: TActor;
+        };
+        response: DataRightsRequestDetailEntity;
+    };
+    [DataProtectionPatterns.actOnRequest]: {
+        payload: {
+            id: string;
+            action: DataRightsAction;
+            actor: TActor;
+        };
+        response: DataRightsRequestDetailEntity;
+    };
+    /** Las vulneraciones del año (o todas las abiertas), de la más reciente a la más antigua. */
+    [DataProtectionPatterns.getBreaches]: {
+        payload: {
+            year?: number | null;
+            openOnly?: boolean;
+        };
+        response: DataBreachResponseEntity[];
+    };
+    [DataProtectionPatterns.getBreach]: {
+        payload: {
+            id: string;
+        };
+        response: DataBreachResponseEntity;
+    };
+    [DataProtectionPatterns.createBreach]: {
+        payload: DataBreachWritePayload & {
+            actor: TActor;
+        };
+        response: DataBreachResponseEntity;
+    };
+    [DataProtectionPatterns.updateBreach]: {
+        payload: DataBreachWritePayload & {
+            id: string;
+            actor: TActor;
+        };
+        response: DataBreachResponseEntity;
+    };
+    [DataProtectionPatterns.actOnBreach]: {
+        payload: {
+            id: string;
+            action: DataBreachAction;
+            actor: TActor;
+        };
+        response: DataBreachResponseEntity;
+    };
+    /** El registro de la vulneración en PDF, para reportarla o archivarla. */
+    [DataProtectionPatterns.getBreachPdf]: {
+        payload: {
+            id: string;
+            generatedBy: string;
+        };
+        response: IndicatorsFileEntity;
+    };
+}
+export {};

package/dist/contracts/dataProtection.contract.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataProtectionPatterns = void 0;
+/** Patrones NATS de `dataProtection`: tratamientos de datos y solicitudes de los titulares (Ley 19.628). */
+exports.DataProtectionPatterns = {
+    getTreatments: 'gestorDocumental.dataProtection.getTreatments',
+    createTreatment: 'gestorDocumental.dataProtection.createTreatment',
+    updateTreatment: 'gestorDocumental.dataProtection.updateTreatment',
+    setTreatmentEnabled: 'gestorDocumental.dataProtection.setTreatmentEnabled',
+    getPolicy: 'gestorDocumental.dataProtection.getPolicy',
+    getRequests: 'gestorDocumental.dataProtection.getRequests',
+    getRequest: 'gestorDocumental.dataProtection.getRequest',
+    getSummary: 'gestorDocumental.dataProtection.getSummary',
+    createRequest: 'gestorDocumental.dataProtection.createRequest',
+    updateRequest: 'gestorDocumental.dataProtection.updateRequest',
+    actOnRequest: 'gestorDocumental.dataProtection.actOnRequest',
+    getBreaches: 'gestorDocumental.dataProtection.getBreaches',
+    getBreach: 'gestorDocumental.dataProtection.getBreach',
+    createBreach: 'gestorDocumental.dataProtection.createBreach',
+    updateBreach: 'gestorDocumental.dataProtection.updateBreach',
+    actOnBreach: 'gestorDocumental.dataProtection.actOnBreach',
+    getBreachPdf: 'gestorDocumental.dataProtection.getBreachPdf',
+};

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

@@ -0,0 +1,88 @@
+import { type CaseFileActuationType, type DeskFileSource, type DocumentAccessLevel } from '../base/entities';
+import { type CaseFileAddEntryResponseEntity, type DeskFileResponseEntity, type DeskOkResponseEntity, type DeskSummaryEntity, type DocumentPublicFileResponseEntity } from '../entities';
+import { type DocumentActor } from './document.contract';
+/** Patrones NATS de `desk`: el escritorio de documentos de cada funcionario («Sin clasificar»). */
+export declare const DeskPatterns: {
+    readonly getFiles: "gestorDocumental.desk.getFiles";
+    readonly getSummary: "gestorDocumental.desk.getSummary";
+    readonly addFiles: "gestorDocumental.desk.addFiles";
+    readonly getFile: "gestorDocumental.desk.getFile";
+    readonly remove: "gestorDocumental.desk.remove";
+    readonly classify: "gestorDocumental.desk.classify";
+    readonly moveToCaseFile: "gestorDocumental.desk.moveToCaseFile";
+};
+export interface DeskContract {
+    /** Los archivos sin clasificar de quien tiene la sesión, del más reciente al más antiguo. */
+    [DeskPatterns.getFiles]: {
+        payload: {
+            actor: DocumentActor;
+        };
+        response: DeskFileResponseEntity[];
+    };
+    /** `email`, el correo institucional de la sesión, cuenta también los correos que esperan que elija sus adjuntos. */
+    [DeskPatterns.getSummary]: {
+        payload: {
+            email?: string | null;
+            actor: DocumentActor;
+        };
+        response: DeskSummaryEntity;
+    };
+    /** Archivos ya subidos a la carpeta del gestor (por el gateway), que quedan en el escritorio. */
+    [DeskPatterns.addFiles]: {
+        payload: {
+            files: {
+                fileId: string;
+                fileName: string;
+            }[];
+            source?: DeskFileSource;
+            description?: string | null;
+            actor: DocumentActor;
+        };
+        response: DeskFileResponseEntity[];
+    };
+    /** El archivo, solo para su dueño. */
+    [DeskPatterns.getFile]: {
+        payload: {
+            id: string;
+            actor: DocumentActor;
+        };
+        response: DocumentPublicFileResponseEntity;
+    };
+    /** Lo quita del escritorio. El archivo no se borra. */
+    [DeskPatterns.remove]: {
+        payload: {
+            id: string;
+            actor: DocumentActor;
+        };
+        response: DeskOkResponseEntity;
+    };
+    /** Se redactó o firmó un documento con este archivo: deja el escritorio. El documento tiene que ser de su dueño. */
+    [DeskPatterns.classify]: {
+        payload: {
+            id: string;
+            documentId: string;
+            actor: DocumentActor;
+        };
+        response: DeskOkResponseEntity;
+    };
+    /** Lo incorpora como actuación a un expediente abierto en que puede incorporar, con sus metadatos. */
+    [DeskPatterns.moveToCaseFile]: {
+        payload: {
+            id: string;
+            caseFileId: string;
+            entry: {
+                actuationType: CaseFileActuationType;
+                title: string;
+                documentTypeName?: string | null;
+                originDate?: string | null;
+                author?: string | null;
+                keywords: string[];
+                accessLevel: DocumentAccessLevel;
+                hasSensitiveData: boolean;
+            };
+            folder?: string | null;
+            actor: DocumentActor;
+        };
+        response: CaseFileAddEntryResponseEntity;
+    };
+}

package/dist/contracts/desk.contract.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeskPatterns = void 0;
+/** Patrones NATS de `desk`: el escritorio de documentos de cada funcionario («Sin clasificar»). */
+exports.DeskPatterns = {
+    getFiles: 'gestorDocumental.desk.getFiles',
+    getSummary: 'gestorDocumental.desk.getSummary',
+    addFiles: 'gestorDocumental.desk.addFiles',
+    getFile: 'gestorDocumental.desk.getFile',
+    remove: 'gestorDocumental.desk.remove',
+    classify: 'gestorDocumental.desk.classify',
+    moveToCaseFile: 'gestorDocumental.desk.moveToCaseFile',
+};