@icure/api 7.1.16 → 8.0.0-RC.2

package/icc-api/model/requests/EntityBulkShareResult.d.ts

@@ -0,0 +1,28 @@
+import { RejectedShareOrMetadataUpdateRequest } from './RejectedShareOrMetadataUpdateRequest';
+import { EncryptedEntity } from '../models';
+/**
+ * Result of a bulk share operation.
+ */
+export declare class EntityBulkShareResult<T extends EncryptedEntity> {
+    constructor(json: JSON | any, entityConstructor: new (json: JSON | any) => T);
+    /**
+     * The updated entity. Non-null if at least one of the requests succeeded.
+     */
+    updatedEntity?: T;
+    /**
+     * Id of the entity for which the update was requested.
+     */
+    entityId: string;
+    /**
+     * Last known revision of the entity before any update, non-null only if an entity matching the requests could be
+     * found. This can help to understand if an error is caused by an outdated version of the entity on the client-side.
+     */
+    entityRev?: string;
+    /**
+     * If a `bulkShare` method fails to apply any of the share requests for an entity this map associates the id of the
+     * original failed request to the reason of failure.
+     */
+    rejectedRequests?: {
+        [requestId: string]: RejectedShareOrMetadataUpdateRequest;
+    };
+}

package/icc-api/model/requests/EntityBulkShareResult.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityBulkShareResult = void 0;
+/**
+ * Result of a bulk share operation.
+ */
+class EntityBulkShareResult {
+    constructor(json, entityConstructor) {
+        Object.assign(this, json);
+        if (json['updatedEntity']) {
+            this.updatedEntity = new entityConstructor(json['updatedEntity']);
+        }
+    }
+}
+exports.EntityBulkShareResult = EntityBulkShareResult;
+//# sourceMappingURL=EntityBulkShareResult.js.map

package/icc-api/model/requests/EntityBulkShareResult.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityBulkShareResult.js","sourceRoot":"","sources":["../../../../icc-api/model/requests/EntityBulkShareResult.ts"],"names":[],"mappings":";;;AAGA;;GAEG;AACH,MAAa,qBAAqB;IAChC,YAAY,IAAgB,EAAE,iBAA8C;QAC1E,MAAM,CAAC,MAAM,CAAC,IAAgC,EAAE,IAAI,CAAC,CAAA;QACrD,IAAI,IAAI,CAAC,eAAe,CAAC,EAAE;YACzB,IAAI,CAAC,aAAa,GAAG,IAAI,iBAAiB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,CAAA;SAClE;IACH,CAAC;CAoBF;AA1BD,sDA0BC","sourcesContent":["import { RejectedShareOrMetadataUpdateRequest } from './RejectedShareOrMetadataUpdateRequest'\nimport { EncryptedEntity } from '../models'\n\n/**\n * Result of a bulk share operation.\n */\nexport class EntityBulkShareResult<T extends EncryptedEntity> {\n  constructor(json: JSON | any, entityConstructor: new (json: JSON | any) => T) {\n    Object.assign(this as EntityBulkShareResult<T>, json)\n    if (json['updatedEntity']) {\n      this.updatedEntity = new entityConstructor(json['updatedEntity'])\n    }\n  }\n\n  /**\n   * The updated entity. Non-null if at least one of the requests succeeded.\n   */\n  updatedEntity?: T\n  /**\n   * Id of the entity for which the update was requested.\n   */\n  entityId!: string\n  /**\n   * Last known revision of the entity before any update, non-null only if an entity matching the requests could be\n   * found. This can help to understand if an error is caused by an outdated version of the entity on the client-side.\n   */\n  entityRev?: string\n  /**\n   * If a `bulkShare` method fails to apply any of the share requests for an entity this map associates the id of the\n   * original failed request to the reason of failure.\n   */\n  rejectedRequests?: { [requestId: string]: RejectedShareOrMetadataUpdateRequest }\n}\n"]}

package/icc-api/model/requests/EntityShareOrMetadataUpdateRequest.d.ts

@@ -0,0 +1,10 @@
+import { EntityShareRequest } from './EntityShareRequest';
+import { EntitySharedMetadataUpdateRequest } from './EntitySharedMetadataUpdateRequest';
+export declare class EntityShareOrMetadataUpdateRequest {
+    constructor(params: {
+        share?: EntityShareRequest;
+        update?: EntitySharedMetadataUpdateRequest;
+    });
+    share?: EntityShareRequest;
+    update?: EntitySharedMetadataUpdateRequest;
+}

package/icc-api/model/requests/EntityShareOrMetadataUpdateRequest.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityShareOrMetadataUpdateRequest = void 0;
+class EntityShareOrMetadataUpdateRequest {
+    constructor(params) {
+        if (params.share && !params.update) {
+            this.share = params.share;
+        }
+        else if (!params.share && params.update) {
+            this.update = params.update;
+        }
+        else
+            throw new Error('Exactly one of share or update should be set');
+    }
+}
+exports.EntityShareOrMetadataUpdateRequest = EntityShareOrMetadataUpdateRequest;
+//# sourceMappingURL=EntityShareOrMetadataUpdateRequest.js.map

package/icc-api/model/requests/EntityShareOrMetadataUpdateRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityShareOrMetadataUpdateRequest.js","sourceRoot":"","sources":["../../../../icc-api/model/requests/EntityShareOrMetadataUpdateRequest.ts"],"names":[],"mappings":";;;AAGA,MAAa,kCAAkC;IAC7C,YAAY,MAAkF;QAC5F,IAAI,MAAM,CAAC,KAAK,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE;YAClC,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAA;SAC1B;aAAM,IAAI,CAAC,MAAM,CAAC,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE;YACzC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAA;SAC5B;;YAAM,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAA;IACxE,CAAC;CAIF;AAXD,gFAWC","sourcesContent":["import { EntityShareRequest } from './EntityShareRequest'\nimport { EntitySharedMetadataUpdateRequest } from './EntitySharedMetadataUpdateRequest'\n\nexport class EntityShareOrMetadataUpdateRequest {\n  constructor(params: { share?: EntityShareRequest; update?: EntitySharedMetadataUpdateRequest }) {\n    if (params.share && !params.update) {\n      this.share = params.share\n    } else if (!params.share && params.update) {\n      this.update = params.update\n    } else throw new Error('Exactly one of share or update should be set')\n  }\n\n  share?: EntityShareRequest\n  update?: EntitySharedMetadataUpdateRequest\n}\n"]}

