@icure/cardinal-sdk 2.13.0 → 2.13.2

package/crypto/entities/SecretIdShareOptions.d.mts

@@ -10,6 +10,10 @@ export declare namespace SecretIdShareOptions {
      *  @param requireAtLeastOne if true the sharing will fail if the current user can't access any secret id of the entity
      */
     class AllAvailable {
+        /**
+         * Share all available secret ids
+         * @param requireAtLeastOne if true the sharing will fail if the current user can't access any secret id of the entity
+         * / */
         requireAtLeastOne: boolean;
         readonly $ktClass: 'com.icure.cardinal.sdk.crypto.entities.SecretIdShareOptions.AllAvailable';
         constructor(partial: Partial<AllAvailable>);

package/crypto/entities/SecretIdShareOptions.mjs

@@ -8,6 +8,10 @@ export var SecretIdShareOptions;
      */
     class AllAvailable {
         constructor(partial) {
+            /**
+             * Share all available secret ids
+             * @param requireAtLeastOne if true the sharing will fail if the current user can't access any secret id of the entity
+             * / */
             this.requireAtLeastOne = false;
             this.$ktClass = 'com.icure.cardinal.sdk.crypto.entities.SecretIdShareOptions.AllAvailable';
             if ('requireAtLeastOne' in partial && partial.requireAtLeastOne !== undefined)

package/crypto/entities/SecretIdUseOption.d.mts

@@ -24,6 +24,11 @@ export declare namespace SecretIdUseOption {
      *  Note that the SDK will not check that the secret id you used is actually a secret id of the owning entity.
      */
     class Use {
+        /**
+         * Specify explicitly which secret ids to use. The secretIds can also be empty, in which case the value is
+         * equivalent to [UseNone].
+         * Note that the SDK will not check that the secret id you used is actually a secret id of the owning entity.
+         * / */
         secretIds: Array<string>;
         readonly $ktClass: 'com.icure.cardinal.sdk.crypto.entities.SecretIdUseOption.Use';
         constructor(partial: Partial<Use> & Pick<Use, "secretIds">);

package/kotlin-kotlin-stdlib.mjs

@@ -48,12 +48,6 @@ 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();
@@ -65,6 +59,12 @@ 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(KtMutableList, 'MutableList', VOID, VOID, [KtList, MutableIterable, Collection]);
-initMetadataForInterface(KtMutableSet, 'MutableSet', VOID, VOID, [KtSet, MutableIterable, Collection]);
+initMetadataForInterface(KtMutableList, 'MutableList', VOID, VOID, [KtList, Collection, MutableIterable]);
+initMetadataForInterface(KtMutableSet, 'MutableSet', VOID, VOID, [KtSet, 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);

package/kotlinx-coroutines-core.mjs

@@ -294,7 +294,7 @@ initMetadataForClass(ContextScope, 'ContextScope', VOID, VOID, [CoroutineScope])
 initMetadataForClass(Symbol, 'Symbol');
 initMetadataForInterface(SelectInstance, 'SelectInstance');
 initMetadataForClass(ClauseData, 'ClauseData', VOID, VOID, VOID, [1]);
-initMetadataForClass(SelectImplementation, 'SelectImplementation', VOID, VOID, [CancelHandler, SelectInstance, Waiter], [0, 2]);
+initMetadataForClass(SelectImplementation, 'SelectImplementation', VOID, VOID, [CancelHandler, Waiter, SelectInstance], [0, 2]);
 initMetadataForClass(TrySelectDetailedResult, 'TrySelectDetailedResult', VOID, Enum);
 initMetadataForClass(CancellableContinuationWithOwner, 'CancellableContinuationWithOwner', VOID, VOID, [CancellableContinuation, Waiter]);
 initMetadataForClass(SemaphoreAndMutexImpl, 'SemaphoreAndMutexImpl', VOID, VOID, VOID, [0]);

package/model/GroupScoped.d.mts

@@ -9,7 +9,25 @@
  *  instances of the SDK working on a different base group, can cause errors and other unexpected behavior.
  */
 export declare class GroupScoped<E> {
+    /**
+     * Wraps an entity and associates it with the group it exists in.
+     *
+     * In-group api methods take in input and return group scoped entities.
+     *
+     * To prevent mistakes, you shouldn't instantiate this class yourself, instead you should always get the GroupScoped
+     * entity from the `inGroup` methods of the apis. Using GroupScoped entities with the wrong groupId, or created by
+     * instances of the SDK working on a different base group, can cause errors and other unexpected behavior.
+     * / */
     entity: E;
+    /**
+     * Wraps an entity and associates it with the group it exists in.
+     *
+     * In-group api methods take in input and return group scoped entities.
+     *
+     * To prevent mistakes, you shouldn't instantiate this class yourself, instead you should always get the GroupScoped
+     * entity from the `inGroup` methods of the apis. Using GroupScoped entities with the wrong groupId, or created by
+     * instances of the SDK working on a different base group, can cause errors and other unexpected behavior.
+     * / */
     groupId: string;
     constructor(partial: Partial<GroupScoped<E>> & Pick<GroupScoped<E>, "entity" | "groupId">);
 }

package/model/embed/AsserterType.d.mts

@@ -1,12 +1,17 @@
 /**
  *
  *
- *   The kind of entity a health element asserter's asserterId refers to.
+ *   The kind of entity a health element asserter's
+ *  [HealthElementAsserterDto.LocalAsserterIdentifier.id] refers to.
  *
  *   This is the *entity-kind* axis, not the role axis: it says what sort of record the id points at,
  *  not what part the
  *   party played in the assertion. Do not confuse it with ParticipantTypeDto.
  *
+ *   It applies to the *local* branch of [HealthElementAsserterDto] only: an asserter named by
+ *   [HealthElementAsserterDto.externalAsserterIdentifier] has no record here, so it carries no
+ *  entity kind.
+ *
  *   The entries deliberately mirror [PartnerTypeDto], which answers the same question for a
  *  partnership's partnerId. The
  *   two enums are kept separate on purpose: partnership vocabulary and asserter vocabulary are free

package/model/embed/AsserterType.mjs

@@ -2,12 +2,17 @@
 /**
  *
  *
- *   The kind of entity a health element asserter's asserterId refers to.
+ *   The kind of entity a health element asserter's
+ *  [HealthElementAsserterDto.LocalAsserterIdentifier.id] refers to.
  *
  *   This is the *entity-kind* axis, not the role axis: it says what sort of record the id points at,
  *  not what part the
  *   party played in the assertion. Do not confuse it with ParticipantTypeDto.
  *
+ *   It applies to the *local* branch of [HealthElementAsserterDto] only: an asserter named by
+ *   [HealthElementAsserterDto.externalAsserterIdentifier] has no record here, so it carries no
+ *  entity kind.
+ *
  *   The entries deliberately mirror [PartnerTypeDto], which answers the same question for a
  *  partnership's partnerId. The
  *   two enums are kept separate on purpose: partnership vocabulary and asserter vocabulary are free

package/model/embed/HealthElementAsserter.d.mts

@@ -1,3 +1,4 @@
+import { Identifier } from '../base/Identifier.mjs';
 import { AsserterType } from './AsserterType.mjs';
 /**
  *
@@ -12,38 +13,79 @@ import { AsserterType } from './AsserterType.mjs';
  *  are asserters, and the
  *   same healthcare element may carry more than one of them.
  *
- *   The two fields must agree: [asserterType] declares which kind of entity [asserterId] points at.
- *  [AsserterTypeDto]
- *   bounds the vocabulary, but nothing enforces the *pairing* - the field is encrypted, so the
- *  server never sees the
- *   values and cannot validate or repair them; that invariant is owned by the SDK.
+ *   The party is named in exactly one of two ways, and exactly one of the two fields must be set:
+ *   - [localAsserterIdentifier] names a party stored in this iCure instance: an id, plus the
+ *  [AsserterTypeDto] saying
+ *     which kind of record that id points at;
+ *   - [externalAsserterIdentifier] names a party that has no record here, through a business
+ *  [IdentifierDto] issued by
+ *     another system. There is deliberately no [AsserterTypeDto] on this branch: the kind of a
+ *  record we do not store is
+ *     not knowable to us.
+ *
+ *   The exactly-one rule is **not** checked on this DTO. It is checked one layer down, in
+ *  `HealthElementAsserter`'s
+ *   `init`: mapping this DTO constructs one, so a violation still surfaces as a `400`, and the rule
+ *  also covers the write
+ *   paths that never build a DTO at all. This class only checks that [LocalAsserterIdentifier.id] is
+ *  not blank. Nothing
+ *   enforces the *pairing* inside [LocalAsserterIdentifier]: [AsserterTypeDto] bounds the
+ *  vocabulary, not what
+ *   [LocalAsserterIdentifier.id] actually points at; that invariant is owned by the SDK.
  *
  *   Note on organisations: an organisation (hospital, practice, care home, ...) is not a distinct
  *  asserter type.
  *   Organisations are stored as healthcare party records, distinguished from individual
  *  practitioners by tags set by the
- *   client, so an organisation asserter is an entry with `asserterType =
- *  AsserterTypeDto.healthcareParty` whose
- *   [asserterId] points to such a record. The association between a practitioner and the
- *  organisation they were acting
- *   for at the time of the assertion is deliberately NOT modelled here.
+ *   client, so an organisation asserter is a [localAsserterIdentifier] with `type =
+ *  AsserterTypeDto.healthcareParty`
+ *   whose `id` points to such a record. The association between a practitioner and the organisation
+ *  they were acting for
+ *   at the time of the assertion is deliberately NOT modelled here.
  */
 export declare class HealthElementAsserter {
     /**
      *
-     *  The id of the entity making the assertion. Which entity it refers to is given by [asserterType].
      *
+     *   The asserting party, as a reference to a record stored in this instance. Null when the party is
+     *  named by
+     *   [externalAsserterIdentifier].
      */
-    asserterId: string;
+    localAsserterIdentifier: HealthElementAsserter.LocalAsserterIdentifier | undefined;
     /**
      *
      *
-     *   The kind of entity [asserterId] refers to. This is the kind of entity, not the role the party
-     *  played - do not
-     *   confuse it with ParticipantTypeDto.
+     *   The asserting party, as a business identifier from a system that is not this one. Null when the
+     *  party is named by
+     *   [localAsserterIdentifier]. Carries no [AsserterTypeDto].
      */
-    asserterType: AsserterType;
-    constructor(partial: Partial<HealthElementAsserter> & Pick<HealthElementAsserter, "asserterId" | "asserterType">);
+    externalAsserterIdentifier: Identifier | undefined;
+    constructor(partial: Partial<HealthElementAsserter>);
     toJSON(): object;
     static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): HealthElementAsserter;
 }
+export declare namespace HealthElementAsserter {
+    /**
+     *
+     *
+     *   A reference to the record, stored in iCure.
+     */
+    class LocalAsserterIdentifier {
+        /**
+         *
+         *  The id of the entity making the assertion. Which entity it refers to is given by [type].
+         */
+        id: string;
+        /**
+         *
+         *
+         *   The kind of entity [id] refers to. This is the kind of entity, not the role the party played -
+         *  do not
+         *   confuse it with ParticipantTypeDto.
+         */
+        type: AsserterType;
+        constructor(partial: Partial<LocalAsserterIdentifier> & Pick<LocalAsserterIdentifier, "type">);
+        toJSON(): object;
+        static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): LocalAsserterIdentifier;
+    }
+}

package/model/embed/HealthElementAsserter.mjs

@@ -1,5 +1,7 @@
 // auto-generated file
-import { expectString, expectStringEnum, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
+import { expectObject, expectString, expectStringEnum, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
+import { randomUuid } from '../../utils/Id.mjs';
+import { Identifier } from '../base/Identifier.mjs';
 import { AsserterType } from './AsserterType.mjs';
 /**
  *
@@ -14,31 +16,65 @@ import { AsserterType } from './AsserterType.mjs';
  *  are asserters, and the
  *   same healthcare element may carry more than one of them.
  *
- *   The two fields must agree: [asserterType] declares which kind of entity [asserterId] points at.
- *  [AsserterTypeDto]
- *   bounds the vocabulary, but nothing enforces the *pairing* - the field is encrypted, so the
- *  server never sees the
- *   values and cannot validate or repair them; that invariant is owned by the SDK.
+ *   The party is named in exactly one of two ways, and exactly one of the two fields must be set:
+ *   - [localAsserterIdentifier] names a party stored in this iCure instance: an id, plus the
+ *  [AsserterTypeDto] saying
+ *     which kind of record that id points at;
+ *   - [externalAsserterIdentifier] names a party that has no record here, through a business
+ *  [IdentifierDto] issued by
+ *     another system. There is deliberately no [AsserterTypeDto] on this branch: the kind of a
+ *  record we do not store is
+ *     not knowable to us.
+ *
+ *   The exactly-one rule is **not** checked on this DTO. It is checked one layer down, in
+ *  `HealthElementAsserter`'s
+ *   `init`: mapping this DTO constructs one, so a violation still surfaces as a `400`, and the rule
+ *  also covers the write
+ *   paths that never build a DTO at all. This class only checks that [LocalAsserterIdentifier.id] is
+ *  not blank. Nothing
+ *   enforces the *pairing* inside [LocalAsserterIdentifier]: [AsserterTypeDto] bounds the
+ *  vocabulary, not what
+ *   [LocalAsserterIdentifier.id] actually points at; that invariant is owned by the SDK.
  *
  *   Note on organisations: an organisation (hospital, practice, care home, ...) is not a distinct
  *  asserter type.
  *   Organisations are stored as healthcare party records, distinguished from individual
  *  practitioners by tags set by the
- *   client, so an organisation asserter is an entry with `asserterType =
- *  AsserterTypeDto.healthcareParty` whose
- *   [asserterId] points to such a record. The association between a practitioner and the
- *  organisation they were acting
- *   for at the time of the assertion is deliberately NOT modelled here.
+ *   client, so an organisation asserter is a [localAsserterIdentifier] with `type =
+ *  AsserterTypeDto.healthcareParty`
+ *   whose `id` points to such a record. The association between a practitioner and the organisation
+ *  they were acting for
+ *   at the time of the assertion is deliberately NOT modelled here.
  */
 export class HealthElementAsserter {
     constructor(partial) {
-        this.asserterId = partial.asserterId;
-        this.asserterType = partial.asserterType;
+        /**
+         *
+         *
+         *   The asserting party, as a reference to a record stored in this instance. Null when the party is
+         *  named by
+         *   [externalAsserterIdentifier].
+         */
+        this.localAsserterIdentifier = undefined;
+        /**
+         *
+         *
+         *   The asserting party, as a business identifier from a system that is not this one. Null when the
+         *  party is named by
+         *   [localAsserterIdentifier]. Carries no [AsserterTypeDto].
+         */
+        this.externalAsserterIdentifier = undefined;
+        if ('localAsserterIdentifier' in partial)
+            this.localAsserterIdentifier = partial.localAsserterIdentifier;
+        if ('externalAsserterIdentifier' in partial)
+            this.externalAsserterIdentifier = partial.externalAsserterIdentifier;
     }
     toJSON() {
         const res = {};
-        res['asserterId'] = this.asserterId;
-        res['asserterType'] = this.asserterType;
+        if (this.localAsserterIdentifier != undefined)
+            res['localAsserterIdentifier'] = this.localAsserterIdentifier.toJSON();
+        if (this.externalAsserterIdentifier != undefined)
+            res['externalAsserterIdentifier'] = this.externalAsserterIdentifier.toJSON();
         return res;
     }
     static fromJSON(json, ignoreUnknownKeys = false, path = ['HealthElementAsserter']) {
@@ -46,8 +82,8 @@ export class HealthElementAsserter {
             throw new Error(`Expected json object at path ${path.join("")}`);
         const jCpy = Object.assign({}, json);
         const res = new HealthElementAsserter({
-            asserterId: expectString(extractEntry(jCpy, 'asserterId', true, path), false, [...path, ".asserterId"]),
-            asserterType: expectStringEnum(extractEntry(jCpy, 'asserterType', true, path), false, [...path, ".asserterType"], AsserterType, 'AsserterType'),
+            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),
         });
         if (!ignoreUnknownKeys) {
             const unused = Object.keys(jCpy);
@@ -57,3 +93,39 @@ export class HealthElementAsserter {
         return res;
     }
 }
+(function (HealthElementAsserter) {
+    /**
+     *
+     *
+     *   A reference to the record, stored in iCure.
+     */
+    class LocalAsserterIdentifier {
+        constructor(partial) {
+            var _a;
+            this.id = (_a = partial.id) !== null && _a !== void 0 ? _a : randomUuid();
+            this.type = partial.type;
+        }
+        toJSON() {
+            const res = {};
+            res['id'] = this.id;
+            res['type'] = this.type;
+            return res;
+        }
+        static fromJSON(json, ignoreUnknownKeys = false, path = ['LocalAsserterIdentifier']) {
+            if (typeof json != 'object')
+                throw new Error(`Expected json object at path ${path.join("")}`);
+            const jCpy = Object.assign({}, json);
+            const res = new LocalAsserterIdentifier({
+                id: expectString(extractEntry(jCpy, 'id', true, path), false, [...path, ".id"]),
+                type: expectStringEnum(extractEntry(jCpy, 'type', true, path), false, [...path, ".type"], AsserterType, 'AsserterType'),
+            });
+            if (!ignoreUnknownKeys) {
+                const unused = Object.keys(jCpy);
+                if (unused.length > 0)
+                    throw new Error(`Unexpected key(s) for json object LocalAsserterIdentifier at path ${path.join("")}: ${unused}`);
+            }
+            return res;
+        }
+    }
+    HealthElementAsserter.LocalAsserterIdentifier = LocalAsserterIdentifier;
+})(HealthElementAsserter || (HealthElementAsserter = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@icure/cardinal-sdk",
-  "version": "2.13.0",
+  "version": "2.13.2",
   "main": "cardinal-sdk-ts.mjs",
   "types": "cardinal-sdk-ts.d.mts",
   "devDependencies": {

package/subscription/EntitySubscriptionEvent.d.mts

@@ -19,6 +19,9 @@ export declare namespace EntitySubscriptionEvent {
      *  A general unexpected error.
      */
     class UnexpectedError {
+        /**
+         * A general unexpected error.
+         * / */
         message: string;
         readonly $ktClass: 'com.icure.cardinal.sdk.subscription.EntitySubscriptionEvent.UnexpectedError';
         constructor(partial: Partial<UnexpectedError> & Pick<UnexpectedError, "message">);