@icure/api 8.3.5 → 8.4.0

package/icc-x-api/icc-document-x-api.d.ts

@@ -12,6 +12,7 @@ import { EncryptedEntityXApi } from './basexapi/EncryptedEntityXApi';
 import AccessLevelEnum = SecureDelegation.AccessLevelEnum;
 import RequestedPermissionEnum = EntityShareRequest.RequestedPermissionEnum;
 import { SecretIdUseOption } from './crypto/SecretIdUseOption';
+import { ListOfIds, PaginatedListDocument } from '../icc-api/model/models';
 export declare class IccDocumentXApi extends IccDocumentApi implements EncryptedEntityXApi<models.Document> {
     private crypto;
     private authApi;
@@ -32,9 +33,10 @@ export declare class IccDocumentXApi extends IccDocumentApi implements Encrypted
     };
     dataOwnerApi: IccDataOwnerXApi;
     authenticationProvider: AuthenticationProvider;
+    private readonly encryptedFields;
     constructor(host: string, headers: {
         [key: string]: string;
-    }, crypto: IccCryptoXApi, authApi: IccAuthApi, dataOwnerApi: IccDataOwnerXApi, autofillAuthor: boolean, authenticationProvider?: AuthenticationProvider, fetchImpl?: (input: RequestInfo, init?: RequestInit) => Promise<Response>);
+    }, crypto: IccCryptoXApi, authApi: IccAuthApi, dataOwnerApi: IccDataOwnerXApi, autofillAuthor: boolean, authenticationProvider?: AuthenticationProvider, encryptedKeys?: Array<string>, fetchImpl?: (input: RequestInfo, init?: RequestInit) => Promise<Response>);
     get headers(): Promise<Array<XHR.Header>>;
     /**
      * Creates a new instance of document with initialised encryption metadata (not in the database).
@@ -60,16 +62,16 @@ export declare class IccDocumentXApi extends IccDocumentApi implements Encrypted
         ignoreAutoDelegations?: boolean;
         alternateRootDelegation?: string;
     }): Promise<models.Document>;
-    /**
-     * @deprecated use {@link findIdsByMessage} instead.
-     */
-    findByMessage(hcpartyId: string, message: models.Message): Promise<models.Document[]>;
     /**
      * Same as {@link findByMessage} but it will only return the ids of the contacts. It can also filter the documents where Document.created is between
      * startDate and endDate in ascending or descending order by that field. (default: ascending).
      */
     findIdsByMessage(hcpartyId: string, message: models.Message, startDate?: number, endDate?: number, descending?: boolean): Promise<string[]>;
-    decrypt(hcpartyId: string, documents: Array<models.Document>): Promise<Array<models.Document>>;
+    decrypt(documents: Array<models.Document>): Promise<{
+        entity: models.Document;
+        decrypted: boolean;
+    }[]>;
+    encrypt(documents: Array<models.Document>): Promise<Array<models.Document>>;
     getAttachmentAs(documentId: string, attachmentId: string, returnType: "application/octet-stream", enckeys?: string, fileName?: string): Promise<ArrayBuffer>;
     getAttachmentAs(documentId: string, attachmentId: string, returnType: "text/plain", enckeys?: string, fileName?: string): Promise<string>;
     getAttachmentAs(documentId: string, attachmentId: string, returnType: "application/json", enckeys?: string, fileName?: string): Promise<any>;
@@ -247,4 +249,47 @@ export declare class IccDocumentXApi extends IccDocumentApi implements Encrypted
     }>;
     getEncryptionKeysOf(entity: models.Document): Promise<string[]>;
     createDelegationDeAnonymizationMetadata(entity: models.Document, delegates: string[]): Promise<void>;