package/icc-api/model/requests/EntityShareRequest.d.ts

@@ -0,0 +1,110 @@
+export declare class EntityShareRequest {
+    constructor(params: {
+        explicitDelegator?: string;
+        explicitDelegate?: string;
+        accessControlKeys: string[];
+        secretIds?: string[];
+        encryptionKeys?: string[];
+        owningEntityIds?: string[];
+        exchangeDataId?: string;
+        encryptedExchangeDataId?: {
+            [fp: string]: string;
+        };
+        requestedPermissions?: EntityShareRequest.RequestedPermissionInternal;
+    });
+    /**
+     * Id of the data owner which is sharing the entity (delegator), if it should be explicitly indicated or null if the
+     * delegator requires anonymous delegations. If not null this must match the logged data owner id.
+     */
+    explicitDelegator?: string;
+    /**
+     * Id of the data owner which will gain access to the entity (delegate), if it should be explicitly indicated or
+     * null if the delegate requires anonymous delegations.
+     */
+    explicitDelegate?: string;
+    /**
+     * The access control keys obtained from the access control secrets of the exchange data used for the encryption of the ids and keys
+     * to share. These are also used to uniquely identify an instance of share metadata.
+     */
+    accessControlKeys: string[];
+    /**
+     * Encrypted secret ids to share with the delegate.
+     */
+    secretIds?: string[];
+    /**
+     * Encrypted encryption keys to share with the delegate.
+     */
+    encryptionKeys?: string[];
+    /**
+     * Encrypted owning entity ids to share with the delegate.
+     */
+    owningEntityIds?: string[];
+    /**
+     * Id of the exchange data used for the encryption of the ids and keys to share. Must be null at least one of
+     * delegator or delegate is not explicit.
+     */
+    exchangeDataId?: string;
+    /**
+     * Must be non-empty if exactly one of delegator or delegate is explicit and the other is not, empty in all other
+     * cases.
+     */
+    encryptedExchangeDataId?: {
+        [fp: string]: string;
+    };
+    /**
+     * Permissions requested for the delegate.
+     */
+    requestedPermissions: EntityShareRequest.RequestedPermissionInternal;
+}
+export declare namespace EntityShareRequest {
+    /**
+     * Strategy to use for the calculation of permissions for the new [SecureDelegation.permissions]
+     */
+    type RequestedPermissionEnum = 'FULL_READ' | 'MAX_WRITE' | 'FULL_WRITE';
+    const RequestedPermissionEnum: {
+        /**
+         * The new secure delegation will give full-read access to the delegate. If in future iCure is going to support
+         * fine-grained access control a user may have limited read access to an entity, and in such case the request
+         * would fail (similarly to [FULL_WRITE]).
+         */
+        FULL_READ: RequestedPermissionEnum;
+        /**
+         * The new secure delegation will give maximum access to the delegate, depending on the rights of the delegator.
+         * If the delegator has full-write access the delegate will also have full-write access else the delegate will
+         * have full-read access.
+         */
+        MAX_WRITE: RequestedPermissionEnum;
+        /**
+         * The new secure delegation will give full-write access to the delegate. If the delegator does not have
+         * full-write access to the entity the request will fail.
+         */
+        FULL_WRITE: RequestedPermissionEnum;
+    };
+    /**
+     * @internal this type is for internal use only and may be changed without notice.
+     * Additional values for requested permissions which are used automatically by the extended apis and should not
+     * be used directly by the user.
+     */
+    type RequestedPermissionInternal = 'ROOT' | RequestedPermissionEnum;
+    const RequestedPermissionInternal: {
+        /**
+         * Request to create a root delegation on the entity. Usually new entities are created with a root delegation
+         * for the creator data owner and no other data owners will be able to obtain root permissions, but there are
+         * some situations where other data owners can create root delegations on existing entities:
+         * - If a data owner has a legacy delegation on an entity he can create a root delegation. This is necessary in
+         * cases where the data owner wants to share an entity with another data owner using the new delegation format
+         * but does not have a delegation in the new format yet (the data owner creates a new root delegation self->self
+         * and then creates a delegation self->other).
+         * - A patient data owner is always allowed to create a root delegation for himself
+         *
+         * A root delegation gives full write permissions to the data owners which can access it (usually a root
+         * delegation should be accessible only for one data owner, it should be a delegation a->a) and does not depend
+         * on any other delegation: this means that no data owners except for the data owners with the root permission
+         * can revoke it.
+         */
+        ROOT: RequestedPermissionInternal;
+        FULL_READ: RequestedPermissionInternal;
+        MAX_WRITE: RequestedPermissionInternal;
+        FULL_WRITE: RequestedPermissionInternal;
+    };
+}

