@icure/api 7.1.14 → 8.0.0-RC.1

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,4 +1,5 @@
-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.
  */
@@ -35,7 +36,7 @@ export interface EncryptedEntityXApi<T extends EncryptedEntity> {
      */
     getDataOwnersWithAccessTo(entity: T): Promise<{
         permissionsByDataOwnerId: {
-            [dataOwnerId: string]: 'WRITE';
+            [dataOwnerId: string]: AccessLevelEnum;
         };
         hasUnknownAnonymousDataOwners: boolean;
     }>;

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. 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]: AccessLevelEnum }\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"]}

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));
             });
         });
     }

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

@@ -1 +1 @@
-{"version":3,"file":"AES.js","sourceRoot":"","sources":["../../../icc-x-api/crypto/AES.ts"],"names":[],"mappings":"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","sourcesContent":["import { appendBuffer, hex2ua, ua2hex } from '../utils'\n\nexport class AESUtils {\n  /********* AES Config **********/\n  ivLength = 16\n  aesAlgorithmEncryptName = 'AES-CBC'\n\n  aesKeyGenParams: AesKeyGenParams = {\n    name: 'AES-CBC',\n    length: 256,\n  }\n  private crypto: Crypto\n  private _debug: boolean = false\n\n  set debug(value: boolean) {\n    this._debug = value\n  }\n\n  constructor(crypto: Crypto = typeof window !== 'undefined' ? window.crypto : typeof self !== 'undefined' ? self.crypto : ({} as Crypto)) {\n    this.crypto = crypto\n  }\n\n  async encryptWithRawKey(rawKey: string, plainData: ArrayBuffer | Uint8Array): Promise<ArrayBuffer> {\n    return this.encrypt(\n      await this.importKey('raw', hex2ua(rawKey.replace(/-/g, ''))),\n      plainData,\n      rawKey // Used for logging only if debug is enabled, ok to always pass\n    )\n  }\n\n  encrypt(cryptoKey: CryptoKey, plainData: ArrayBuffer | Uint8Array, rawKey = '<NA>'): Promise<ArrayBuffer> {\n    return new Promise((resolve: (value: ArrayBuffer) => any, reject: (reason: any) => any) => {\n      if (plainData instanceof Uint8Array) {\n        const buffer = plainData.buffer\n        plainData = (buffer.byteLength > plainData.byteLength ? buffer.slice(0, plainData.byteLength) : buffer) as ArrayBuffer\n      }\n      const aesAlgorithmEncrypt = {\n        name: this.aesAlgorithmEncryptName,\n        iv: this.generateIV(this.ivLength),\n      }\n      this._debug && console.log(`encrypt ${ua2hex(plainData)} with ${rawKey}`)\n      this.crypto.subtle\n        .encrypt(\n          {\n            ...aesAlgorithmEncrypt,\n          } /* some ill behaved implementations change the values in place */,\n          cryptoKey,\n          plainData\n        )\n        .then(\n          (cipherData) => {\n            this._debug && console.log(`cipherData: ${ua2hex(cipherData)}`)\n            return resolve(appendBuffer(aesAlgorithmEncrypt.iv.buffer as ArrayBuffer, cipherData))\n          },\n          (err) => reject('AES encryption failed: ' + err)\n        )\n    })\n  }\n\n  async decryptWithRawKey(rawKey: string, plainData: ArrayBuffer | Uint8Array): Promise<ArrayBuffer> {\n    return this.decrypt(\n      await this.importKey('raw', hex2ua(rawKey.replace(/-/g, ''))),\n      plainData,\n      rawKey // Used for logging only if debug is enabled, ok to always pass\n    )\n  }\n\n  /**\n   *\n   * @param cryptoKey (CryptoKey)\n   * @param encryptedData (ArrayBuffer)\n   * @param rawKey\n   * @returns {Promise} will be ArrayBuffer\n   */\n  decrypt(cryptoKey: CryptoKey, encryptedData: ArrayBuffer | Uint8Array, rawKey = '<NA>'): Promise<ArrayBuffer> {\n    return new Promise((resolve: (value: ArrayBuffer) => any, reject: (reason: any) => any) => {\n      if (!cryptoKey) {\n        return reject('No crypto key provided for decryption')\n      }\n      const encryptedDataUint8 = encryptedData instanceof ArrayBuffer ? new Uint8Array(encryptedData) : encryptedData\n      const aesAlgorithmEncrypt = {\n        name: this.aesAlgorithmEncryptName,\n        iv: encryptedDataUint8.subarray(0, this.ivLength),\n\n        /*\n         * IF THIS BIT OF CODE PRODUCES A DOMEXCEPTION CODE 0 ERROR, IT MIGHT BE RELATED TO THIS:\n         *\n         * NOTOK:\n         * if (!hcparty.hcPartyKeys && !hcparty.hcPartyKeys[hcpartyId] && hcparty.hcPartyKeys[hcpartyId].length !== 2) {\n         *   throw 'No hcPartyKey for this Healthcare party(' + hcpartyId + ').';\n         * }\n         * var delegateHcPartyKey = hcparty.hcPartyKeys[hcpartyId][1];\n         *\n         * SHOULD BE:\n         * var delegatorId = patient.delegations[hcpartyId][0].owner;\n         * if (!hcparty.hcPartyKeys && !hcparty.hcPartyKeys[delegatorId] && hcparty.hcPartyKeys[delegatorId].length !== 2) {\n         *   throw 'No hcPartyKey for this Healthcare party(' + delegatorId + ').';\n         * }\n         * var delegateHcPartyKey = hcparty.hcPartyKeys[delegatorId][1];\n         */\n      }\n      this._debug && console.log(`decrypt ${ua2hex(encryptedData)} with ${rawKey}`)\n      this.crypto.subtle.decrypt(aesAlgorithmEncrypt, cryptoKey, encryptedDataUint8.subarray(this.ivLength, encryptedDataUint8.length)).then(\n        (decipheredData) => {\n          this._debug && console.log(`decipheredData: ${ua2hex(decipheredData)}`)\n          resolve(decipheredData)\n        },\n        (err) => {\n          reject('AES decryption failed: ' + err)\n        }\n      )\n    })\n  }\n\n  async decryptSome(cryptoKeys: CryptoKey[], uint8Array: Uint8Array): Promise<ArrayBuffer> {\n    try {\n      return this.decrypt(cryptoKeys[0], uint8Array)\n    } catch (e) {\n      if (cryptoKeys.length > 1) {\n        return this.decryptSome(cryptoKeys.slice(1), uint8Array)\n      } else {\n        throw e\n      }\n    }\n  }\n\n  // generate an AES key\n  // noinspection JSUnusedGlobalSymbols\n  /**\n   *\n   * @param toHex boolean, if true, it returns hex String\n   * @returns {Promise} either Hex string or CryptoKey\n   */\n  generateCryptoKey(toHex: false): Promise<CryptoKey>\n  generateCryptoKey(toHex: true): Promise<string>\n  generateCryptoKey(toHex: boolean): Promise<string | CryptoKey> {\n    return new Promise((resolve: (value: CryptoKey | string) => any, reject: (reason: any) => any) => {\n      const extractable = true\n      const keyUsages: KeyUsage[] = ['decrypt', 'encrypt']\n      const cryptoKeyPromise: Promise<CryptoKey> = this.crypto.subtle.generateKey(this.aesKeyGenParams, extractable, keyUsages) as Promise<CryptoKey>\n      return toHex === undefined || !toHex\n        ? cryptoKeyPromise.then(resolve, reject)\n        : cryptoKeyPromise.then((k) => this.exportKey(k, 'raw'), reject).then((raw) => resolve(ua2hex(raw)), reject)\n    })\n  }\n\n  // noinspection JSMethodCanBeStatic\n  generateIV(ivByteLength: number): Uint8Array {\n    return new Uint8Array(this.crypto.getRandomValues(new Uint8Array(ivByteLength)))\n  }\n\n  /**\n   * This function return a promise which will be the key Format will be either 'raw' or 'jwk'.\n   * JWK: Json Web key (ref. http://tools.ietf.org/html/draft-ietf-jose-json-web-key-11)\n   *\n   * @param cryptoKey CryptoKey\n   * @param format will be 'raw' or 'jwk'\n   * @returns {Promise} will the AES Key\n   */\n  exportKey(cryptoKey: CryptoKey, format: 'raw'): Promise<ArrayBuffer>\n  exportKey(cryptoKey: CryptoKey, format: 'jwk'): Promise<JsonWebKey>\n  exportKey(cryptoKey: CryptoKey, format: 'jwk' | 'raw'): Promise<ArrayBuffer | JsonWebKey> {\n    return new Promise((resolve: (value: ArrayBuffer | JsonWebKey) => any, reject: (reason: any) => any) => {\n      return this.crypto.subtle.exportKey(format as any, cryptoKey).then(resolve, reject)\n    })\n  }\n\n  /**\n   * the ability to import a key that have already been created elsewhere, for use within the web\n   * application that is invoking the import function, for use within the importing web application's\n   * origin. This necessiates an interoperable key format, such as JSON Web Key [JWK] which may be\n   * represented as octets.\n   *\n   * https://chromium.googlesource.com/chromium/blink.git/+/6b902997e3ca0384c8fa6fe56f79ecd7589d3ca6/LayoutTests/crypto/resources/common.js\n   *\n   * @param format 'raw' or 'jwk'\n   * @param aesKey\n   * @returns {*}\n   */\n  importKey(format: 'jwk' | 'raw', aesKey: JsonWebKey | ArrayBuffer | Uint8Array): Promise<CryptoKey> {\n    return new Promise((resolve: (value: CryptoKey) => any, reject: (reason: any) => any) => {\n      const extractable = true\n      const keyUsages: KeyUsage[] = ['decrypt', 'encrypt']\n      return this.crypto.subtle\n        .importKey(format as any, aesKey as any, this.aesKeyGenParams, extractable, keyUsages)\n        .catch((err) => {\n          if (format == 'raw' && (aesKey instanceof ArrayBuffer || ArrayBuffer.isView(aesKey))) {\n            console.warn(`Import of key ${ua2hex(aesKey)} failed`)\n          }\n          throw err\n        })\n        .then(resolve, reject)\n    })\n  }\n}\n\nexport const AES = new AESUtils()\n"]}
+{"version":3,"file":"AES.js","sourceRoot":"","sources":["../../../icc-x-api/crypto/AES.ts"],"names":[],"mappings":"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","sourcesContent":["import { appendBuffer, hex2ua, ua2hex } from '../utils'\n\nexport class AESUtils {\n  /********* AES Config **********/\n  ivLength = 16\n  aesAlgorithmEncryptName = 'AES-CBC'\n\n  aesKeyGenParams: AesKeyGenParams = {\n    name: 'AES-CBC',\n    length: 256,\n  }\n  private crypto: Crypto\n  private _debug: boolean = false\n\n  set debug(value: boolean) {\n    this._debug = value\n  }\n\n  constructor(crypto: Crypto = typeof window !== 'undefined' ? window.crypto : typeof self !== 'undefined' ? self.crypto : ({} as Crypto)) {\n    this.crypto = crypto\n  }\n\n  async encryptWithRawKey(rawKey: string, plainData: ArrayBuffer | Uint8Array): Promise<ArrayBuffer> {\n    return this.encrypt(\n      await this.importKey('raw', hex2ua(rawKey.replace(/-/g, ''))),\n      plainData,\n      rawKey // Used for logging only if debug is enabled, ok to always pass\n    )\n  }\n\n  encrypt(cryptoKey: CryptoKey, plainData: ArrayBuffer | Uint8Array, rawKey = '<NA>'): Promise<ArrayBuffer> {\n    return new Promise((resolve: (value: ArrayBuffer) => any, reject: (reason: any) => any) => {\n      if (plainData instanceof Uint8Array) {\n        const buffer = plainData.buffer\n        plainData = (buffer.byteLength > plainData.byteLength ? buffer.slice(0, plainData.byteLength) : buffer) as ArrayBuffer\n      }\n      const aesAlgorithmEncrypt = {\n        name: this.aesAlgorithmEncryptName,\n        iv: this.generateIV(this.ivLength),\n      }\n      this._debug && console.log(`encrypt ${ua2hex(plainData)} with ${rawKey}`)\n      this.crypto.subtle\n        .encrypt(\n          {\n            ...aesAlgorithmEncrypt,\n          } /* some ill behaved implementations change the values in place */,\n          cryptoKey,\n          plainData\n        )\n        .then(\n          (cipherData) => {\n            this._debug && console.log(`cipherData: ${ua2hex(cipherData)}`)\n            return resolve(appendBuffer(aesAlgorithmEncrypt.iv.buffer as ArrayBuffer, cipherData))\n          },\n          (err) => reject('AES encryption failed: ' + err)\n        )\n    })\n  }\n\n  async decryptWithRawKey(rawKey: string, plainData: ArrayBuffer | Uint8Array): Promise<ArrayBuffer> {\n    return this.decrypt(\n      await this.importKey('raw', hex2ua(rawKey.replace(/-/g, ''))),\n      plainData,\n      rawKey // Used for logging only if debug is enabled, ok to always pass\n    )\n  }\n\n  /**\n   *\n   * @param cryptoKey (CryptoKey)\n   * @param encryptedData (ArrayBuffer)\n   * @param rawKey\n   * @returns {Promise} will be ArrayBuffer\n   */\n  decrypt(cryptoKey: CryptoKey, encryptedData: ArrayBuffer | Uint8Array, rawKey = '<NA>'): Promise<ArrayBuffer> {\n    return new Promise((resolve: (value: ArrayBuffer) => any, reject: (reason: any) => any) => {\n      if (!cryptoKey) {\n        return reject('No crypto key provided for decryption')\n      }\n      const encryptedDataUint8 = encryptedData instanceof ArrayBuffer ? new Uint8Array(encryptedData) : encryptedData\n      const aesAlgorithmEncrypt = {\n        name: this.aesAlgorithmEncryptName,\n        iv: encryptedDataUint8.subarray(0, this.ivLength),\n\n        /*\n         * IF THIS BIT OF CODE PRODUCES A DOMEXCEPTION CODE 0 ERROR, IT MIGHT BE RELATED TO THIS:\n         *\n         * NOTOK:\n         * if (!hcparty.hcPartyKeys && !hcparty.hcPartyKeys[hcpartyId] && hcparty.hcPartyKeys[hcpartyId].length !== 2) {\n         *   throw 'No hcPartyKey for this Healthcare party(' + hcpartyId + ').';\n         * }\n         * var delegateHcPartyKey = hcparty.hcPartyKeys[hcpartyId][1];\n         *\n         * SHOULD BE:\n         * var delegatorId = patient.delegations[hcpartyId][0].owner;\n         * if (!hcparty.hcPartyKeys && !hcparty.hcPartyKeys[delegatorId] && hcparty.hcPartyKeys[delegatorId].length !== 2) {\n         *   throw 'No hcPartyKey for this Healthcare party(' + delegatorId + ').';\n         * }\n         * var delegateHcPartyKey = hcparty.hcPartyKeys[delegatorId][1];\n         */\n      }\n      this._debug && console.log(`decrypt ${ua2hex(encryptedData)} with ${rawKey}`)\n      this.crypto.subtle.decrypt(aesAlgorithmEncrypt, cryptoKey, encryptedDataUint8.subarray(this.ivLength, encryptedDataUint8.length)).then(\n        (decipheredData) => {\n          this._debug && console.log(`decipheredData: ${ua2hex(decipheredData)}`)\n          resolve(decipheredData)\n        },\n        (err) => {\n          reject(new Error('AES decryption failed: ' + err))\n        }\n      )\n    })\n  }\n\n  async decryptSome(cryptoKeys: CryptoKey[], uint8Array: Uint8Array): Promise<ArrayBuffer> {\n    try {\n      return this.decrypt(cryptoKeys[0], uint8Array)\n    } catch (e) {\n      if (cryptoKeys.length > 1) {\n        return this.decryptSome(cryptoKeys.slice(1), uint8Array)\n      } else {\n        throw e\n      }\n    }\n  }\n\n  // generate an AES key\n  // noinspection JSUnusedGlobalSymbols\n  /**\n   *\n   * @param toHex boolean, if true, it returns hex String\n   * @returns {Promise} either Hex string or CryptoKey\n   */\n  generateCryptoKey(toHex: false): Promise<CryptoKey>\n  generateCryptoKey(toHex: true): Promise<string>\n  generateCryptoKey(toHex: boolean): Promise<string | CryptoKey> {\n    return new Promise((resolve: (value: CryptoKey | string) => any, reject: (reason: any) => any) => {\n      const extractable = true\n      const keyUsages: KeyUsage[] = ['decrypt', 'encrypt']\n      const cryptoKeyPromise: Promise<CryptoKey> = this.crypto.subtle.generateKey(this.aesKeyGenParams, extractable, keyUsages) as Promise<CryptoKey>\n      return toHex === undefined || !toHex\n        ? cryptoKeyPromise.then(resolve, reject)\n        : cryptoKeyPromise.then((k) => this.exportKey(k, 'raw'), reject).then((raw) => resolve(ua2hex(raw)), reject)\n    })\n  }\n\n  // noinspection JSMethodCanBeStatic\n  generateIV(ivByteLength: number): Uint8Array {\n    return new Uint8Array(this.crypto.getRandomValues(new Uint8Array(ivByteLength)))\n  }\n\n  /**\n   * This function return a promise which will be the key Format will be either 'raw' or 'jwk'.\n   * JWK: Json Web key (ref. http://tools.ietf.org/html/draft-ietf-jose-json-web-key-11)\n   *\n   * @param cryptoKey CryptoKey\n   * @param format will be 'raw' or 'jwk'\n   * @returns {Promise} will the AES Key\n   */\n  exportKey(cryptoKey: CryptoKey, format: 'raw'): Promise<ArrayBuffer>\n  exportKey(cryptoKey: CryptoKey, format: 'jwk'): Promise<JsonWebKey>\n  exportKey(cryptoKey: CryptoKey, format: 'jwk' | 'raw'): Promise<ArrayBuffer | JsonWebKey> {\n    return new Promise((resolve: (value: ArrayBuffer | JsonWebKey) => any, reject: (reason: any) => any) => {\n      return this.crypto.subtle.exportKey(format as any, cryptoKey).then(resolve, reject)\n    })\n  }\n\n  /**\n   * the ability to import a key that have already been created elsewhere, for use within the web\n   * application that is invoking the import function, for use within the importing web application's\n   * origin. This necessiates an interoperable key format, such as JSON Web Key [JWK] which may be\n   * represented as octets.\n   *\n   * https://chromium.googlesource.com/chromium/blink.git/+/6b902997e3ca0384c8fa6fe56f79ecd7589d3ca6/LayoutTests/crypto/resources/common.js\n   *\n   * @param format 'raw' or 'jwk'\n   * @param aesKey\n   * @returns {*}\n   */\n  importKey(format: 'jwk' | 'raw', aesKey: JsonWebKey | ArrayBuffer | Uint8Array): Promise<CryptoKey> {\n    return new Promise((resolve: (value: CryptoKey) => any, reject: (reason: any) => any) => {\n      const extractable = true\n      const keyUsages: KeyUsage[] = ['decrypt', 'encrypt']\n      return this.crypto.subtle\n        .importKey(format as any, aesKey as any, this.aesKeyGenParams, extractable, keyUsages)\n        .catch((err) => {\n          if (format == 'raw' && (aesKey instanceof ArrayBuffer || ArrayBuffer.isView(aesKey))) {\n            console.warn(`Import of key ${ua2hex(aesKey)} failed`)\n          }\n          throw err\n        })\n        .then(resolve, reject)\n    })\n  }\n}\n\nexport const AES = new AESUtils()\n"]}

