@icure/cardinal-sdk 3.0.0-PREVIEW-2 → 3.0.0-PREVIEW-3

package/crypto/CryptoStrategies.d.mts

@@ -4,7 +4,7 @@ import { KeypairFingerprintV1String } from "../model/specializations/KeypairFing
 import { CryptoActorStubWithType } from "../model/CryptoActorStubWithType.mjs";
 import { RecoveryResult } from "./entities/RecoveryResult.mjs";
 import { RecoveryDataKey } from "./entities/RecoveryDataKey.mjs";
-import { RsaAlgorithm, XCryptoService, XRsaKeypair } from "./CryptoService.mjs";
+import { RsaAlgorithm, RsaEncryptionAlgorithm, XCryptoService, XRsaKeypair } from "./CryptoService.mjs";
 import { CardinalApis } from "../sdk/CardinalSdk.mjs";
 /**
  * Allows customizing the behavior of the crypto api to better suit your needs.
@@ -54,21 +54,57 @@ export declare class CryptoStrategies {
      */
     generateNewKeyForDataOwner(self: DataOwnerWithType, cryptoPrimitives: XCryptoService): Promise<CryptoStrategies.KeyGenerationRequestResult>;
     /**
-     * Verifies if the public keys of a data owner which will be the delegate of a new exchange key do actually belong to the person the data owner
-     * represents. This method is not called when the delegate would be the current data owner for the api.
+     * Verifies if the public keys of a data owner which will be the delegate of new exchange data do actually belong to
+     * the person the data owner represents; if you do not override this method the public keys of the delegate are
+     * obtained from the cardinal backend and are fully trusted.
      *
-     * The user will have to obtain the verified public keys of the delegate from outside iCure, for example by email with another hcp, by checking the
-     * personal website of the other user, or by scanning verification qr codes at the doctor office...
+     * Note that this method is not called when:
+     * - The delegate id the current SDK delegator actor
+     * - The delegate is a parent type data owner linked from the current SDK delegator actor.
+     * - The SDK is creating exchange data to a simple-type group of data owners (in that case [getDelegatesPublicKeys] is used)
+     *
+     * There are two approaches you can use for verification of public keys: a separate service not controlled by iCure,
+     * or interaction with the end user.
+     *
+     * For example this method may ask the end user to compare the public keys with verified public keys of the delegate
+     * obtained from out of iCure, such as an email, the personal website of the other user, or by scanning verification
+     * qr codes at the doctor office.
+     *
+     * As long as one of the public keys is verified the creation of a new exchange key will succeed.
+     *
+     * If no public key is verified the operation will fail.
      *
-     * As long as one of the public keys is verified the creation of a new exchange key will succeed. If no public key is verified the operation will
-     * fail.
      * @param delegate the potential data owner delegate.
      * @param publicKeys public keys requiring verification, in spki hex-encoded format.
      * @param cryptoPrimitives cryptographic primitives you can use to support the process.
-     * @param groupId the id of the data owner's group, or null if the data owner is in the same group as the current user
+     * @param groupId the id of the delegate data owner's group, or null if the data owner is in the same group as the current user
      * @return all verified public keys, in spki hex-encoded format.
      */
     verifyDelegatePublicKeys(delegate: CryptoActorStubWithType, publicKeys: Array<SpkiHexString>, cryptoPrimitives: XCryptoService, groupId: string | undefined): Promise<Array<SpkiHexString>>;