package/icc-api/model/requests/EntityShareRequest.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityShareRequest = void 0;
+class EntityShareRequest {
+    constructor(params) {
+        var _a;
+        if (!params.accessControlKeys.length)
+            throw new Error('Access control keys should not be empty');
+        this.explicitDelegator = params.explicitDelegator;
+        this.explicitDelegate = params.explicitDelegate;
+        this.accessControlKeys = params.accessControlKeys;
+        this.secretIds = params.secretIds;
+        this.encryptionKeys = params.encryptionKeys;
+        this.owningEntityIds = params.owningEntityIds;
+        this.exchangeDataId = params.exchangeDataId;
+        this.encryptedExchangeDataId = params.encryptedExchangeDataId;
+        this.requestedPermissions = (_a = params.requestedPermissions) !== null && _a !== void 0 ? _a : EntityShareRequest.RequestedPermissionInternal.MAX_WRITE;
+    }
+}
+exports.EntityShareRequest = EntityShareRequest;
+(function (EntityShareRequest) {
+    EntityShareRequest.RequestedPermissionEnum = {
+        /**
+         * The new secure delegation will give full-read access to the delegate. If in future iCure is going to support
+         * fine-grained access control a user may have limited read access to an entity, and in such case the request
+         * would fail (similarly to [FULL_WRITE]).
+         */
+        FULL_READ: 'FULL_READ',
+        /**
+         * The new secure delegation will give maximum access to the delegate, depending on the rights of the delegator.
+         * If the delegator has full-write access the delegate will also have full-write access else the delegate will
+         * have full-read access.
+         */
+        MAX_WRITE: 'MAX_WRITE',
+        /**
+         * The new secure delegation will give full-write access to the delegate. If the delegator does not have
+         * full-write access to the entity the request will fail.
+         */
+        FULL_WRITE: 'FULL_WRITE',
+    };
+    EntityShareRequest.RequestedPermissionInternal = {
+        /**
+         * Request to create a root delegation on the entity. Usually new entities are created with a root delegation
+         * for the creator data owner and no other data owners will be able to obtain root permissions, but there are
+         * some situations where other data owners can create root delegations on existing entities:
+         * - If a data owner has a legacy delegation on an entity he can create a root delegation. This is necessary in
+         * cases where the data owner wants to share an entity with another data owner using the new delegation format
+         * but does not have a delegation in the new format yet (the data owner creates a new root delegation self->self
+         * and then creates a delegation self->other).
+         * - A patient data owner is always allowed to create a root delegation for himself
+         *
+         * A root delegation gives full write permissions to the data owners which can access it (usually a root
+         * delegation should be accessible only for one data owner, it should be a delegation a->a) and does not depend
+         * on any other delegation: this means that no data owners except for the data owners with the root permission
+         * can revoke it.
+         */
+        ROOT: 'ROOT',
+        FULL_READ: EntityShareRequest.RequestedPermissionEnum.FULL_READ,
+        MAX_WRITE: EntityShareRequest.RequestedPermissionEnum.MAX_WRITE,
+        FULL_WRITE: EntityShareRequest.RequestedPermissionEnum.FULL_WRITE,
+    };
+})(EntityShareRequest = exports.EntityShareRequest || (exports.EntityShareRequest = {}));
+//# sourceMappingURL=EntityShareRequest.js.map

package/icc-api/model/requests/EntityShareRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityShareRequest.js","sourceRoot":"","sources":["../../../../icc-api/model/requests/EntityShareRequest.ts"],"names":[],"mappings":";;;AAAA,MAAa,kBAAkB;IAC7B,YAAY,MAUX;;QACC,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,MAAM;YAAE,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAA;QAChG,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC,iBAAiB,CAAA;QACjD,IAAI,CAAC,gBAAgB,GAAG,MAAM,CAAC,gBAAgB,CAAA;QAC/C,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC,iBAAiB,CAAA;QACjD,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAA;QACjC,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC,cAAc,CAAA;QAC3C,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC,eAAe,CAAA;QAC7C,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC,cAAc,CAAA;QAC3C,IAAI,CAAC,uBAAuB,GAAG,MAAM,CAAC,uBAAuB,CAAA;QAC7D,IAAI,CAAC,oBAAoB,GAAG,MAAA,MAAM,CAAC,oBAAoB,mCAAI,kBAAkB,CAAC,2BAA2B,CAAC,SAAS,CAAA;IACrH,CAAC;CA2CF;AAjED,gDAiEC;AAED,WAAiB,kBAAkB;IAKpB,0CAAuB,GAAG;QACrC;;;;WAIG;QACH,SAAS,EAAE,WAAsC;QAEjD;;;;WAIG;QACH,SAAS,EAAE,WAAsC;QAEjD;;;WAGG;QACH,UAAU,EAAE,YAAuC;KACpD,CAAA;IAQY,8CAA2B,GAAG;QACzC;;;;;;;;;;;;;;WAcG;QACH,IAAI,EAAE,MAAqC;QAC3C,SAAS,EAAE,mBAAA,uBAAuB,CAAC,SAAwC;QAC3E,SAAS,EAAE,mBAAA,uBAAuB,CAAC,SAAwC;QAC3E,UAAU,EAAE,mBAAA,uBAAuB,CAAC,UAAyC;KAC9E,CAAA;AACH,CAAC,EAtDgB,kBAAkB,GAAlB,0BAAkB,KAAlB,0BAAkB,QAsDlC","sourcesContent":["export class EntityShareRequest {\n  constructor(params: {\n    explicitDelegator?: string\n    explicitDelegate?: string\n    accessControlKeys: string[]\n    secretIds?: string[]\n    encryptionKeys?: string[]\n    owningEntityIds?: string[]\n    exchangeDataId?: string\n    encryptedExchangeDataId?: { [fp: string]: string }\n    requestedPermissions?: EntityShareRequest.RequestedPermissionInternal\n  }) {\n    if (!params.accessControlKeys.length) throw new Error('Access control keys should not be empty')\n    this.explicitDelegator = params.explicitDelegator\n    this.explicitDelegate = params.explicitDelegate\n    this.accessControlKeys = params.accessControlKeys\n    this.secretIds = params.secretIds\n    this.encryptionKeys = params.encryptionKeys\n    this.owningEntityIds = params.owningEntityIds\n    this.exchangeDataId = params.exchangeDataId\n    this.encryptedExchangeDataId = params.encryptedExchangeDataId\n    this.requestedPermissions = params.requestedPermissions ?? EntityShareRequest.RequestedPermissionInternal.MAX_WRITE\n  }\n\n  /**\n   * Id of the data owner which is sharing the entity (delegator), if it should be explicitly indicated or null if the\n   * delegator requires anonymous delegations. If not null this must match the logged data owner id.\n   */\n  explicitDelegator?: string\n  /**\n   * Id of the data owner which will gain access to the entity (delegate), if it should be explicitly indicated or\n   * null if the delegate requires anonymous delegations.\n   */\n  explicitDelegate?: string\n  /**\n   * The access control keys obtained from the access control secrets of the exchange data used for the encryption of the ids and keys\n   * to share. These are also used to uniquely identify an instance of share metadata.\n   */\n  accessControlKeys: string[]\n  /**\n   * Encrypted secret ids to share with the delegate.\n   */\n  secretIds?: string[]\n  /**\n   * Encrypted encryption keys to share with the delegate.\n   */\n  encryptionKeys?: string[]\n  /**\n   * Encrypted owning entity ids to share with the delegate.\n   */\n  owningEntityIds?: string[]\n  /**\n   * Id of the exchange data used for the encryption of the ids and keys to share. Must be null at least one of\n   * delegator or delegate is not explicit.\n   */\n  exchangeDataId?: string\n  /**\n   * Must be non-empty if exactly one of delegator or delegate is explicit and the other is not, empty in all other\n   * cases.\n   */\n  encryptedExchangeDataId?: { [fp: string]: string }\n  /**\n   * Permissions requested for the delegate.\n   */\n  requestedPermissions: EntityShareRequest.RequestedPermissionInternal\n}\n\nexport namespace EntityShareRequest {\n  /**\n   * Strategy to use for the calculation of permissions for the new [SecureDelegation.permissions]\n   */\n  export type RequestedPermissionEnum = 'FULL_READ' | 'MAX_WRITE' | 'FULL_WRITE'\n  export const RequestedPermissionEnum = {\n    /**\n     * The new secure delegation will give full-read access to the delegate. If in future iCure is going to support\n     * fine-grained access control a user may have limited read access to an entity, and in such case the request\n     * would fail (similarly to [FULL_WRITE]).\n     */\n    FULL_READ: 'FULL_READ' as RequestedPermissionEnum,\n\n    /**\n     * The new secure delegation will give maximum access to the delegate, depending on the rights of the delegator.\n     * If the delegator has full-write access the delegate will also have full-write access else the delegate will\n     * have full-read access.\n     */\n    MAX_WRITE: 'MAX_WRITE' as RequestedPermissionEnum,\n\n    /**\n     * The new secure delegation will give full-write access to the delegate. If the delegator does not have\n     * full-write access to the entity the request will fail.\n     */\n    FULL_WRITE: 'FULL_WRITE' as RequestedPermissionEnum,\n  }\n\n  /**\n   * @internal this type is for internal use only and may be changed without notice.\n   * Additional values for requested permissions which are used automatically by the extended apis and should not\n   * be used directly by the user.\n   */\n  export type RequestedPermissionInternal = 'ROOT' | RequestedPermissionEnum\n  export const RequestedPermissionInternal = {\n    /**\n     * Request to create a root delegation on the entity. Usually new entities are created with a root delegation\n     * for the creator data owner and no other data owners will be able to obtain root permissions, but there are\n     * some situations where other data owners can create root delegations on existing entities:\n     * - If a data owner has a legacy delegation on an entity he can create a root delegation. This is necessary in\n     * cases where the data owner wants to share an entity with another data owner using the new delegation format\n     * but does not have a delegation in the new format yet (the data owner creates a new root delegation self->self\n     * and then creates a delegation self->other).\n     * - A patient data owner is always allowed to create a root delegation for himself\n     *\n     * A root delegation gives full write permissions to the data owners which can access it (usually a root\n     * delegation should be accessible only for one data owner, it should be a delegation a->a) and does not depend\n     * on any other delegation: this means that no data owners except for the data owners with the root permission\n     * can revoke it.\n     */\n    ROOT: 'ROOT' as RequestedPermissionInternal,\n    FULL_READ: RequestedPermissionEnum.FULL_READ as RequestedPermissionInternal,\n    MAX_WRITE: RequestedPermissionEnum.MAX_WRITE as RequestedPermissionInternal,\n    FULL_WRITE: RequestedPermissionEnum.FULL_WRITE as RequestedPermissionInternal,\n  }\n}\n"]}

