@icure/cardinal-sdk 2.13.1 → 2.13.3

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"], HealthElementAsserter.ExternalAsserterIdentifier.fromJSON),
         });
         if (!ignoreUnknownKeys) {
             const unused = Object.keys(jCpy);
@@ -57,3 +93,79 @@ 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;
+    /**
+     *
+     *
+     *   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/model/embed/form/template/Field.d.mts

@@ -17,4 +17,4 @@ import { TimePicker } from './TimePicker.mjs';
  *  validation rules, and optional codification and tagging.
  *  /
  */
-export type Field = DropdownField | TimePicker | RadioButton | DatePicker | MeasureField | TextField | DateTimePicker | MultipleChoice | CheckBox | NumberField;
+export type Field = DatePicker | MeasureField | DateTimePicker | TextField | CheckBox | DropdownField | NumberField | TimePicker | RadioButton | MultipleChoice;

package/model/embed/form/template/StructureElement.d.mts

@@ -6,7 +6,7 @@ import { FieldsGroup } from './FieldsGroup.mjs';
  *  groups.
  *  /
  */
-export type StructureElement = Field | FieldsGroup;
+export type StructureElement = FieldsGroup | Field;
 export declare namespace StructureElement {
     function fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): StructureElement;
 }

package/model/embed/form/template/StructureElement.mjs

@@ -14,17 +14,17 @@ export var StructureElement;
 (function (StructureElement) {
     function fromJSON(json, ignoreUnknownKeys = false, path = ['StructureElement']) {
         switch (json.$ktClass) {
-            case 'com.icure.cardinal.sdk.model.embed.form.template.DropdownField': return DropdownField.fromJSON(json, ignoreUnknownKeys);
-            case 'com.icure.cardinal.sdk.model.embed.form.template.TimePicker': return TimePicker.fromJSON(json, ignoreUnknownKeys);
-            case 'com.icure.cardinal.sdk.model.embed.form.template.RadioButton': return RadioButton.fromJSON(json, ignoreUnknownKeys);
+            case 'com.icure.cardinal.sdk.model.embed.form.template.FieldsGroup': return FieldsGroup.fromJSON(json, ignoreUnknownKeys);
             case 'com.icure.cardinal.sdk.model.embed.form.template.DatePicker': return DatePicker.fromJSON(json, ignoreUnknownKeys);
             case 'com.icure.cardinal.sdk.model.embed.form.template.MeasureField': return MeasureField.fromJSON(json, ignoreUnknownKeys);
-            case 'com.icure.cardinal.sdk.model.embed.form.template.TextField': return TextField.fromJSON(json, ignoreUnknownKeys);
             case 'com.icure.cardinal.sdk.model.embed.form.template.DateTimePicker': return DateTimePicker.fromJSON(json, ignoreUnknownKeys);
-            case 'com.icure.cardinal.sdk.model.embed.form.template.MultipleChoice': return MultipleChoice.fromJSON(json, ignoreUnknownKeys);
+            case 'com.icure.cardinal.sdk.model.embed.form.template.TextField': return TextField.fromJSON(json, ignoreUnknownKeys);
             case 'com.icure.cardinal.sdk.model.embed.form.template.CheckBox': return CheckBox.fromJSON(json, ignoreUnknownKeys);
+            case 'com.icure.cardinal.sdk.model.embed.form.template.DropdownField': return DropdownField.fromJSON(json, ignoreUnknownKeys);
             case 'com.icure.cardinal.sdk.model.embed.form.template.NumberField': return NumberField.fromJSON(json, ignoreUnknownKeys);
-            case 'com.icure.cardinal.sdk.model.embed.form.template.FieldsGroup': return FieldsGroup.fromJSON(json, ignoreUnknownKeys);
+            case 'com.icure.cardinal.sdk.model.embed.form.template.TimePicker': return TimePicker.fromJSON(json, ignoreUnknownKeys);
+            case 'com.icure.cardinal.sdk.model.embed.form.template.RadioButton': return RadioButton.fromJSON(json, ignoreUnknownKeys);
+            case 'com.icure.cardinal.sdk.model.embed.form.template.MultipleChoice': return MultipleChoice.fromJSON(json, ignoreUnknownKeys);
             default: throw new Error('Unexpected discriminator for StructureElement: ' + json.$ktClass);
         }
     }

package/model/filter/predicate/Predicate.d.mts

@@ -9,7 +9,7 @@ import { OrPredicate } from './OrPredicate.mjs';
  *  chain.
  *  /
  */
-export type Predicate = KeyValuePredicate | AlwaysPredicate | NotPredicate | AndPredicate | OrPredicate;
+export type Predicate = NotPredicate | AndPredicate | OrPredicate | KeyValuePredicate | AlwaysPredicate;
 export declare namespace Predicate {
     function fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): Predicate;
 }

package/model/filter/predicate/Predicate.mjs

@@ -8,11 +8,11 @@ export var Predicate;
 (function (Predicate) {
     function fromJSON(json, ignoreUnknownKeys = false, path = ['Predicate']) {
         switch (json.$ktClass) {
-            case 'com.icure.cardinal.sdk.model.filter.predicate.KeyValuePredicate': return KeyValuePredicate.fromJSON(json, ignoreUnknownKeys);
-            case 'com.icure.cardinal.sdk.model.filter.predicate.AlwaysPredicate': return AlwaysPredicate.fromJSON(json, ignoreUnknownKeys);
             case 'com.icure.cardinal.sdk.model.filter.predicate.NotPredicate': return NotPredicate.fromJSON(json, ignoreUnknownKeys);
             case 'com.icure.cardinal.sdk.model.filter.predicate.AndPredicate': return AndPredicate.fromJSON(json, ignoreUnknownKeys);
             case 'com.icure.cardinal.sdk.model.filter.predicate.OrPredicate': return OrPredicate.fromJSON(json, ignoreUnknownKeys);
+            case 'com.icure.cardinal.sdk.model.filter.predicate.KeyValuePredicate': return KeyValuePredicate.fromJSON(json, ignoreUnknownKeys);
+            case 'com.icure.cardinal.sdk.model.filter.predicate.AlwaysPredicate': return AlwaysPredicate.fromJSON(json, ignoreUnknownKeys);
             default: throw new Error('Unexpected discriminator for Predicate: ' + json.$ktClass);
         }
     }