+    private decryptPage;
+    createDocumentWithUser(user: models.User | undefined, body: models.Document): Promise<models.Document>;
+    deleteAttachmentWithUser(user: models.User | undefined, documentId: string): Promise<models.Document>;
+    /**
+     * @deprecated
+     */
+    findByTypeHCPartyMessageSecretFKeysWithUser(user: models.User | undefined, documentTypeCode: string, hcPartyId: string, secretFKeys: string[]): Promise<Array<models.Document>>;
+    /**
+     * @deprecated
+     */
+    findDocumentsByHCPartyPatientForeignKeysWithUser(user: models.User | undefined, hcPartyId: string, secretFKeys: string[]): Promise<Array<models.Document>>;
+    /**
+     * @deprecated
+     */
+    findDocumentsByHCPartyPatientForeignKeyWithUser(user: models.User | undefined, hcPartyId: string, secretFKey: string, startKey?: string, startDocumentId?: string, limit?: number): Promise<PaginatedListDocument>;
+    findWithoutDelegationWithUser(user: models.User | undefined, limit?: number): Promise<Array<models.Document>>;
+    getDocumentWithUser(user: models.User | undefined, documentId: string): Promise<models.Document>;
+    getDocumentByExternalUuidWithUser(user: models.User | undefined, externalUuid: string): Promise<models.Document>;
+    getDocumentsWithUser(user: models.User | undefined, body?: ListOfIds): Promise<Array<models.Document>>;
+    getDocumentsByExternalUuidWithUser(user: models.User | undefined, externalUuid: string): Promise<Array<models.Document>>;
+    modifyDocumentWithUser(user: models.User | undefined, body: models.Document): Promise<models.Document>;
+    modifyDocumentsWithUser(user: models.User | undefined, body: Array<models.Document>): Promise<Array<models.Document>>;
+    setMainDocumentAttachmentWithUser(user: models.User | undefined, documentId: string, documentRev: string, body: Object, utis?: Array<string>, dataIsEncrypted?: boolean): Promise<models.Document>;
+    setSecondaryAttachmentWithUser(user: models.User | undefined, documentId: string, key: string, rev: string, attachment: Object, utis?: Array<string>, dataIsEncrypted?: boolean): Promise<models.Document>;
+    deleteSecondaryAttachmentWithUser(user: models.User | undefined, documentId: string, key: string, rev: string): Promise<models.Document>;
+    createDocument(body?: models.Document): never;
+    deleteAttachment(documentId: string): never;
+    findByTypeHCPartyMessageSecretFKeys(documentTypeCode: string, hcPartyId: string, secretFKeys: string[]): never;
+    findDocumentsByHCPartyPatientForeignKeys(hcPartyId: string, secretFKeys: string[]): never;
+    findDocumentsByHCPartyPatientForeignKey(hcPartyId: string, secretFKey: string, startKey?: string, startDocumentId?: string, limit?: number): never;
+    findWithoutDelegation(limit?: number): never;
+    getDocument(documentId: string): never;
+    getDocumentByExternalUuid(externalUuid: string): never;
+    getDocuments(body?: ListOfIds): never;
+    getDocumentsByExternalUuid(externalUuid: string): never;
+    modifyDocument(body?: models.Document): never;
+    modifyDocuments(body?: Array<models.Document>): never;
+    setMainDocumentAttachment(documentId: string, documentRev: string, body: Object, utis?: Array<string>, dataIsEncrypted?: boolean): never;
+    setDocumentAttachmentBody(documentId: string, documentRev: string, enckeys?: null, body?: Object, utis?: string[]): never;
+    setDocumentAttachment(documentId: string, documentRev: string, enckeys?: null, body?: Object, utis?: string[]): never;
+    setDocumentAttachmentMulti(attachment: ArrayBuffer, documentRev: string, documentId: string, enckeys?: null): never;
+    setSecondaryAttachment(documentId: string, key: string, rev: string, attachment: Object, utis?: Array<string>, dataIsEncrypted?: boolean): never;
+    deleteSecondaryAttachment(documentId: string, key: string, rev: string): never;
 }

package/icc-x-api/icc-document-x-api.js