package/icc-api/model/requests/EntitySharedMetadataUpdateRequest.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Parameters for the update of shared metadata. Currently only changes to secret ids, encryption keys and owning entity
+ * ids are allowed. In the future we are going to allow also changes to the permissions of users with access to the
+ * shared metadata.
+ */
+export declare class EntitySharedMetadataUpdateRequest {
+    constructor(params: {
+        metadataAccessControlHash: string;
+        secretIds?: {
+            [encryptedData: string]: EntitySharedMetadataUpdateRequest.EntryUpdateTypeEnum;
+        };
+        encryptionKeys?: {
+            [encryptedData: string]: EntitySharedMetadataUpdateRequest.EntryUpdateTypeEnum;
+        };
+        owningEntityIds?: {
+            [encryptedData: string]: EntitySharedMetadataUpdateRequest.EntryUpdateTypeEnum;
+        };
+    });
+    /**
+     * Access control hash of the metadata to update.
+     */
+    metadataAccessControlHash: string;
+    /**
+     * Updates for secret ids: the key is an encrypted secret id and the value is if an entry with that encrypted secret
+     * id should be created or deleted.
+     */
+    secretIds?: {
+        [encryptedData: string]: EntitySharedMetadataUpdateRequest.EntryUpdateTypeEnum;
+    };
+    /**
+     * Updates for encryption keys: a key in the map is an encrypted encrpytion key and the value is if an entry with
+     * that encrypted encryption key should be created or deleted.
+     */
+    encryptionKeys?: {
+        [encryptedData: string]: EntitySharedMetadataUpdateRequest.EntryUpdateTypeEnum;
+    };
+    /**
+     * Updates for owning entity ids: the key is the encrypted id of an owning entity and the value is if an entry with
+     * that encrypted owning entity id should be created or deleted.
+     */
+    owningEntityIds?: {
+        [encryptedData: string]: EntitySharedMetadataUpdateRequest.EntryUpdateTypeEnum;
+    };
+}
+export declare namespace EntitySharedMetadataUpdateRequest {
+    /**
+     * Specifies if an entry should be created anew or deleted
+     */
+    type EntryUpdateTypeEnum = 'CREATE' | 'DELETE';
+    const EntryUpdateTypeEnum: {
+        CREATE: EntryUpdateTypeEnum;
+        DELETE: EntryUpdateTypeEnum;
+    };
+}

