@icure/api 7.1.6 → 7.1.8

package/icc-x-api/maintenance/KeyPairUpdateRequest.ts

@@ -1,62 +0,0 @@
-/**
- * Represents a request to update aes exchange keys following the creation of a new key pair for a data owner.
- */
-import { MaintenanceTask } from '../../icc-api/model/MaintenanceTask'
-import { PropertyStub } from '../../icc-api/model/PropertyStub'
-
-export interface KeyPairUpdateRequest {
-  /**
-   * New public key of the data owner, in hex-encoded spki format.
-   */
-  readonly newPublicKey: string
-
-  /**
-   * Id of the data owner which created a new key pair and wants to regain access to his exchange keys.
-   */
-  readonly concernedDataOwnerId: string
-
-  /**
-   * @internal this field is intended for internal use only and may be changed in future without notice
-   */
-  readonly originalTask?: MaintenanceTask
-}
-
-export namespace KeyPairUpdateRequest {
-  /**
-   * Create a key pair update request from a maintenance task.
-   */
-  export function fromMaintenanceTask(task: MaintenanceTask): KeyPairUpdateRequest {
-    if (task.taskType !== KeyPairUpdateRequest.TASK_TYPE)
-      throw new Error(`Key pair update tasks should have task type ${KeyPairUpdateRequest.TASK_TYPE}, but got task with type ${task.taskType}`)
-
-    function findStringProp(propId: string): string {
-      const prop: PropertyStub | undefined = task.properties?.find((x) => x.id === propId)
-      if (!prop) throw new Error(`Task is missing required string property ${propId} for KeyPairUpdateRequest. ${JSON.stringify(task)}`)
-      const propValue = prop.typedValue?.stringValue
-      if (!propValue)
-        throw new Error(`Invalid value ${prop.typedValue?.stringValue} for property ${propId} for KeyPairUpdateRequest. ${JSON.stringify(task)}`)
-      return propValue
-    }
-
-    return {
-      concernedDataOwnerId: findStringProp(KeyPairUpdateRequest.OWNER_ID_PROP_ID),
-      newPublicKey: findStringProp(KeyPairUpdateRequest.OWNER_PUB_PROP_ID),
-      originalTask: task,
-    }
-  }
-}
-
-export namespace KeyPairUpdateRequest {
-  /**
-   * @internal this field is intended for internal use only and may be changed in future without notice
-   */
-  export const OWNER_ID_PROP_ID = 'dataOwnerConcernedId'
-  /**
-   * @internal this field is intended for internal use only and may be changed in future without notice
-   */
-  export const OWNER_PUB_PROP_ID = 'dataOwnerConcernedPubKey'
-  /**
-   * @internal this field is intended for internal use only and may be changed in future without notice
-   */
-  export const TASK_TYPE = MaintenanceTask.TaskTypeEnum.KeyPairUpdate
-}

package/icc-x-api/rsrc/codelng.ts

@@ -1,8 +0,0 @@
-export default {
-  'BE-THESAURUS': ['fr', 'nl'],
-  'CD-ATC': ['fr', 'nl'],
-  'CD-DRUG-CNK': ['fr', 'nl'],
-  'CD-INNCLUSTER': ['fr', 'nl'],
-  ICPC: ['fr', 'nl'],
-  ICD: ['fr', 'nl'],
-}

package/icc-x-api/rsrc/contact.i18n.ts