+    /**
+     * Similarly to [verifyDelegatePublicKeys] this method can be used if you don't want the SDK to fully trust the
+     * public keys coming from the cardinal backend, however this method is only called when creating exchange data for
+     * a simple-type data owner group, which may require to get validated public keys for many data owners.
+     *
+     * In that case interaction with the end-user is undesired, and it would be better instead to have a dedicated
+     * service separated from cardinal that provides the public keys of your cardinal data owners.
+     *
+     * Note that:
+     * - Returning null means the SDK will retrieve public keys from the cardinal backend and fully trust them.
+     * - If this method does not return null, it must provide at least a key for each delegate
+     * - Unlike [verifyDelegatePublicKeys] this method might be called even for delegates that are parent of the current
+     *   SDK delegator actor.
+     * - The keys returned by this method will not be checked against the cardinal backend; if there are any
+     *   inconsistencies the SDK might create invalid exchange data.
+     *
+     * @param delegates delegates for which the public keys are required.
+     * @param groupId the id of the delegate data owners' group, or null if their group is the same as the current user
+     */
+    getDelegatesPublicKeys(delegates: Array<string>, groupId: string | undefined): Promise<{
+        [delegateId: string]: {
+            [publicKey: SpkiHexString]: RsaEncryptionAlgorithm;
+        };
+    } | undefined>;
     /**
      * Specifies if a data owner requires anonymous delegations, i.e. his id should not appear unencrypted in new secure
      * delegations.

package/crypto/CryptoStrategies.mjs

@@ -51,23 +51,57 @@ export class CryptoStrategies {
         return Promise.resolve(CryptoStrategies.KeyGenerationRequestResult.Allow);
     }
     /**
-     * Verifies if the public keys of a data owner which will be the delegate of a new exchange key do actually belong to the person the data owner
-     * represents. This method is not called when the delegate would be the current data owner for the api.
+     * Verifies if the public keys of a data owner which will be the delegate of new exchange data do actually belong to
+     * the person the data owner represents; if you do not override this method the public keys of the delegate are
+     * obtained from the cardinal backend and are fully trusted.
      *
-     * The user will have to obtain the verified public keys of the delegate from outside iCure, for example by email with another hcp, by checking the
-     * personal website of the other user, or by scanning verification qr codes at the doctor office...
+     * Note that this method is not called when:
+     * - The delegate id the current SDK delegator actor
+     * - The delegate is a parent type data owner linked from the current SDK delegator actor.
+     * - The SDK is creating exchange data to a simple-type group of data owners (in that case [getDelegatesPublicKeys] is used)
+     *
+     * There are two approaches you can use for verification of public keys: a separate service not controlled by iCure,
+     * or interaction with the end user.
+     *
+     * For example this method may ask the end user to compare the public keys with verified public keys of the delegate
+     * obtained from out of iCure, such as an email, the personal website of the other user, or by scanning verification
+     * qr codes at the doctor office.
+     *
+     * As long as one of the public keys is verified the creation of a new exchange key will succeed.
+     *
+     * If no public key is verified the operation will fail.
      *
-     * As long as one of the public keys is verified the creation of a new exchange key will succeed. If no public key is verified the operation will
-     * fail.
      * @param delegate the potential data owner delegate.
      * @param publicKeys public keys requiring verification, in spki hex-encoded format.
      * @param cryptoPrimitives cryptographic primitives you can use to support the process.
-     * @param groupId the id of the data owner's group, or null if the data owner is in the same group as the current user
+     * @param groupId the id of the delegate data owner's group, or null if the data owner is in the same group as the current user
      * @return all verified public keys, in spki hex-encoded format.
      */
     verifyDelegatePublicKeys(delegate, publicKeys, cryptoPrimitives, groupId) {
         return Promise.resolve(publicKeys);
     }