package/icc-api/model/requests/EntitySharedMetadataUpdateRequest.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntitySharedMetadataUpdateRequest = void 0;
+/**
+ * Parameters for the update of shared metadata. Currently only changes to secret ids, encryption keys and owning entity
+ * ids are allowed. In the future we are going to allow also changes to the permissions of users with access to the
+ * shared metadata.
+ */
+class EntitySharedMetadataUpdateRequest {
+    constructor(params) {
+        this.metadataAccessControlHash = params.metadataAccessControlHash;
+        this.secretIds = params.secretIds;
+        this.encryptionKeys = params.encryptionKeys;
+        this.owningEntityIds = params.owningEntityIds;
+    }
+}
+exports.EntitySharedMetadataUpdateRequest = EntitySharedMetadataUpdateRequest;
+(function (EntitySharedMetadataUpdateRequest) {
+    EntitySharedMetadataUpdateRequest.EntryUpdateTypeEnum = {
+        CREATE: 'CREATE',
+        DELETE: 'DELETE',
+    };
+})(EntitySharedMetadataUpdateRequest = exports.EntitySharedMetadataUpdateRequest || (exports.EntitySharedMetadataUpdateRequest = {}));
+//# sourceMappingURL=EntitySharedMetadataUpdateRequest.js.map

package/icc-api/model/requests/EntitySharedMetadataUpdateRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntitySharedMetadataUpdateRequest.js","sourceRoot":"","sources":["../../../../icc-api/model/requests/EntitySharedMetadataUpdateRequest.ts"],"names":[],"mappings":";;;AAAA;;;;GAIG;AACH,MAAa,iCAAiC;IAC5C,YAAY,MAKX;QACC,IAAI,CAAC,yBAAyB,GAAG,MAAM,CAAC,yBAAyB,CAAA;QACjE,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAA;QACjC,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC,cAAc,CAAA;QAC3C,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC,eAAe,CAAA;IAC/C,CAAC;CAqBF;AAhCD,8EAgCC;AACD,WAAiB,iCAAiC;IAKnC,qDAAmB,GAAG;QACjC,MAAM,EAAE,QAA+B;QACvC,MAAM,EAAE,QAA+B;KACxC,CAAA;AACH,CAAC,EATgB,iCAAiC,GAAjC,yCAAiC,KAAjC,yCAAiC,QASjD","sourcesContent":["/**\n * Parameters for the update of shared metadata. Currently only changes to secret ids, encryption keys and owning entity\n * ids are allowed. In the future we are going to allow also changes to the permissions of users with access to the\n * shared metadata.\n */\nexport class EntitySharedMetadataUpdateRequest {\n  constructor(params: {\n    metadataAccessControlHash: string\n    secretIds?: { [encryptedData: string]: EntitySharedMetadataUpdateRequest.EntryUpdateTypeEnum }\n    encryptionKeys?: { [encryptedData: string]: EntitySharedMetadataUpdateRequest.EntryUpdateTypeEnum }\n    owningEntityIds?: { [encryptedData: string]: EntitySharedMetadataUpdateRequest.EntryUpdateTypeEnum }\n  }) {\n    this.metadataAccessControlHash = params.metadataAccessControlHash\n    this.secretIds = params.secretIds\n    this.encryptionKeys = params.encryptionKeys\n    this.owningEntityIds = params.owningEntityIds\n  }\n\n  /**\n   * Access control hash of the metadata to update.\n   */\n  metadataAccessControlHash: string\n  /**\n   * Updates for secret ids: the key is an encrypted secret id and the value is if an entry with that encrypted secret\n   * id should be created or deleted.\n   */\n  secretIds?: { [encryptedData: string]: EntitySharedMetadataUpdateRequest.EntryUpdateTypeEnum }\n  /**\n   * Updates for encryption keys: a key in the map is an encrypted encrpytion key and the value is if an entry with\n   * that encrypted encryption key should be created or deleted.\n   */\n  encryptionKeys?: { [encryptedData: string]: EntitySharedMetadataUpdateRequest.EntryUpdateTypeEnum }\n  /**\n   * Updates for owning entity ids: the key is the encrypted id of an owning entity and the value is if an entry with\n   * that encrypted owning entity id should be created or deleted.\n   */\n  owningEntityIds?: { [encryptedData: string]: EntitySharedMetadataUpdateRequest.EntryUpdateTypeEnum }\n}\nexport namespace EntitySharedMetadataUpdateRequest {\n  /**\n   * Specifies if an entry should be created anew or deleted\n   */\n  export type EntryUpdateTypeEnum = 'CREATE' | 'DELETE'\n  export const EntryUpdateTypeEnum = {\n    CREATE: 'CREATE' as EntryUpdateTypeEnum,\n    DELETE: 'DELETE' as EntryUpdateTypeEnum,\n  }\n}\n"]}

package/icc-api/model/requests/MinimalEntityBulkShareResult.d.ts

@@ -0,0 +1,23 @@
+import { RejectedShareOrMetadataUpdateRequest } from './RejectedShareOrMetadataUpdateRequest';
+/**
+ * Result of a bulk share operation.
+ */
+export declare class MinimalEntityBulkShareResult {
+    constructor(json: JSON | any);
+    /**
+     * Id of the entity for which the update was requested.
+     */
+    entityId: string;
+    /**
+     * Last known revision of the entity before any update, non-null only if an entity matching the requests could be
+     * found. This can help to understand if an error is caused by an outdated version of the entity on the client-side.
+     */
+    entityRev?: string;
+    /**
+     * If a `bulkShare` method fails to apply any of the share requests for an entity this map associates the id of the
+     * original failed request to the reason of failure.
+     */
+    rejectedRequests?: {
+        [requestId: string]: RejectedShareOrMetadataUpdateRequest;
+    };
+}

package/icc-api/model/requests/MinimalEntityBulkShareResult.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinimalEntityBulkShareResult = void 0;
+/**
+ * Result of a bulk share operation.
+ */
+class MinimalEntityBulkShareResult {
+    constructor(json) {
+        Object.assign(this, json);
+    }
+}
+exports.MinimalEntityBulkShareResult = MinimalEntityBulkShareResult;
+//# sourceMappingURL=MinimalEntityBulkShareResult.js.map