package/icc-x-api/crypto/AccessControlKeysHeadersProvider.d.ts

@@ -0,0 +1,16 @@
+import { ExchangeDataManager } from './ExchangeDataManager';
+import { XHR } from '../../icc-api/api/XHR';
+import { EntityWithDelegationTypeName } from '../utils/EntityWithDelegationTypeName';
+/**
+ * @internal this class is intended for internal use only and may be changed without notice.
+ */
+export declare class AccessControlKeysHeadersProvider {
+    private readonly exchangeDataManager;
+    constructor(exchangeDataManager: ExchangeDataManager);
+    /**
+     * Add the access control keys headers to the provided initial headers, allowing access control on users with anonymous delegations.
+     * @param initialHeaders the initial headers
+     * @param entityType the type of entity which the user is attempting to retrieve.
+     */
+    addAccessControlKeysHeaders(initialHeaders: XHR.Header[], entityType: EntityWithDelegationTypeName): Promise<XHR.Header[]>;
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessControlKeysHeadersProvider = void 0;
+const XHR_1 = require("../../icc-api/api/XHR");
+const ACCESS_CONTROL_KEYS_HEADER = 'Icure-Access-Control-Keys';
+/**
+ * @internal this class is intended for internal use only and may be changed without notice.
+ */
+class AccessControlKeysHeadersProvider {
+    constructor(exchangeDataManager) {
+        this.exchangeDataManager = exchangeDataManager;
+    }
+    // This will be enough only as long as we don't use the entities sfks in the access control keys.
+    /**
+     * Add the access control keys headers to the provided initial headers, allowing access control on users with anonymous delegations.
+     * @param initialHeaders the initial headers
+     * @param entityType the type of entity which the user is attempting to retrieve.
+     */
+    addAccessControlKeysHeaders(initialHeaders, entityType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accessControlKeysValue = yield this.exchangeDataManager.getAccessControlKeysValue(entityType);
+            if (accessControlKeysValue) {
+                return [...initialHeaders, new XHR_1.XHR.Header(ACCESS_CONTROL_KEYS_HEADER, accessControlKeysValue)];
+            }
+            else {
+                return initialHeaders;
+            }
+        });
+    }
+}
+exports.AccessControlKeysHeadersProvider = AccessControlKeysHeadersProvider;
+//# sourceMappingURL=AccessControlKeysHeadersProvider.js.map