+    /**
+     * Similarly to [verifyDelegatePublicKeys] this method can be used if you don't want the SDK to fully trust the
+     * public keys coming from the cardinal backend, however this method is only called when creating exchange data for
+     * a simple-type data owner group, which may require to get validated public keys for many data owners.
+     *
+     * In that case interaction with the end-user is undesired, and it would be better instead to have a dedicated
+     * service separated from cardinal that provides the public keys of your cardinal data owners.
+     *
+     * Note that:
+     * - Returning null means the SDK will retrieve public keys from the cardinal backend and fully trust them.
+     * - If this method does not return null, it must provide at least a key for each delegate
+     * - Unlike [verifyDelegatePublicKeys] this method might be called even for delegates that are parent of the current
+     *   SDK delegator actor.
+     * - The keys returned by this method will not be checked against the cardinal backend; if there are any
+     *   inconsistencies the SDK might create invalid exchange data.
+     *
+     * @param delegates delegates for which the public keys are required.
+     * @param groupId the id of the delegate data owners' group, or null if their group is the same as the current user
+     */
+    getDelegatesPublicKeys(delegates, groupId) {
+        return Promise.resolve(undefined);
+    }
     /**
      * Specifies if a data owner requires anonymous delegations, i.e. his id should not appear unencrypted in new secure
      * delegations.

package/kotlin-kotlin-stdlib.mjs

@@ -48,6 +48,12 @@ if (typeof Math.clz32 === 'undefined') {
     };
   }(Math.log, Math.LN2);
 }
+if (typeof String.prototype.startsWith === 'undefined') {
+  Object.defineProperty(String.prototype, 'startsWith', {value: function (searchString, position) {
+    position = position || 0;
+    return this.lastIndexOf(searchString, position) === position;
+  }});
+}
 if (typeof String.prototype.endsWith === 'undefined') {
   Object.defineProperty(String.prototype, 'endsWith', {value: function (searchString, position) {
     var subjectString = this.toString();
@@ -59,12 +65,6 @@ if (typeof String.prototype.endsWith === 'undefined') {
     return lastIndex !== -1 && lastIndex === position;
   }});
 }
-if (typeof String.prototype.startsWith === 'undefined') {
-  Object.defineProperty(String.prototype, 'startsWith', {value: function (searchString, position) {
-    position = position || 0;
-    return this.lastIndexOf(searchString, position) === position;
-  }});
-}
 //endregion
 //region block: imports
 var imul_0 = Math.imul;
@@ -93,8 +93,8 @@ initMetadataForInterface(Entry, 'Entry');
 initMetadataForInterface(KtMap, 'Map');
 initMetadataForInterface(KtSet, 'Set', VOID, VOID, [Collection]);
 initMetadataForInterface(MutableIterable, 'MutableIterable');
-initMetadataForInterface(KtMutableSet, 'MutableSet', VOID, VOID, [KtSet, MutableIterable, Collection]);
-initMetadataForInterface(KtMutableList, 'MutableList', VOID, VOID, [KtList, MutableIterable, Collection]);
+initMetadataForInterface(KtMutableSet, 'MutableSet', VOID, VOID, [KtSet, Collection, MutableIterable]);
+initMetadataForInterface(KtMutableList, 'MutableList', VOID, VOID, [KtList, Collection, MutableIterable]);
 initMetadataForInterface(KtMutableMap, 'MutableMap', VOID, VOID, [KtMap]);
 initMetadataForCompanion(Companion_0);
 initMetadataForClass(Enum, 'Enum', VOID, VOID, [Comparable]);
@@ -115,7 +115,7 @@ initMetadataForInterface(AutoCloseable, 'AutoCloseable');
 initMetadataForInterface(Comparator, 'Comparator');
 initMetadataForObject(Unit, 'Unit');
 initMetadataForClass(AbstractCollection, 'AbstractCollection', VOID, VOID, [Collection]);
-initMetadataForClass(AbstractMutableCollection, 'AbstractMutableCollection', VOID, AbstractCollection, [MutableIterable, Collection]);
+initMetadataForClass(AbstractMutableCollection, 'AbstractMutableCollection', VOID, AbstractCollection, [Collection, MutableIterable]);
 initMetadataForClass(IteratorImpl, 'IteratorImpl');
 initMetadataForClass(ListIteratorImpl, 'ListIteratorImpl', VOID, IteratorImpl);
 initMetadataForClass(AbstractMutableList, 'AbstractMutableList', VOID, AbstractMutableCollection, [KtMutableList]);
@@ -128,7 +128,7 @@ initMetadataForCompanion(Companion_2);
 initMetadataForClass(ArrayList, 'ArrayList', ArrayList_init_$Create$, AbstractMutableList, [KtMutableList, RandomAccess]);
 initMetadataForClass(HashMap, 'HashMap', HashMap_init_$Create$, AbstractMutableMap, [KtMutableMap]);
 initMetadataForClass(HashMapKeys, 'HashMapKeys', VOID, AbstractMutableSet, [KtMutableSet]);
-initMetadataForClass(HashMapValues, 'HashMapValues', VOID, AbstractMutableCollection, [MutableIterable, Collection]);
+initMetadataForClass(HashMapValues, 'HashMapValues', VOID, AbstractMutableCollection, [Collection, MutableIterable]);
 initMetadataForClass(HashMapEntrySetBase, 'HashMapEntrySetBase', VOID, AbstractMutableSet, [KtMutableSet]);
 initMetadataForClass(HashMapEntrySet, 'HashMapEntrySet', VOID, HashMapEntrySetBase);
 initMetadataForClass(HashMapKeysDefault$iterator$1);
@@ -1325,6 +1325,22 @@ function contains_4(_this__u8e3s4, element) {
     return _this__u8e3s4.q1(element);
   return indexOf_4(_this__u8e3s4, element) >= 0;
 }
+function minus(_this__u8e3s4, elements) {
+  var other = convertToListIfNotCollection(elements);
+  if (other.r())
+    return toList_1(_this__u8e3s4);
+  // Inline function 'kotlin.collections.filterNot' call
+  // Inline function 'kotlin.collections.filterNotTo' call
+  var destination = ArrayList_init_$Create$();
+  var _iterator__ex2g4s = _this__u8e3s4.t();
+  while (_iterator__ex2g4s.u()) {
+    var element = _iterator__ex2g4s.v();
+    if (!other.q1(element)) {
+      destination.j1(element);
+    }
+  }
+  return destination;
+}
 function intersect(_this__u8e3s4, other) {
   var otherCollection = convertToListIfNotCollection(other);
   // Inline function 'kotlin.collections.mutableSetOf' call
@@ -1620,7 +1636,7 @@ function plus_5(_this__u8e3s4, elements) {
   addAll(result, elements);
   return result;
 }
-function minus(_this__u8e3s4, element) {
+function minus_0(_this__u8e3s4, element) {
   var result = LinkedHashSet_init_$Create$_1(mapCapacity(_this__u8e3s4.m1()));
   var removed = false;
   // Inline function 'kotlin.collections.filterTo' call
@@ -1640,7 +1656,7 @@ function minus(_this__u8e3s4, element) {
   }
   return result;
 }
-function minus_0(_this__u8e3s4, elements) {
+function minus_1(_this__u8e3s4, elements) {
   var other = convertToListIfNotCollection(elements);
   if (other.r())
     return toSet_0(_this__u8e3s4);
@@ -9823,7 +9839,7 @@ function plus_10(_this__u8e3s4, pair) {
 function toMutableMap(_this__u8e3s4) {
   return LinkedHashMap_init_$Create$_1(_this__u8e3s4);
 }
-function minus_1(_this__u8e3s4, key) {
+function minus_2(_this__u8e3s4, key) {
   // Inline function 'kotlin.apply' call
   var this_0 = toMutableMap(_this__u8e3s4);
   // Inline function 'kotlin.collections.minusAssign' call
@@ -17470,9 +17486,10 @@ export {
   mapCapacity as mapCapacity1h45rc3eh9p2l,
   mapOf as mapOf2zpbbmyqk8xpf,
   mapOf_0 as mapOf1xd03cq9cnmy8,
-  minus_1 as minus1f3bieyodk5vw,
-  minus_0 as minus165a8u1e0x1lu,
-  minus as minus27abgkurcn6u0,
+  minus_2 as minus1f3bieyodk5vw,
+  minus_1 as minus165a8u1e0x1lu,
+  minus as minus2znw4oicpx34e,
+  minus_0 as minus27abgkurcn6u0,
   mutableListOf as mutableListOf6oorvk2mtdmp,
   mutableSetOf as mutableSetOf3lxrr4fe5z3v8,
   plus_9 as plus2m1vv33moko5t,

package/kotlinx-coroutines-core.mjs

@@ -235,11 +235,6 @@ initMetadataForClass(BufferedChannelIterator, 'BufferedChannelIterator', VOID, V
 initMetadataForCoroutine($sendCOROUTINE$, CoroutineImpl);
 initMetadataForCoroutine($receiveCOROUTINE$, CoroutineImpl);
 initMetadataForCoroutine($receiveCatchingCOROUTINE$, CoroutineImpl);
-function close$default(cause, $super) {
-  cause = cause === VOID ? null : cause;
-  return $super === VOID ? this.e1e(cause) : $super.e1e.call(this, cause);
-}
-initMetadataForInterface(SendChannel, 'SendChannel', VOID, VOID, VOID, [1]);
 function cancel$default_0(cause, $super) {
   cause = cause === VOID ? null : cause;
   var tmp;
@@ -252,7 +247,12 @@ function cancel$default_0(cause, $super) {
   return tmp;
 }
 initMetadataForInterface(ReceiveChannel, 'ReceiveChannel', VOID, VOID, VOID, [0]);
-initMetadataForClass(BufferedChannel, 'BufferedChannel', VOID, VOID, [SendChannel, ReceiveChannel], [1, 4, 0, 3]);
+function close$default(cause, $super) {
+  cause = cause === VOID ? null : cause;
+  return $super === VOID ? this.e1e(cause) : $super.e1e.call(this, cause);
+}
+initMetadataForInterface(SendChannel, 'SendChannel', VOID, VOID, VOID, [1]);
+initMetadataForClass(BufferedChannel, 'BufferedChannel', VOID, VOID, [ReceiveChannel, SendChannel], [1, 4, 0, 3]);
 initMetadataForClass(WaiterEB, 'WaiterEB');
 initMetadataForClass(ReceiveCatching, 'ReceiveCatching', VOID, VOID, [Waiter]);
 initMetadataForObject(Factory, 'Factory');
@@ -262,7 +262,7 @@ initMetadataForCompanion(Companion);
 initMetadataForClass(ChannelResult, 'ChannelResult');
 initMetadataForClass(ClosedReceiveChannelException, 'ClosedReceiveChannelException', VOID, NoSuchElementException);
 initMetadataForClass(ClosedSendChannelException, 'ClosedSendChannelException', VOID, IllegalStateException);
-initMetadataForClass(ChannelCoroutine, 'ChannelCoroutine', VOID, AbstractCoroutine, [SendChannel, ReceiveChannel], [1, 0]);
+initMetadataForClass(ChannelCoroutine, 'ChannelCoroutine', VOID, AbstractCoroutine, [ReceiveChannel, SendChannel], [1, 0]);
 initMetadataForClass(ConflatedBufferedChannel, 'ConflatedBufferedChannel', VOID, BufferedChannel, VOID, [1, 0]);
 initMetadataForInterface(ProducerScope, 'ProducerScope', VOID, VOID, [CoroutineScope, SendChannel], [1]);
 initMetadataForClass(ProducerCoroutine, 'ProducerCoroutine', VOID, ChannelCoroutine, [ProducerScope], [1, 0]);

package/model/PaginatedDocumentKeyIdPair.d.mts

@@ -13,7 +13,6 @@ export declare class PaginatedDocumentKeyIdPair {
      *
      *  The document identifier to start the next page from, used to disambiguate when multiple
      *  documents share the same key.
-     *  Always null for requests that use grouped reduced views.
      */
     startKeyDocId: string | undefined;
     constructor(partial: Partial<PaginatedDocumentKeyIdPair>);