@@ -1,110 +0,0 @@
-export default {
-  fr: {
-    package: 'boîte',
-    packages: 'boîtes',
-    packageOf: 'boîte de',
-    packagesOf: 'boîtes de',
-    during: 'pendant',
-    take_s_: 'prise(s)',
-    weekly: '/semaine',
-    monthly: '/mois',
-    daily: '/jour',
-    the: 'le',
-    onDay: 'le jour',
-    on: 'le',
-    afterwakingup: 'Au lever',
-    afterbreakfast: 'Après ptit déj.',
-    afterdinner: 'Après rep. soir',
-    afterlunch: 'Après rep. midi',
-    afternoon: 'Après-midi',
-    beforebreakfast: 'Avant ptit déj.',
-    beforedinner: 'Avant rep. soir',
-    beforelunch: 'Avant rep. midi',
-    duringbreakfast: 'Pdt ptit déj.',
-    duringdinner: 'Pdt rep. soir',
-    duringlunch: 'Pdt rep. midi',
-    betweenbreakfastandlunch: 'Entre ptit déj et rep. midi',
-    betweenlunchanddinner: 'Entre rep. midi et rep. soir',
-    betweendinnerandsleep: 'Entre rep. soir et couch.',
-    evening: 'Soir',
-    knownuse: 'Usage connu',
-    morning: 'Matin',
-    night: 'Avt couch.',
-    midday: 'Midi',
-    noon: 'Midi',
-    at: 'à',
-    thehourofsleep: 'Au coucher',
-  },
-  en: {
-    package: 'package',
-    packages: 'packages',
-    packageOf: 'package of',
-    packagesOf: 'packages of',
-    during: 'during',
-    take_s_: 'take(s)',
-    weekly: 'weekly',
-    monthly: 'monthly',
-    daily: 'daily',
-    the: 'the',
-    onDay: 'on day',
-    on: 'on',
-    afterwakingup: 'After Waking Up',
-    afterbreakfast: 'After Breakfast',
-    afterdinner: 'After Dinner',
-    afterlunch: 'After Lunch',
-    afternoon: 'Afternoon',
-    beforebreakfast: 'Before Breakfast',
-    beforedinner: 'Before Dinner',
-    beforelunch: 'Before Lunch',
-    duringbreakfast: 'During Breakfast',
-    duringdinner: 'During Dinner',
-    duringlunch: 'During Lunch',
-    betweenbreakfastandlunch: 'Between Breakfast and Lunch',
-    betweenlunchanddinner: 'Between Lunch and Dinner',
-    betweendinnerandsleep: 'Between Dinner and Sleep',
-    evening: 'Evening',
-    knownuse: 'Known Usage',
-    morning: 'Morning',
-    night: 'Night',
-    midday: 'Midday',
-    noon: 'Noon',
-    at: 'at',
-    thehourofsleep: 'At Bedtime',
-  },
-  nl: {
-    package: 'verpakking',
-    packages: 'verpakkingen',
-    packageOf: 'verpakking van',
-    packagesOf: 'verpakkingen van',
-    during: 'gedurende',
-    take_s_: 'inname(s)',
-    weekly: 'wekelijks',
-    monthly: 'maandelijks',
-    daily: 'dagelijks',
-    the: 'de',
-    onDay: 'op dag',
-    on: 'op',
-    afterwakingup: 'Bij het opstaan',
-    afterbreakfast: 'Na ontbijt',
-    afterdinner: 'Na avondeten',
-    afterlunch: 'Na middageten',
-    afternoon: 'Namiddag',
-    beforebreakfast: 'Voor ontbijt',
-    beforedinner: 'Voor avondeten',
-    beforelunch: 'Voor middageten',
-    duringbreakfast: 'Tijdens ontbijt',
-    duringdinner: 'Tijdens avondeten',
-    duringlunch: 'Tijdens middageten',
-    betweenbreakfastandlunch: 'Tussen ontbijt en middageten',
-    betweenlunchanddinner: 'Tussen middag- en avondeten',
-    betweendinnerandsleep: 'Tussen avondmaal en slapeneten',
-    evening: 'Avond',
-    knownuse: 'Gekend gebruik',
-    morning: "'s Morgens",
-    night: 'Vóór slapengaan',
-    midday: 'Middag',
-    noon: 'Middag',
-    at: 'om',
-    thehourofsleep: 'Voor het slapen',
-  },
-}

package/icc-x-api/rsrc/icd10.ts