package/icc-x-api/crypto/AccessControlKeysHeadersProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AccessControlKeysHeadersProvider.js","sourceRoot":"","sources":["../../../icc-x-api/crypto/AccessControlKeysHeadersProvider.ts"],"names":[],"mappings":";;;;;;;;;;;;AACA,+CAA2C;AAG3C,MAAM,0BAA0B,GAAG,2BAA2B,CAAA;AAE9D;;GAEG;AACH,MAAa,gCAAgC;IAC3C,YAA6B,mBAAwC;QAAxC,wBAAmB,GAAnB,mBAAmB,CAAqB;IAAG,CAAC;IAEzE,iGAAiG;IACjG;;;;OAIG;IACG,2BAA2B,CAAC,cAA4B,EAAE,UAAwC;;YACtG,MAAM,sBAAsB,GAAG,MAAM,IAAI,CAAC,mBAAmB,CAAC,yBAAyB,CAAC,UAAU,CAAC,CAAA;YACnG,IAAI,sBAAsB,EAAE;gBAC1B,OAAO,CAAC,GAAG,cAAc,EAAE,IAAI,SAAG,CAAC,MAAM,CAAC,0BAA0B,EAAE,sBAAsB,CAAC,CAAC,CAAA;aAC/F;iBAAM;gBACL,OAAO,cAAc,CAAA;aACtB;QACH,CAAC;KAAA;CACF;AAjBD,4EAiBC","sourcesContent":["import { ExchangeDataManager } from './ExchangeDataManager'\nimport { XHR } from '../../icc-api/api/XHR'\nimport { EntityWithDelegationTypeName } from '../utils/EntityWithDelegationTypeName'\n\nconst ACCESS_CONTROL_KEYS_HEADER = 'Icure-Access-Control-Keys'\n\n/**\n * @internal this class is intended for internal use only and may be changed without notice.\n */\nexport class AccessControlKeysHeadersProvider {\n  constructor(private readonly exchangeDataManager: ExchangeDataManager) {}\n\n  // This will be enough only as long as we don't use the entities sfks in the access control keys.\n  /**\n   * Add the access control keys headers to the provided initial headers, allowing access control on users with anonymous delegations.\n   * @param initialHeaders the initial headers\n   * @param entityType the type of entity which the user is attempting to retrieve.\n   */\n  async addAccessControlKeysHeaders(initialHeaders: XHR.Header[], entityType: EntityWithDelegationTypeName): Promise<XHR.Header[]> {\n    const accessControlKeysValue = await this.exchangeDataManager.getAccessControlKeysValue(entityType)\n    if (accessControlKeysValue) {\n      return [...initialHeaders, new XHR.Header(ACCESS_CONTROL_KEYS_HEADER, accessControlKeysValue)]\n    } else {\n      return initialHeaders\n    }\n  }\n}\n"]}

package/icc-x-api/crypto/AccessControlSecretUtils.d.ts

@@ -0,0 +1,42 @@
+import { CryptoPrimitives } from './CryptoPrimitives';
+import { EntityWithDelegationTypeName } from '../utils/EntityWithDelegationTypeName';
+/**
+ * @internal this class is intended for internal use only and may be changed without notice.
+ */
+export declare class AccessControlSecretUtils {
+    private readonly primitives;
+    constructor(primitives: CryptoPrimitives);
+    /**
+     * Size of the access control keys returned by this class.
+     */
+    get accessControlKeyLengthBytes(): number;
+    /**
+     * Get the access control key to use for entities of the provided type and using the provided secret foreign key. The combination of secret foreign
+     * keys and entity type ensures that unauthorised people will not be able to draw links between entities of different types of data or different
+     * confidentiality levels.
+     * These keys will be sent to the icure server for access control of data owners which require anonymous delegations.
+     * @param accessControlSecret an access control secret
+     * @param entityTypeName an entity type name
+     * @param secretForeignKey optionally a secret foreign key to include in the secret. "" and undefined are equivalent.
+     */
+    accessControlKeyFor(accessControlSecret: string, entityTypeName: EntityWithDelegationTypeName, secretForeignKey: string | undefined): Promise<ArrayBuffer>;
+    /**
+     * Get the access control keys for proving access to an entity of provided type with the provided secret foreign keys.
+     */
+    accessControlKeysFor(accessControlSecret: string, entityTypeName: EntityWithDelegationTypeName, secretForeignKeys: string[]): Promise<ArrayBuffer[]>;
+    /**
+     * Get value to use as key in secure delegations for entities of the provided type with the provided secret foreign key. The combination of secret
+     * foreign keys and entity type ensures that unauthorised people will not be able to draw links between entities of different types of data or
+     * different confidentiality levels.
+     * These keys will be used in the secure delegations map of security metadata.
+     * @param accessControlSecret an access control secret
+     * @param entityTypeName an entity type name
+     * @param secretForeignKey optionally a secret foreign key to include in the secret. "" and undefined are equivalent.
+     */
+    secureDelegationKeyFor(accessControlSecret: string, entityTypeName: EntityWithDelegationTypeName, secretForeignKey: string | undefined): Promise<string>;
+    /**
+     * Get the secure delegations keys which can be used on an entity of provided type with the provided secret foreign keys.
+     */
+    secureDelegationKeysFor(accessControlSecret: string, entityTypeName: EntityWithDelegationTypeName, secretForeignKeys: string[]): Promise<string[]>;
+    private getKeys;
+}