package/model/PaginatedDocumentKeyIdPair.mjs

@@ -16,7 +16,6 @@ export class PaginatedDocumentKeyIdPair {
          *
          *  The document identifier to start the next page from, used to disambiguate when multiple
          *  documents share the same key.
-         *  Always null for requests that use grouped reduced views.
          */
         this.startKeyDocId = undefined;
         if ('startKey' in partial)

package/model/embed/HealthElementAsserter.d.mts

@@ -59,7 +59,7 @@ export declare class HealthElementAsserter {
      *  party is named by
      *   [localAsserterIdentifier]. Carries no [AsserterTypeDto].
      */
-    externalAsserterIdentifier: Identifier | undefined;
+    externalAsserterIdentifier: HealthElementAsserter.ExternalAsserterIdentifier | undefined;
     constructor(partial: Partial<HealthElementAsserter>);
     toJSON(): object;
     static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): HealthElementAsserter;
@@ -88,4 +88,33 @@ export declare namespace HealthElementAsserter {
         toJSON(): object;
         static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): LocalAsserterIdentifier;
     }
+    /**
+     *
+     *
+     *   The party making the assertion, when it has no record in this iCure instance.
+     *
+     *   The party is named by a business [identifier] issued by another system: a national registry
+     *  number, an entry in
+     *   the sending hospital's directory, and so on. Because the record lives elsewhere there is no
+     *  [AsserterTypeDto]
+     *   here - the kind of a record we do not store is not knowable to us. The wrapper around the
+     *  [IdentifierDto] mirrors
+     *   [LocalAsserterIdentifier] on the other branch, and is where anything specific to an external
+     *  asserter would go:
+     *   [IdentifierDto] itself is shared by every `identifiers` field in the model and cannot carry it.
+     */
+    class ExternalAsserterIdentifier {
+        /**
+         *
+         *
+         *   The business identifier of the party in the system that issued it. `system` names that issuing
+         *  system and
+         *   `value` is the party's identifier within it; together they are what makes the party
+         *  resolvable.
+         */
+        identifier: Identifier;
+        constructor(partial: Partial<ExternalAsserterIdentifier> & Pick<ExternalAsserterIdentifier, "identifier">);
+        toJSON(): object;
+        static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): ExternalAsserterIdentifier;
+    }
 }