@@ -1,113 +0,0 @@
-export default {
-  'A00-B99': {
-    en: 'Infectious and parasitic',
-    fr: 'Infections & parasites',
-    colour: 'ICD-10--IV',
-  },
-  'C00-D48': {
-    en: 'Neoplasms',
-    fr: 'Tumeurs',
-    colour: 'ICD-10--IV',
-  },
-  'D49-D89': {
-    en: 'Blood & immunity',
-    fr: 'Sang & immunité',
-    colour: 'ICD-10--IV',
-  },
-  'E00-E99': {
-    en: 'Endocrine, nutritional & metabolic',
-    fr: 'Endocrino, nutrition et métabolisme',
-    colour: 'ICD-10--IV',
-  },
-  'F00-F99': {
-    en: 'Mental and behavioural disorders',
-    fr: 'Troubles mentaux et du comportement',
-    colour: 'ICD-10--V',
-  },
-  'G00-G99': {
-    en: 'Nervous system',
-    fr: 'Système nerveux',
-    colour: 'ICD-10--VI',
-  },
-  'H00-H59': {
-    en: 'Eye and adnexa',
-    fr: 'Œil et de ses annexes',
-    colour: 'ICD-10--VII',
-  },
-  'H60-H99': {
-    en: 'Ear and mastoid process',
-    fr: "Oreille et de l'apophyse mastoïde",
-    colour: 'ICD-10--VII',
-  },
-  'I00-I99': {
-    en: 'Circulatory system',
-    fr: 'Appareil circulatoire',
-    colour: 'ICD-10--VIII',
-  },
-  'J00-J99': {
-    en: 'Respiratory system',
-    fr: 'Appareil respiratoire',
-    colour: 'ICD-10--IX',
-  },
-  'K00-K99': {
-    en: 'Digestive system',
-    fr: 'Appareil digestif',
-    colour: 'ICD-10--X',
-  },
-  'L00-L99': {
-    en: 'Skin and subcutaneous tissue',
-    fr: 'Peau et Tissu cellulaire sous-cutané',
-    colour: 'ICD-10--XI',
-  },
-  'M00-M99': {
-    en: 'Musculoskeletal system and connective tissue',
-    fr: 'Système ostéo-articulaire, des muscles et du tissu conjonctif',
-    colour: 'ICD-10--XII',
-  },
-  'N00-N99': {
-    en: 'Genitourinary system',
-    fr: 'Appareil génito-urinaire',
-    colour: 'ICD-10--XIII',
-  },
-  'O00-O99': {
-    en: 'Pregnancy, childbirth and the puerperium',
-    fr: 'Grossesse, accouchement et puerpéralité',
-    colour: 'ICD-10--XIV',
-  },
-  'P00-P99': {
-    en: 'Perinatal period conditions',
-    fr: 'Affections périnatale',
-    colour: 'ICD-10--XV',
-  },
-  'Q00-Q99': {
-    en: 'Congenital malformations, deformations and chromosomal abnormalities',
-    fr: 'Malformations congénitales et anomalies chromosomiques',
-    colour: 'ICD-10--XVI',
-  },
-  'R00-R69': {
-    en: 'Symptoms and signs',
-    fr: 'Symptômes et signes',
-    colour: 'ICD-10--other',
-  },
-  'R70-R94': {
-    en: 'Abnormal clinical and laboratory findings',
-    fr: 'Examens cliniques et laboratoires anormaux',
-    colour: 'ICD-10--other',
-  },
-  'R95-R99': {
-    en: 'Ill-defined and unknown causes of mortality',
-    fr: 'Cause de décès mal-définie ou inconnue',
-    colour: 'ICD-10--other',
-  },
-  'S00-T99': {
-    en: 'Injuries & poisoning',
-    fr: 'Traumato & toxicologie',
-    colour: 'ICD-10--other',
-  },
-  'U00-Y99': { en: 'Unsorted', fr: 'Non-classé', colour: 'ICD-10--other' },
-  'Z00-Z99': {
-    en: 'General health status',
-    fr: 'Etat général',
-    colour: 'ICD-10--other',
-  },
-}

package/icc-x-api/rsrc/icpc2.ts

@@ -1,22 +0,0 @@
-export default {
-  A: { en: 'General and unspecified', colour: 'ICPC-2--A' },
-  B: {
-    en: 'Blood, blood forming organs, lymphatics, spleen',
-    colour: 'ICPC-2--B',
-  },
-  D: { en: 'Digestive', colour: 'ICPC-2--D' },
-  F: { en: 'Eye', colour: 'ICPC-2--F' },
-  H: { en: 'Ear', colour: 'ICPC-2--H' },
-  K: { en: 'Circulatory', colour: 'ICPC-2--K' },
-  L: { en: 'Musculoskeletal', colour: 'ICPC-2--L' },
-  N: { en: 'Neurological', colour: 'ICPC-2--N' },
-  P: { en: 'Psychological', colour: 'ICPC-2--P' },
-  R: { en: 'Respiratory', colour: 'ICPC-2--R' },
-  S: { en: 'Skin', colour: 'ICPC-2--S' },
-  T: { en: 'Endocrine, metabolic and nutritional', colour: 'ICPC-2--T' },
-  U: { en: 'Urology', colour: 'ICPC-2--U' },
-  W: { en: 'Pregnancy, childbirth, family planning', colour: 'ICPC-2--W' },
-  X: { en: 'Female genital system and breast', colour: 'ICPC-2--X' },
-  Y: { en: 'Male genital system', colour: 'ICPC-2--Y' },
-  Z: { en: 'Social problems', colour: 'ICPC-2--Z' },
-}