@@ -22,7 +22,7 @@ var AccessLevelEnum = SecureDelegation_1.SecureDelegation.AccessLevelEnum;
 const SecretIdUseOption_1 = require("./crypto/SecretIdUseOption");
 // noinspection JSUnusedGlobalSymbols
 class IccDocumentXApi extends icc_api_1.IccDocumentApi {
-    constructor(host, headers, crypto, authApi, dataOwnerApi, autofillAuthor, authenticationProvider = new AuthenticationProvider_1.NoAuthenticationProvider(), fetchImpl = typeof window !== 'undefined'
+    constructor(host, headers, crypto, authApi, dataOwnerApi, autofillAuthor, authenticationProvider = new AuthenticationProvider_1.NoAuthenticationProvider(), encryptedKeys = [], fetchImpl = typeof window !== 'undefined'
         ? window.fetch
         : typeof self !== 'undefined'
             ? self.fetch
@@ -423,6 +423,7 @@ class IccDocumentXApi extends icc_api_1.IccDocumentApi {
         this.fetchImpl = fetchImpl;
         this.authenticationProvider = authenticationProvider;
         this.dataOwnerApi = dataOwnerApi;
+        this.encryptedFields = (0, utils_1.parseEncryptedFields)(encryptedKeys, 'Document.');
     }
     get headers() {
         return super.headers.then((h) => this.crypto.accessControlKeysHeaders.addAccessControlKeysHeaders(h, utils_1.EntityWithDelegationTypeName.Document));
@@ -462,17 +463,6 @@ class IccDocumentXApi extends icc_api_1.IccDocumentApi {
         });
     }
     // noinspection JSUnusedGlobalSymbols
-    /**
-     * @deprecated use {@link findIdsByMessage} instead.
-     */
-    findByMessage(hcpartyId, message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const extractedKeys = yield this.crypto.xapi.secretIdsOf({ entity: message, type: utils_1.EntityWithDelegationTypeName.Message }, hcpartyId);
-            const topmostParentId = (yield this.dataOwnerApi.getCurrentDataOwnerHierarchyIds())[0];
-            let documents = yield this.findDocumentsByHCPartyPatientForeignKeys(topmostParentId, _.uniq(extractedKeys));
-            return yield this.decrypt(hcpartyId, documents);
-        });
-    }
     /**
      * Same as {@link findByMessage} but it will only return the ids of the contacts. It can also filter the documents where Document.created is between
      * startDate and endDate in ascending or descending order by that field. (default: ascending).
@@ -484,55 +474,14 @@ class IccDocumentXApi extends icc_api_1.IccDocumentApi {
             return this.findDocumentIdsByDataOwnerSecretForeignKey(topmostParentId, _.uniq(extractedKeys), startDate, endDate, descending);
         });
     }
-    // Note: this is only for dealing with legacy documents: new document are not encrypted, only their attachments are
-    decrypt(hcpartyId, documents) {
+    decrypt(documents) {
         return __awaiter(this, void 0, void 0, function* () {
-            const res = [];
-            for (const document of documents) {
-                const keys = yield this.crypto.xapi.encryptionKeysOf({ entity: document, type: utils_1.EntityWithDelegationTypeName.Document }, undefined);
-                if (!keys.length) {
-                    console.log('Cannot decrypt document', document.id);
-                    res.push(document);
-                }
-                else if (keys.length && (document.encryptedSelf || document.encryptedAttachment)) {
-                    const key = yield this.crypto.primitives.AES.importKey('raw', (0, binary_utils_1.hex2ua)(keys[0]));
-                    res.push(yield Promise.all([
-                        document.encryptedSelf
-                            ? new Promise((resolve) => {
-                                this.crypto.primitives.AES.decrypt(key, (0, binary_utils_1.string2ua)((0, binary_utils_1.a2b)(document.encryptedSelf))).then(resolve, () => {
-                                    console.log('Cannot decrypt document', document.id);
-                                    resolve(null);
-                                });
-                            })
-                            : Promise.resolve(null),
-                        document.encryptedAttachment
-                            ? new Promise((resolve) => {
-                                this.crypto.primitives.AES.decrypt(key, document.encryptedAttachment).then(resolve, () => {
-                                    console.log('Cannot decrypt document', document.id);
-                                    resolve(null);
-                                });
-                            })
-                            : Promise.resolve(null),
-                    ]).then((decrypted) => {
-                        let updatedDocument = Object.assign({}, document);
-                        if (decrypted) {
-                            if (decrypted[0]) {
-                                updatedDocument = _.extend(document, JSON.parse((0, binary_utils_1.ua2string)(decrypted[0])));
-                            }
-                            if (decrypted[1]) {
-                                updatedDocument.decryptedAttachment = decrypted[1];
-                            }
-                        }
-                        return updatedDocument;
-                    }));
-                }
-                else {
-                    res.push(document);
-                }
-            }
-            return res;
+            return yield this.crypto.xapi.tryDecryptEntities(documents, utils_1.EntityWithDelegationTypeName.Document, (x) => new models.Document(x));
         });
     }
+    encrypt(documents) {
+        return this.crypto.xapi.tryEncryptEntities(documents, utils_1.EntityWithDelegationTypeName.Document, this.encryptedFields, true, false, (x) => new models.Document(x));
+    }
     /**
      * @deprecated use getMainAttachmentAs instead
      */