package/model/embed/HealthElementAsserter.mjs

@@ -83,7 +83,7 @@ export class HealthElementAsserter {
         const jCpy = Object.assign({}, json);
         const res = new HealthElementAsserter({
             localAsserterIdentifier: expectObject(extractEntry(jCpy, 'localAsserterIdentifier', false, path), true, ignoreUnknownKeys, [...path, ".localAsserterIdentifier"], HealthElementAsserter.LocalAsserterIdentifier.fromJSON),
-            externalAsserterIdentifier: expectObject(extractEntry(jCpy, 'externalAsserterIdentifier', false, path), true, ignoreUnknownKeys, [...path, ".externalAsserterIdentifier"], Identifier.fromJSON),
+            externalAsserterIdentifier: expectObject(extractEntry(jCpy, 'externalAsserterIdentifier', false, path), true, ignoreUnknownKeys, [...path, ".externalAsserterIdentifier"], HealthElementAsserter.ExternalAsserterIdentifier.fromJSON),
         });
         if (!ignoreUnknownKeys) {
             const unused = Object.keys(jCpy);
@@ -128,4 +128,44 @@ export class HealthElementAsserter {
         }
     }
     HealthElementAsserter.LocalAsserterIdentifier = LocalAsserterIdentifier;
+    /**
+     *
+     *
+     *   The party making the assertion, when it has no record in this iCure instance.
+     *
+     *   The party is named by a business [identifier] issued by another system: a national registry
+     *  number, an entry in
+     *   the sending hospital's directory, and so on. Because the record lives elsewhere there is no
+     *  [AsserterTypeDto]
+     *   here - the kind of a record we do not store is not knowable to us. The wrapper around the
+     *  [IdentifierDto] mirrors
+     *   [LocalAsserterIdentifier] on the other branch, and is where anything specific to an external
+     *  asserter would go:
+     *   [IdentifierDto] itself is shared by every `identifiers` field in the model and cannot carry it.
+     */
+    class ExternalAsserterIdentifier {
+        constructor(partial) {
+            this.identifier = partial.identifier;
+        }
+        toJSON() {
+            const res = {};
+            res['identifier'] = this.identifier.toJSON();
+            return res;
+        }
+        static fromJSON(json, ignoreUnknownKeys = false, path = ['ExternalAsserterIdentifier']) {
+            if (typeof json != 'object')
+                throw new Error(`Expected json object at path ${path.join("")}`);
+            const jCpy = Object.assign({}, json);
+            const res = new ExternalAsserterIdentifier({
+                identifier: expectObject(extractEntry(jCpy, 'identifier', true, path), false, ignoreUnknownKeys, [...path, ".identifier"], Identifier.fromJSON),
+            });
+            if (!ignoreUnknownKeys) {
+                const unused = Object.keys(jCpy);
+                if (unused.length > 0)
+                    throw new Error(`Unexpected key(s) for json object ExternalAsserterIdentifier at path ${path.join("")}: ${unused}`);
+            }
+            return res;
+        }
+    }
+    HealthElementAsserter.ExternalAsserterIdentifier = ExternalAsserterIdentifier;
 })(HealthElementAsserter || (HealthElementAsserter = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@icure/cardinal-sdk",
-  "version": "3.0.0-PREVIEW-2",
+  "version": "3.0.0-PREVIEW-3",
   "main": "cardinal-sdk-ts.mjs",
   "types": "cardinal-sdk-ts.d.mts",
   "devDependencies": {