package/icc-x-api/storage/DefaultStorageEntryKeysFactory.ts

@@ -1,20 +0,0 @@
-import { StorageEntryKeysFactory } from './StorageEntryKeysFactory'
-
-/**
- * Default implementation for {@link StorageEntryKeysFactory}, compatible with legacy local storage keys.
- */
-export class DefaultStorageEntryKeysFactory implements StorageEntryKeysFactory {
-  cachedRecoveredKeypairOfDataOwner(dataOwnerId: string, publicKeyFingerprint: string): string {
-    if (publicKeyFingerprint.length != 32) throw new Error(`Invalid key fingerprint: ${publicKeyFingerprint}`)
-    return `org.taktik.icure.rsa.recovered.${dataOwnerId}.${publicKeyFingerprint}`
-  }
-
-  deviceKeypairOfDataOwner(dataOwnerId: string, publicKeyFingerprint: string): string {
-    if (publicKeyFingerprint.length != 32) throw new Error(`Invalid key fingerprint: ${publicKeyFingerprint}`)
-    return `org.taktik.icure.rsa.device.${dataOwnerId}.${publicKeyFingerprint}`
-  }
-
-  selfPublicKeysVerificationCacheForDataOwner(dataOwnerId: string): string {
-    return `org.taktik.icure.rsa.${dataOwnerId}.verification.self`
-  }
-}

package/icc-x-api/storage/IcureStorageFacade.ts

@@ -1,93 +0,0 @@
-import { KeyStorageFacade } from './KeyStorageFacade'
-import { StorageFacade } from './StorageFacade'
-import { StorageEntryKeysFactory } from './StorageEntryKeysFactory'
-import { KeyPair } from '../crypto/RSA'
-
-/**
- * @internal This class is meant for internal use only and may be changed without notice.
- * Simplifies access to the storage facades for iCure-specific data storage.
- */
-export class IcureStorageFacade {
-  private readonly keys: KeyStorageFacade
-  private readonly data: StorageFacade<string>
-  private readonly entryFor: StorageEntryKeysFactory
-
-  constructor(keyStorage: KeyStorageFacade, storage: StorageFacade<string>, entryKeysFactory: StorageEntryKeysFactory) {
-    this.keys = keyStorage
-    this.data = storage
-    this.entryFor = entryKeysFactory
-  }
-
-  /**
-   * Saves a key pair for the data owner.
-   * @param dataOwnerId id of the data owner with the key.
-   * @param publicKeyFingerprint fingerprint of the public key of the pair.
-   * @param keyPair a key pair of the data owner.
-   * @param isDevice true if the key was generated on this device.
-   */
-  async saveKey(dataOwnerId: string, publicKeyFingerprint: string, keyPair: KeyPair<JsonWebKey>, isDevice: boolean): Promise<void> {
-    const key = isDevice
-      ? this.entryFor.deviceKeypairOfDataOwner(dataOwnerId, publicKeyFingerprint)
-      : this.entryFor.cachedRecoveredKeypairOfDataOwner(dataOwnerId, publicKeyFingerprint)
-    await this.keys.storeKeyPair(key, keyPair)
-  }
-
-  /**
-   * Get an existing key pair for the data owner.
-   * @param dataOwnerId id of the data owner with the key.
-   * @param publicKeyFingerprint fingerprint of a public key of the data owner.
-   * @param legacyPublicKey the legacy public key of the data owner, if present
-   * @return the keypair and if the key was generated on this device or undefined if the key pair could not be found.
-   */
-  async loadKey(
-    dataOwnerId: string,
-    publicKeyFingerprint: string,
-    legacyPublicKey: string | undefined
-  ): Promise<{ pair: KeyPair<JsonWebKey>; isDevice: boolean } | undefined> {
-    const deviceKey =
-      (await this.keys.getKeypair(this.entryFor.deviceKeypairOfDataOwner(dataOwnerId, publicKeyFingerprint))) ??
-      (await this.keys.getKeypair(`org.taktik.icure.rsa.${dataOwnerId}.${publicKeyFingerprint}`)) ??
-      (legacyPublicKey?.slice(-32) === publicKeyFingerprint ? await this.keys.getKeypair(`org.taktik.icure.rsa.${dataOwnerId}`) : undefined)
-    if (deviceKey) return { pair: deviceKey, isDevice: true }
-    const cachedKey = await this.keys.getKeypair(this.entryFor.cachedRecoveredKeypairOfDataOwner(dataOwnerId, publicKeyFingerprint))
-    if (cachedKey) return { pair: cachedKey, isDevice: false }
-    return undefined
-  }
-
-  /**
-   * Save the results of public key verification. If there were already results stored the entries will be merged. In case of conflicts the new
-   * {@link verificationDetails} take priority over the stored data.
-   * @param dataOwnerId id of a data owner.
-   * @param verificationDetails results of verification, associates key fingerprints to true if they were verified by the user or false otherwise.
-   * @return the udpated keys
-   */
-  async saveSelfVerifiedKeys(
-    dataOwnerId: string,
-    verificationDetails: { [keyFingerprint: string]: boolean }
-  ): Promise<{ [keyFingerprint: string]: boolean }> {
-    const updated = {
-      ...(await this.loadSelfVerifiedKeys(dataOwnerId)),
-      ...verificationDetails,
-    }
-    await this.data.setItem(this.entryFor.selfPublicKeysVerificationCacheForDataOwner(dataOwnerId), JSON.stringify(updated))
-    return updated
-  }
-
-  /**
-   * Get the last saved results of public key verification.
-   * @param dataOwnerId id of a data owner.
-   * @return saved results of verification, associates key fingerprints to true if they were verified by the user or false otherwise. If no results
-   * were saved returns an empty object instead.
-   * @throws if the stored results are not in a valid format.
-   */
-  async loadSelfVerifiedKeys(dataOwnerId: string): Promise<{ [keyFingerprint: string]: boolean }> {
-    const dataString = await this.data.getItem(this.entryFor.selfPublicKeysVerificationCacheForDataOwner(dataOwnerId))
-    if (dataString) {
-      const parsed = JSON.parse(dataString)
-      Object.entries(parsed).forEach(([k, v]) => {
-        if (v !== true && v !== false) throw new Error(`Unexpected entry ${k}:${v}`)
-      })
-      return parsed
-    } else return {}
-  }
-}