package/icc-api/model/requests/MinimalEntityBulkShareResult.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MinimalEntityBulkShareResult.js","sourceRoot":"","sources":["../../../../icc-api/model/requests/MinimalEntityBulkShareResult.ts"],"names":[],"mappings":";;;AAGA;;GAEG;AACH,MAAa,4BAA4B;IACvC,YAAY,IAAgB;QAC1B,MAAM,CAAC,MAAM,CAAC,IAAoC,EAAE,IAAI,CAAC,CAAA;IAC3D,CAAC;CAgBF;AAnBD,oEAmBC","sourcesContent":["import { RejectedShareOrMetadataUpdateRequest } from './RejectedShareOrMetadataUpdateRequest'\nimport { EncryptedEntity } from '../models'\n\n/**\n * Result of a bulk share operation.\n */\nexport class MinimalEntityBulkShareResult {\n  constructor(json: JSON | any) {\n    Object.assign(this as MinimalEntityBulkShareResult, json)\n  }\n\n  /**\n   * Id of the entity for which the update was requested.\n   */\n  entityId!: string\n  /**\n   * Last known revision of the entity before any update, non-null only if an entity matching the requests could be\n   * found. This can help to understand if an error is caused by an outdated version of the entity on the client-side.\n   */\n  entityRev?: string\n  /**\n   * If a `bulkShare` method fails to apply any of the share requests for an entity this map associates the id of the\n   * original failed request to the reason of failure.\n   */\n  rejectedRequests?: { [requestId: string]: RejectedShareOrMetadataUpdateRequest }\n}\n"]}

package/icc-api/model/requests/RejectedShareOrMetadataUpdateRequest.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Represents a reason why a share requests failed or was rejected.
+ */
+export declare class RejectedShareOrMetadataUpdateRequest {
+    constructor(json: JSON | any);
+    /**
+     * Code of the error, mimics an http status code (400 general user error, 409 conflict, ...).
+     */
+    code?: number;
+    /**
+     * If true a new share request with the same content may succeed so the user is encouraged to retry. This could
+     * happen if the entity to share changed while verifying the validity of the request (correctness, permissions,
+     * ...), and if the entity did not change in ways incompatible with the request re-performing the request in
+     * the same way may succeed.
+     */
+    shouldRetry: boolean;
+    /**
+     * Human-friendly message explaining the reason of the failure.
+     */
+    reason?: string;
+}

package/icc-api/model/requests/RejectedShareOrMetadataUpdateRequest.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RejectedShareOrMetadataUpdateRequest = void 0;
+/**
+ * Represents a reason why a share requests failed or was rejected.
+ */
+class RejectedShareOrMetadataUpdateRequest {
+    constructor(json) {
+        Object.assign(this, json);
+        this.shouldRetry = !!json['shouldRetry'];
+    }
+}
+exports.RejectedShareOrMetadataUpdateRequest = RejectedShareOrMetadataUpdateRequest;
+//# sourceMappingURL=RejectedShareOrMetadataUpdateRequest.js.map

package/icc-api/model/requests/RejectedShareOrMetadataUpdateRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RejectedShareOrMetadataUpdateRequest.js","sourceRoot":"","sources":["../../../../icc-api/model/requests/RejectedShareOrMetadataUpdateRequest.ts"],"names":[],"mappings":";;;AAAA;;GAEG;AACH,MAAa,oCAAoC;IAC/C,YAAY,IAAgB;QAC1B,MAAM,CAAC,MAAM,CAAC,IAA4C,EAAE,IAAI,CAAC,CAAA;QACjE,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAA;IAC1C,CAAC;CAiBF;AArBD,oFAqBC","sourcesContent":["/**\n * Represents a reason why a share requests failed or was rejected.\n */\nexport class RejectedShareOrMetadataUpdateRequest {\n  constructor(json: JSON | any) {\n    Object.assign(this as RejectedShareOrMetadataUpdateRequest, json)\n    this.shouldRetry = !!json['shouldRetry']\n  }\n\n  /**\n   * Code of the error, mimics an http status code (400 general user error, 409 conflict, ...).\n   */\n  code?: number\n  /**\n   * If true a new share request with the same content may succeed so the user is encouraged to retry. This could\n   * happen if the entity to share changed while verifying the validity of the request (correctness, permissions,\n   * ...), and if the entity did not change in ways incompatible with the request re-performing the request in\n   * the same way may succeed.\n   */\n  shouldRetry: boolean\n  /**\n   * Human-friendly message explaining the reason of the failure.\n   */\n  reason?: string\n}\n"]}

package/icc-x-api/basexapi/EncryptedEntityXApi.d.ts