@@ -610,12 +559,15 @@ class IccDocumentXApi extends icc_api_1.IccDocumentApi {
      * @return the updated document.
      */
     encryptAndSetDocumentAttachment(document, attachment, utis) {
+        const _super = Object.create(null, {
+            setMainDocumentAttachment: { get: () => super.setMainDocumentAttachment }
+        });
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             if (!document.rev)
                 throw new Error('Cannot set attachment on document without rev');
-            const { encryptedData, updatedEntity } = yield this.crypto.xapi.encryptDataOf(document, utils_1.EntityWithDelegationTypeName.Document, attachment, (d) => this.modifyDocument(d));
-            return yield this.setMainDocumentAttachment(document.id, (_a = updatedEntity === null || updatedEntity === void 0 ? void 0 : updatedEntity.rev) !== null && _a !== void 0 ? _a : document.rev, encryptedData, utis, true);
+            const { encryptedData, updatedEntity } = yield this.crypto.xapi.encryptDataOf(document, utils_1.EntityWithDelegationTypeName.Document, attachment, (d) => this.modifyDocumentWithUser(undefined, d));
+            return (yield this.decrypt([yield _super.setMainDocumentAttachment.call(this, document.id, (_a = updatedEntity === null || updatedEntity === void 0 ? void 0 : updatedEntity.rev) !== null && _a !== void 0 ? _a : document.rev, encryptedData, utis, true)]))[0].entity;
         });
     }
     /**
@@ -627,10 +579,13 @@ class IccDocumentXApi extends icc_api_1.IccDocumentApi {
      * @return the updated document.
      */
     setClearDocumentAttachment(document, attachment, utis) {
+        const _super = Object.create(null, {
+            setMainDocumentAttachment: { get: () => super.setMainDocumentAttachment }
+        });
         return __awaiter(this, void 0, void 0, function* () {
             if (!document.rev)
                 throw new Error('Cannot set attachment on document without rev');
-            return yield this.setMainDocumentAttachment(document.id, document.rev, attachment, utis, false);
+            return (yield this.decrypt([yield _super.setMainDocumentAttachment.call(this, document.id, document.rev, attachment, utis, false)]))[0].entity;
         });
     }
     /**
@@ -643,12 +598,17 @@ class IccDocumentXApi extends icc_api_1.IccDocumentApi {
      * @return the updated document.
      */
     encryptAndSetSecondaryDocumentAttachment(document, secondaryAttachmentKey, attachment, utis) {
+        const _super = Object.create(null, {
+            setSecondaryAttachment: { get: () => super.setSecondaryAttachment }
+        });
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             if (!document.rev)
                 throw new Error('Cannot set attachment on document without rev');
-            const { encryptedData, updatedEntity } = yield this.crypto.xapi.encryptDataOf(document, utils_1.EntityWithDelegationTypeName.Document, attachment, (d) => this.modifyDocument());
-            return yield this.setSecondaryAttachment(document.id, secondaryAttachmentKey, (_a = updatedEntity === null || updatedEntity === void 0 ? void 0 : updatedEntity.rev) !== null && _a !== void 0 ? _a : document.rev, encryptedData, utis, true);
+            const { encryptedData, updatedEntity } = yield this.crypto.xapi.encryptDataOf(document, utils_1.EntityWithDelegationTypeName.Document, attachment, (d) => this.modifyDocumentWithUser(undefined, d));
+            return (yield this.decrypt([
+                yield _super.setSecondaryAttachment.call(this, document.id, secondaryAttachmentKey, (_a = updatedEntity === null || updatedEntity === void 0 ? void 0 : updatedEntity.rev) !== null && _a !== void 0 ? _a : document.rev, encryptedData, utis, true),
+            ]))[0].entity;
         });
     }
     /**
@@ -661,8 +621,12 @@ class IccDocumentXApi extends icc_api_1.IccDocumentApi {
      * @return the updated document.
      */
     setClearSecondaryDocumentAttachment(document, secondaryAttachmentKey, attachment, utis) {
+        const _super = Object.create(null, {
+            setSecondaryAttachment: { get: () => super.setSecondaryAttachment }
+        });
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.setSecondaryAttachment(document.id, secondaryAttachmentKey, document.rev, attachment, utis, false);
+            return (yield this.decrypt([yield _super.setSecondaryAttachment.call(this, document.id, secondaryAttachmentKey, document.rev, attachment, utis, false)]))[0]
+                .entity;
         });
     }
     /**
@@ -690,8 +654,11 @@ class IccDocumentXApi extends icc_api_1.IccDocumentApi {
      * - wasDecrypted: if the data was successfully decrypted or not
      */
     getAndTryDecryptDocumentAttachment(document_1) {
+        const _super = Object.create(null, {
+            getRawMainDocumentAttachment: { get: () => super.getRawMainDocumentAttachment }
+        });
         return __awaiter(this, arguments, void 0, function* (document, validator = () => Promise.resolve(true)) {
-            return yield this.crypto.xapi.tryDecryptDataOf({ entity: document, type: utils_1.EntityWithDelegationTypeName.Document }, yield this.getRawMainDocumentAttachment(document.id), (x) => validator(x));
+            return yield this.crypto.xapi.tryDecryptDataOf({ entity: document, type: utils_1.EntityWithDelegationTypeName.Document }, yield _super.getRawMainDocumentAttachment.call(this, document.id), (x) => validator(x));
         });
     }
     /**
@@ -721,8 +688,11 @@ class IccDocumentXApi extends icc_api_1.IccDocumentApi {
      * - wasDecrypted: if the data was successfully decrypted or not
      */
     getAndTryDecryptSecondaryDocumentAttachment(document_1, secondaryAttachmentKey_1) {
+        const _super = Object.create(null, {
+            getSecondaryAttachment: { get: () => super.getSecondaryAttachment }
+        });
         return __awaiter(this, arguments, void 0, function* (document, secondaryAttachmentKey, validator = () => Promise.resolve(true)) {
-            return yield this.crypto.xapi.tryDecryptDataOf({ entity: document, type: utils_1.EntityWithDelegationTypeName.Document }, yield this.getSecondaryAttachment(document.id, secondaryAttachmentKey), (x) => validator(x));
+            return yield this.crypto.xapi.tryDecryptDataOf({ entity: document, type: utils_1.EntityWithDelegationTypeName.Document }, yield _super.getSecondaryAttachment.call(this, document.id, secondaryAttachmentKey), (x) => validator(x));
         });
     }
     /**
@@ -795,11 +765,14 @@ class IccDocumentXApi extends icc_api_1.IccDocumentApi {
      * the operation failed.
      */
     tryShareWithMany(document, delegates) {
+        const _super = Object.create(null, {
+            bulkShareDocument: { get: () => super.bulkShareDocument }
+        });
         return __awaiter(this, void 0, void 0, function* () {
             const self = yield this.dataOwnerApi.getCurrentDataOwnerId();
             // All entities should have an encryption key.
             const entityWithEncryptionKey = yield this.crypto.xapi.ensureEncryptionKeysInitialised(document, utils_1.EntityWithDelegationTypeName.Document);
-            const updatedEntity = entityWithEncryptionKey ? yield this.modifyDocument(entityWithEncryptionKey) : document;
+            const updatedEntity = entityWithEncryptionKey ? yield this.modifyDocumentWithUser(undefined, entityWithEncryptionKey) : document;
             return this.crypto.xapi
                 .simpleShareOrUpdateEncryptedEntityMetadata({
                 entity: updatedEntity,
@@ -812,8 +785,8 @@ class IccDocumentXApi extends icc_api_1.IccDocumentApi {
                     shareOwningEntityIds: options.shareMessageId,
                     shareSecretIds: options.shareSecretIds,
                 },
-            ])), (x) => this.bulkShareDocument(x))
-                .then((r) => r);
+            ])), (x) => _super.bulkShareDocument.call(this, x))
+                .then((r) => r.mapSuccessAsync((m) => __awaiter(this, void 0, void 0, function* () { return (yield this.decrypt([m]))[0].entity; })));
         });
     }
     getDataOwnersWithAccessTo(entity) {
@@ -825,6 +798,195 @@ class IccDocumentXApi extends icc_api_1.IccDocumentApi {
     createDelegationDeAnonymizationMetadata(entity, delegates) {
         return this.crypto.delegationsDeAnonymization.createOrUpdateDeAnonymizationInfo({ entity, type: utils_1.EntityWithDelegationTypeName.Document }, delegates);
     }
+    decryptPage(page) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            return Object.assign(Object.assign({}, page), { rows: (yield this.decrypt((_a = page.rows) !== null && _a !== void 0 ? _a : [])).map((x) => x.entity) });
+        });
+    }
+    createDocumentWithUser(user, body) {
+        const _super = Object.create(null, {
+            createDocument: { get: () => super.createDocument }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.decrypt([yield _super.createDocument.call(this, (yield this.encrypt([body]))[0])]))[0].entity;
+        });
+    }
+    deleteAttachmentWithUser(user, documentId) {
+        const _super = Object.create(null, {
+            deleteAttachment: { get: () => super.deleteAttachment }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.decrypt([yield _super.deleteAttachment.call(this, documentId)]))[0].entity;
+        });
+    }
+    /**
+     * @deprecated
+     */
+    findByTypeHCPartyMessageSecretFKeysWithUser(user, documentTypeCode, hcPartyId, secretFKeys) {
+        const _super = Object.create(null, {
+            findByTypeHCPartyMessageSecretFKeys: { get: () => super.findByTypeHCPartyMessageSecretFKeys }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.decrypt(yield _super.findByTypeHCPartyMessageSecretFKeys.call(this, documentTypeCode, hcPartyId, secretFKeys))).map((x) => x.entity);
+        });
+    }
+    /**
+     * @deprecated
+     */
+    findDocumentsByHCPartyPatientForeignKeysWithUser(user, hcPartyId, secretFKeys) {
+        const _super = Object.create(null, {
+            findDocumentsByHCPartyPatientForeignKeys: { get: () => super.findDocumentsByHCPartyPatientForeignKeys }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.decrypt(yield _super.findDocumentsByHCPartyPatientForeignKeys.call(this, hcPartyId, secretFKeys))).map((x) => x.entity);
+        });
+    }
+    /**
+     * @deprecated
+     */
+    findDocumentsByHCPartyPatientForeignKeyWithUser(user, hcPartyId, secretFKey, startKey, startDocumentId, limit) {
+        const _super = Object.create(null, {
+            findDocumentsByHCPartyPatientForeignKey: { get: () => super.findDocumentsByHCPartyPatientForeignKey }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.decryptPage(yield _super.findDocumentsByHCPartyPatientForeignKey.call(this, hcPartyId, secretFKey, startKey, startDocumentId, limit));
+        });
+    }
+    findWithoutDelegationWithUser(user, limit) {
+        const _super = Object.create(null, {
+            findWithoutDelegation: { get: () => super.findWithoutDelegation }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.decrypt(yield _super.findWithoutDelegation.call(this, limit))).map((x) => x.entity);
+        });
+    }
+    getDocumentWithUser(user, documentId) {
+        const _super = Object.create(null, {
+            getDocument: { get: () => super.getDocument }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.decrypt([yield _super.getDocument.call(this, documentId)]))[0].entity;
+        });
+    }
+    getDocumentByExternalUuidWithUser(user, externalUuid) {
+        const _super = Object.create(null, {
+            getDocumentByExternalUuid: { get: () => super.getDocumentByExternalUuid }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.decrypt([yield _super.getDocumentByExternalUuid.call(this, externalUuid)]))[0].entity;
+        });
+    }
+    getDocumentsWithUser(user, body) {
+        const _super = Object.create(null, {
+            getDocuments: { get: () => super.getDocuments }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.decrypt(yield _super.getDocuments.call(this, body))).map((x) => x.entity);
+        });
+    }
+    getDocumentsByExternalUuidWithUser(user, externalUuid) {
+        const _super = Object.create(null, {
+            getDocumentsByExternalUuid: { get: () => super.getDocumentsByExternalUuid }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.decrypt(yield _super.getDocumentsByExternalUuid.call(this, externalUuid))).map((x) => x.entity);
+        });
+    }
+    modifyDocumentWithUser(user, body) {
+        const _super = Object.create(null, {
+            modifyDocument: { get: () => super.modifyDocument }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.decrypt([yield _super.modifyDocument.call(this, (yield this.encrypt([body]))[0])]))[0].entity;
+        });
+    }
+    modifyDocumentsWithUser(user, body) {
+        const _super = Object.create(null, {
+            modifyDocuments: { get: () => super.modifyDocuments }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.decrypt(yield _super.modifyDocuments.call(this, yield this.encrypt(body)))).map((x) => x.entity);
+        });
+    }
+    setMainDocumentAttachmentWithUser(user, documentId, documentRev, body, utis, dataIsEncrypted) {
+        const _super = Object.create(null, {
+            setMainDocumentAttachment: { get: () => super.setMainDocumentAttachment }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.decrypt([yield _super.setMainDocumentAttachment.call(this, documentId, documentRev, body, utis, dataIsEncrypted)]))[0].entity;
+        });
+    }
+    setSecondaryAttachmentWithUser(user, documentId, key, rev, attachment, utis, dataIsEncrypted) {
+        const _super = Object.create(null, {
+            setSecondaryAttachment: { get: () => super.setSecondaryAttachment }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.decrypt([yield _super.setSecondaryAttachment.call(this, documentId, key, rev, attachment, utis, dataIsEncrypted)]))[0].entity;
+        });
+    }
+    deleteSecondaryAttachmentWithUser(user, documentId, key, rev) {
+        const _super = Object.create(null, {
+            deleteSecondaryAttachment: { get: () => super.deleteSecondaryAttachment }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.decrypt([yield _super.deleteSecondaryAttachment.call(this, documentId, key, rev)]))[0].entity;
+        });
+    }
+    createDocument(body) {
+        throw new Error('Use withUser method');
+    }
+    deleteAttachment(documentId) {
+        throw new Error('Use withUser method');
+    }
+    findByTypeHCPartyMessageSecretFKeys(documentTypeCode, hcPartyId, secretFKeys) {
+        throw new Error('Use withUser method');
+    }
+    findDocumentsByHCPartyPatientForeignKeys(hcPartyId, secretFKeys) {
+        throw new Error('Use withUser method');
+    }
+    findDocumentsByHCPartyPatientForeignKey(hcPartyId, secretFKey, startKey, startDocumentId, limit) {
+        throw new Error('Use withUser method');
+    }
+    findWithoutDelegation(limit) {
+        throw new Error('Use withUser method');
+    }
+    getDocument(documentId) {
+        throw new Error('Use withUser method');
+    }
+    getDocumentByExternalUuid(externalUuid) {
+        throw new Error('Use withUser method');
+    }
+    getDocuments(body) {
+        throw new Error('Use withUser method');
+    }
+    getDocumentsByExternalUuid(externalUuid) {
+        throw new Error('Use withUser method');
+    }
+    modifyDocument(body) {
+        throw new Error('Use withUser method');
+    }
+    modifyDocuments(body) {
+        throw new Error('Use withUser method');
+    }
+    setMainDocumentAttachment(documentId, documentRev, body, utis, dataIsEncrypted) {
+        throw new Error('Use withUser method');
+    }
+    setDocumentAttachmentBody(documentId, documentRev, enckeys, body, utis) {
+        throw new Error('Use withUser method');
+    }
+    setDocumentAttachment(documentId, documentRev, enckeys, body, utis) {
+        throw new Error('Use withUser method');
+    }
+    setDocumentAttachmentMulti(attachment, documentRev, documentId, enckeys) {
+        throw new Error('Use withUser method');
+    }
+    setSecondaryAttachment(documentId, key, rev, attachment, utis, dataIsEncrypted) {
+        throw new Error('Use withUser method');
+    }
+    deleteSecondaryAttachment(documentId, key, rev) {
+        throw new Error('Use withUser method');
+    }
 }
 exports.IccDocumentXApi = IccDocumentXApi;
 //# sourceMappingURL=icc-document-x-api.js.map