package/icc-x-api/storage/KeyStorageFacade.ts

@@ -1,35 +0,0 @@
-export interface KeyStorageFacade {
-  /**
-   * Returns the publicKey of the provided key from the storage
-   * @param key Key of the value to retrieve
-   * @return The publicKey associated to the provided key or undefined if not found.
-   */
-  getPublicKey(key: string): Promise<JsonWebKey | undefined>
-
-  /**
-   * Returns the privateKey of the provided key from the storage
-   * @param key Key of the value to retrieve
-   * @return The privateKey associated to the provided key or undefined if not found.
-   */
-  getPrivateKey(key: string): Promise<JsonWebKey | undefined>
-
-  /**
-   * Get the keyPair associated to the provided key
-   * @param key Key of the value to retrieve
-   * @return The keyPair associated to the provided key or undefined if not found.
-   */
-  getKeypair(key: string): Promise<{ publicKey: JsonWebKey; privateKey: JsonWebKey } | undefined>
-
-  /**
-   * Delete the keyPair associated to the provided key
-   * @param key Key of the value to delete
-   */
-  deleteKeypair(key: string): Promise<void>
-
-  /**
-   * Stores the given keyPair under the given key in the storage.
-   * @param key The id of the entry in storage
-   * @param keyPair should be JWK
-   */
-  storeKeyPair(key: string, keyPair: { publicKey: JsonWebKey; privateKey: JsonWebKey }): Promise<void>
-}

package/icc-x-api/storage/KeyStorageImpl.ts

@@ -1,36 +0,0 @@
-import { StorageFacade } from './StorageFacade'
-import { KeyStorageFacade } from './KeyStorageFacade'
-
-export class KeyStorageImpl implements KeyStorageFacade {
-  private readonly _storage: StorageFacade<string>
-
-  constructor(storage: StorageFacade<string>) {
-    this._storage = storage
-  }
-
-  async deleteKeypair(key: string): Promise<void> {
-    return await this._storage.removeItem(key)
-  }
-
-  async getKeypair(key: string): Promise<{ publicKey: JsonWebKey; privateKey: JsonWebKey } | undefined> {
-    const keyPair = JSON.parse((await this._storage.getItem(key)) ?? '{}')
-    return keyPair.hasOwnProperty('publicKey') && keyPair.hasOwnProperty('privateKey')
-      ? {
-          publicKey: keyPair.publicKey as JsonWebKey,
-          privateKey: keyPair.privateKey as JsonWebKey,
-        }
-      : undefined
-  }
-
-  async getPrivateKey(key: string): Promise<JsonWebKey | undefined> {
-    return (await this.getKeypair(key))?.privateKey
-  }
-
-  async getPublicKey(key: string): Promise<JsonWebKey | undefined> {
-    return (await this.getKeypair(key))?.publicKey
-  }
-
-  async storeKeyPair(key: string, keyPair: { publicKey: JsonWebKey; privateKey: JsonWebKey }): Promise<void> {
-    return await this._storage.setItem(key, JSON.stringify(keyPair))
-  }
-}