@@ -1,14 +1,20 @@
-import { EncryptedEntity } from '../../icc-api/model/models';
+import { EncryptedEntity, SecureDelegation } from '../../icc-api/model/models';
+import AccessLevelEnum = SecureDelegation.AccessLevelEnum;
 /**
  * Interface of common methods for XApis of any encryptable entities.
  */
 export interface EncryptedEntityXApi<T extends EncryptedEntity> {
     /**
      * Get the ids of all data owners with access to the provided entity, including their permissions on the entity. This method also uses the
-     * information available to the current user to attempt to identify the anonymous data owners with access to this entity. Note however that
-     * the user may not be capable of identifying all anonymous data owners with access to the entity. In cases where there is at least an anonymous
-     * data owner with access to the entity the value of `hasUnknownAnonymousDataOwners` in the returned object will be `true` (`false` otherwise).
-     * Note that users are only capable of identifying anonymous data owners in delegations where the user itself is involved, meaning that if a
+     * information available to the current user to attempt to identify the anonymous data owners with access to this entity.
+     *
+     * Note however that the user may not be capable of identifying all anonymous data owners with access to the entity. In cases where there is at least
+     * an anonymous data owner with access to the entity that the current data owner can't identify the value of `hasUnknownAnonymousDataOwners` in the
+     * returned object will be `true` (`false` otherwise).
+     *
+     * ## Basic anonymous data owners identification
+     *
+     * Initially users are only capable of identifying anonymous data owners in delegations where the user itself is involved, meaning that if a
      * specific anonymous data owners has access to an entity through two delegations, one accessible to the current user and one not, the anonymous
      * data owner will appear in the `permissionsByDataOwnerId`, but the `hasUnknownAnonymousDataOwners` will also be `true`, since the user can't know
      * if the other delegation refers to the same anonymous data owner or not.
@@ -27,6 +33,31 @@ export interface EncryptedEntityXApi<T extends EncryptedEntity> {
      * - `P` gets `{ permissionsByDataOwnerId: { A: 'WRITE', B: 'WRITE', P: 'WRITE' }, hasUnknownAnonymousDataOwners: false }` (`P` knows the
      *    delegations that he is part of)
      *
+     * ## Anonymous data owner identification through de-anonymization metadata
+     *
+     * You also have the possibility of identifying anonymous data owners through the de-anonymization metadata. This metadata is created on request
+     * by data owners that have access to the delegation anonymous data owners involved in the delegations, but can later be shared also by other
+     * data owners.
+     *
+     * For example consider an entity with the following delegations, where `A`, `B` and `C` are unrelated explicit data owners, and `P` is an
+     * anonymous data owner:
+     * - A -> A
+     * - A -> B
+     * - A -> P
+     *
+     * As we know initially B will not be able to identify P (B only knows that [A,B] have access to the entity), but if A creates the
+     * de-anonymization metadata for the delegation A->P, then B will be to do so.
+     *
+     * If later B shares the entity with C, resulting in the following delegations:
+     * - A -> A
+     * - A -> B
+     * - A -> P
+     * - B -> C
+     *
+     * C will initially be only aware of [A, B, C] having access to the entity, but now B can share with C the information that P has also
+     * access to the entity through the delegation A->P. Note that if A had not created the de-anonymization metadata for the delegation A->P,
+     * then B would not be able to share this information with C.
+     *
      * @param entity an entity.
      * @return an object containing:
      * - `permissionsByDataOwnerId`: a map associating each data owner id with the access level to the entity. Currently only WRITE access is supported.
@@ -35,10 +66,28 @@ export interface EncryptedEntityXApi<T extends EncryptedEntity> {
      */
     getDataOwnersWithAccessTo(entity: T): Promise<{
         permissionsByDataOwnerId: {
-            [dataOwnerId: string]: 'WRITE';
+            [dataOwnerId: string]: AccessLevelEnum;
         };
         hasUnknownAnonymousDataOwners: boolean;
     }>;
+    /**
+     * Creates the metadata to support {@link delegates} in the de-anonymization of the delegations in the provided entity.
+     *
+     * Refer to {@link getDataOwnersWithAccessTo} for more information on how this metadata is used.
+     *
+     * # Important information
+     *
+     * while the metadata is created based on the delegations of the provided entity, the metadata may be used to de-anonymize
+     * equivalent delegations in other entities of the same type.
+     *
+     * For example if A creates an entity of type T, shares it with B and P, and then creates the de-anonymization metadata
+     * to allow B to de-anonymize the delegation A->P, then B will be able to de-anonymize any delegation A->P in any other
+     * entity of type T that B can access (through the iCure cloud or directly through database replicas).
+     *
+     * @param entity an entity.
+     * @param delegates users
+     */
+    createDelegationDeAnonymizationMetadata(entity: T, delegates: string[]): Promise<void>;
     /**
      * @param entity an entity.
      * @return the available encryption keys for the entity, which could be decrypted by the current data owner. Normally this array should contain at

package/icc-x-api/basexapi/EncryptedEntityXApi.js.map

@@ -1 +1 @@
-{"version":3,"file":"EncryptedEntityXApi.js","sourceRoot":"","sources":["../../../icc-x-api/basexapi/EncryptedEntityXApi.ts"],"names":[],"mappings":"","sourcesContent":["import { EncryptedEntity } from '../../icc-api/model/models'\n\n/**\n * Interface of common methods for XApis of any encryptable entities.\n */\nexport interface EncryptedEntityXApi<T extends EncryptedEntity> {\n  /**\n   * Get the ids of all data owners with access to the provided entity, including their permissions on the entity. This method also uses the\n   * information available to the current user to attempt to identify the anonymous data owners with access to this entity. Note however that\n   * the user may not be capable of identifying all anonymous data owners with access to the entity. In cases where there is at least an anonymous\n   * data owner with access to the entity the value of `hasUnknownAnonymousDataOwners` in the returned object will be `true` (`false` otherwise).\n   * Note that users are only capable of identifying anonymous data owners in delegations where the user itself is involved, meaning that if a\n   * specific anonymous data owners has access to an entity through two delegations, one accessible to the current user and one not, the anonymous\n   * data owner will appear in the `permissionsByDataOwnerId`, but the `hasUnknownAnonymousDataOwners` will also be `true`, since the user can't know\n   * if the other delegation refers to the same anonymous data owner or not.\n   *\n   * For example consider an entity with the following delegations, where `A` and `B` are unrelated explicit data owners, and `P` is an anonymous\n   * data owner:\n   * - A -> A - r/w\n   * - A -> B - r/w\n   * - A -> P - r\n   * - B -> P - r/w\n   * In this case we can get the following results, depending on whether the current user is `A`, `B` or `P`:\n   * - `A` gets `{ permissionsByDataOwnerId: { A: 'WRITE', B: 'WRITE', P: 'READ' }, hasUnknownAnonymousDataOwners: true }` (`A` does not know that\n   *   `B->P` actually refers to `P`, but only that it was created by `B`)\n   * - `B` gets `{ permissionsByDataOwnerId: { A: 'WRITE', B: 'WRITE', P: 'WRITE' }, hasUnknownAnonymousDataOwners: true }` (`B` does not know that\n   *   `A->P` actually refers to `P`, but only that it was created by `A`)\n   * - `P` gets `{ permissionsByDataOwnerId: { A: 'WRITE', B: 'WRITE', P: 'WRITE' }, hasUnknownAnonymousDataOwners: false }` (`P` knows the\n   *    delegations that he is part of)\n   *\n   * @param entity an entity.\n   * @return an object containing:\n   * - `permissionsByDataOwnerId`: a map associating each data owner id with the access level to the entity. Currently only WRITE access is supported.\n   * - `hasUnknownAnonymousDataOwners`: a boolean indicating if there are anonymous data owners with access to the entity that the current user can\n   *   not identify.\n   */\n  getDataOwnersWithAccessTo(entity: T): Promise<{\n    permissionsByDataOwnerId: { [dataOwnerId: string]: 'WRITE' }\n    hasUnknownAnonymousDataOwners: boolean\n  }>\n\n  /**\n   * @param entity an entity.\n   * @return the available encryption keys for the entity, which could be decrypted by the current data owner. Normally this array should contain at\n   * most one element but this method in case of entity merges there could be multiple values.\n   */\n  getEncryptionKeysOf(entity: T): Promise<string[]>\n}\n"]}
+{"version":3,"file":"EncryptedEntityXApi.js","sourceRoot":"","sources":["../../../icc-x-api/basexapi/EncryptedEntityXApi.ts"],"names":[],"mappings":"","sourcesContent":["import { EncryptedEntity, SecureDelegation } from '../../icc-api/model/models'\nimport AccessLevelEnum = SecureDelegation.AccessLevelEnum\n\n/**\n * Interface of common methods for XApis of any encryptable entities.\n */\nexport interface EncryptedEntityXApi<T extends EncryptedEntity> {\n  /**\n   * Get the ids of all data owners with access to the provided entity, including their permissions on the entity. This method also uses the\n   * information available to the current user to attempt to identify the anonymous data owners with access to this entity.\n   *\n   * Note however that the user may not be capable of identifying all anonymous data owners with access to the entity. In cases where there is at least\n   * an anonymous data owner with access to the entity that the current data owner can't identify the value of `hasUnknownAnonymousDataOwners` in the\n   * returned object will be `true` (`false` otherwise).\n   *\n   * ## Basic anonymous data owners identification\n   *\n   * Initially users are only capable of identifying anonymous data owners in delegations where the user itself is involved, meaning that if a\n   * specific anonymous data owners has access to an entity through two delegations, one accessible to the current user and one not, the anonymous\n   * data owner will appear in the `permissionsByDataOwnerId`, but the `hasUnknownAnonymousDataOwners` will also be `true`, since the user can't know\n   * if the other delegation refers to the same anonymous data owner or not.\n   *\n   * For example consider an entity with the following delegations, where `A` and `B` are unrelated explicit data owners, and `P` is an anonymous\n   * data owner:\n   * - A -> A - r/w\n   * - A -> B - r/w\n   * - A -> P - r\n   * - B -> P - r/w\n   * In this case we can get the following results, depending on whether the current user is `A`, `B` or `P`:\n   * - `A` gets `{ permissionsByDataOwnerId: { A: 'WRITE', B: 'WRITE', P: 'READ' }, hasUnknownAnonymousDataOwners: true }` (`A` does not know that\n   *   `B->P` actually refers to `P`, but only that it was created by `B`)\n   * - `B` gets `{ permissionsByDataOwnerId: { A: 'WRITE', B: 'WRITE', P: 'WRITE' }, hasUnknownAnonymousDataOwners: true }` (`B` does not know that\n   *   `A->P` actually refers to `P`, but only that it was created by `A`)\n   * - `P` gets `{ permissionsByDataOwnerId: { A: 'WRITE', B: 'WRITE', P: 'WRITE' }, hasUnknownAnonymousDataOwners: false }` (`P` knows the\n   *    delegations that he is part of)\n   *\n   * ## Anonymous data owner identification through de-anonymization metadata\n   *\n   * You also have the possibility of identifying anonymous data owners through the de-anonymization metadata. This metadata is created on request\n   * by data owners that have access to the delegation anonymous data owners involved in the delegations, but can later be shared also by other\n   * data owners.\n   *\n   * For example consider an entity with the following delegations, where `A`, `B` and `C` are unrelated explicit data owners, and `P` is an\n   * anonymous data owner:\n   * - A -> A\n   * - A -> B\n   * - A -> P\n   *\n   * As we know initially B will not be able to identify P (B only knows that [A,B] have access to the entity), but if A creates the\n   * de-anonymization metadata for the delegation A->P, then B will be to do so.\n   *\n   * If later B shares the entity with C, resulting in the following delegations:\n   * - A -> A\n   * - A -> B\n   * - A -> P\n   * - B -> C\n   *\n   * C will initially be only aware of [A, B, C] having access to the entity, but now B can share with C the information that P has also\n   * access to the entity through the delegation A->P. Note that if A had not created the de-anonymization metadata for the delegation A->P,\n   * then B would not be able to share this information with C.\n   *\n   * @param entity an entity.\n   * @return an object containing:\n   * - `permissionsByDataOwnerId`: a map associating each data owner id with the access level to the entity. Currently only WRITE access is supported.\n   * - `hasUnknownAnonymousDataOwners`: a boolean indicating if there are anonymous data owners with access to the entity that the current user can\n   *   not identify.\n   */\n  getDataOwnersWithAccessTo(entity: T): Promise<{\n    permissionsByDataOwnerId: { [dataOwnerId: string]: AccessLevelEnum }\n    hasUnknownAnonymousDataOwners: boolean\n  }>\n\n  /**\n   * Creates the metadata to support {@link delegates} in the de-anonymization of the delegations in the provided entity.\n   *\n   * Refer to {@link getDataOwnersWithAccessTo} for more information on how this metadata is used.\n   *\n   * # Important information\n   *\n   * while the metadata is created based on the delegations of the provided entity, the metadata may be used to de-anonymize\n   * equivalent delegations in other entities of the same type.\n   *\n   * For example if A creates an entity of type T, shares it with B and P, and then creates the de-anonymization metadata\n   * to allow B to de-anonymize the delegation A->P, then B will be able to de-anonymize any delegation A->P in any other\n   * entity of type T that B can access (through the iCure cloud or directly through database replicas).\n   *\n   * @param entity an entity.\n   * @param delegates users\n   */\n  createDelegationDeAnonymizationMetadata(entity: T, delegates: string[]): Promise<void>\n\n  /**\n   * @param entity an entity.\n   * @return the available encryption keys for the entity, which could be decrypted by the current data owner. Normally this array should contain at\n   * most one element but this method in case of entity merges there could be multiple values.\n   */\n  getEncryptionKeysOf(entity: T): Promise<string[]>\n}\n"]}

package/icc-x-api/crypto/AES.js

@@ -95,7 +95,7 @@ class AESUtils {
                 this._debug && console.log(`decipheredData: ${(0, utils_1.ua2hex)(decipheredData)}`);
                 resolve(decipheredData);
             }, (err) => {
-                reject('AES decryption failed: ' + err);
+                reject(new Error('AES decryption failed: ' + err));
             });
         });
     }