package/icc-x-api/storage/LocalStorageImpl.ts

@@ -1,27 +0,0 @@
-import { StorageFacade } from './StorageFacade'
-
-export class LocalStorageImpl implements StorageFacade<string> {
-  async getItem(key: string): Promise<string | undefined> {
-    if (typeof Storage === 'undefined') {
-      console.error('Your browser does not support HTML5 Browser Local Storage !')
-      throw new Error('Your browser does not support HTML5 Browser Local Storage !')
-    }
-    return localStorage.getItem(key) ?? undefined
-  }
-
-  async removeItem(key: string): Promise<void> {
-    if (typeof Storage === 'undefined') {
-      console.error('Your browser does not support HTML5 Browser Local Storage !')
-      throw new Error('Your browser does not support HTML5 Browser Local Storage !')
-    }
-    return localStorage.removeItem(key)
-  }
-
-  async setItem(key: string, valueToStore: string): Promise<void> {
-    if (typeof Storage === 'undefined') {
-      console.error('Your browser does not support HTML5 Browser Local Storage !')
-      throw new Error('Your browser does not support HTML5 Browser Local Storage !')
-    }
-    return localStorage.setItem(key, valueToStore)
-  }
-}

package/icc-x-api/storage/StorageEntryKeysFactory.ts

@@ -1,39 +0,0 @@
-/**
- * Specifies the entry keys to use for storage of data needed by iCure.
- */
-export interface StorageEntryKeysFactory {
-  /**
-   * Get the entry key for the storage of a key pair of a data owner which was created on this device. All keys created on this device will be
-   * considered as verified and safe.
-   * This entry key will be used in a {@link KeyStorageFacade}.
-   * @param dataOwnerId Id of a data owner.
-   * @param publicKeyFingerprint Fingerprint of the public key in a keypair of the data owner.
-   * @return entry key for the keypair.
-   */
-  deviceKeypairOfDataOwner(dataOwnerId: string, publicKeyFingerprint: string): string
-
-  /**
-   * Get the entry key for the storage of a key pair of a data owner which was recovered from transfer keys or shamir.
-   * These keys are going to be considered as UNSAFE for encryption unless their public key has been verified by the human user and has been stored in
-   * {@link selfPublicKeysVerificationCacheForDataOwner}.
-   * This entry key will be used in a {@link KeyStorageFacade}.
-   * @param dataOwnerId Id of a data owner.
-   * @param publicKeyFingerprint Fingerprint of the public key in a keypair of the data owner.
-   * @return entry key for the keypair.
-   */
-  cachedRecoveredKeypairOfDataOwner(dataOwnerId: string, publicKeyFingerprint: string): string
-
-  /**
-   * Get the entry key for the storage of answers to own public key verification (from {@link CryptoStrategies.verifyOwnPublicKeys}).
-   * This entry key will be used in a {@link StorageFacade}.
-   * @param dataOwnerId Id of a data owner.
-   * @return entry key for verified public keys of the data owner.
-   */
-  selfPublicKeysVerificationCacheForDataOwner(dataOwnerId: string): string
-
-  /*
-   * There is no need to store verified public keys for other data owners: we verify only when we want to create a new exchange key, and we need to
-   * create an exchange key to each user only once unless we lose our key. But we can lose our key only if we delete our data, which means we would
-   * also used the verified keys for other data owners...
-   */
-}

package/icc-x-api/storage/StorageFacade.ts

@@ -1,21 +0,0 @@
-export interface StorageFacade<T> {
-  /**
-   * Returns the value of the provided key from the storage
-   * @param key Key of the value to retrieve
-   * @return The value associated to the provided key or undefined if not found.
-   */
-  getItem(key: string): Promise<T | undefined>
-
-  /**
-   * Set an item in the storage for the given key
-   * @param key Key of the value to set
-   * @param valueToStore
-   */
-  setItem(key: string, valueToStore: T): Promise<void>
-
-  /**
-   * Removes the item with the given key from the storage.
-   * @param key The key of the item to remove.
-   */
-  removeItem(key: string): Promise<void>
-}