@icure/api 8.13.0 → 8.13.1

package/icc-api/model/HealthElementAsserter.d.ts

@@ -1,3 +1,4 @@
+import { Identifier } from './Identifier';
 /**
  * The party asserting that the patient has the healthcare element this asserter is attached to.
  *
@@ -6,28 +7,68 @@
  * report a condition on behalf of the patient, and a physician may assert a diagnosis: all three 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. The type 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.
+ * 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 `AsserterTypeEnum` saying
+ *   which kind of record that id points at;
+ * - `externalAsserterIdentifier` names a party that has no record here, through a business `Identifier` issued by
+ *   another system. There is deliberately no asserter type on this branch: the kind of a record we do not store is not
+ *   knowable to us.
+ *
+ * Both fields of `LocalAsserterIdentifier` are required by the server and by the other iCure SDKs, and are declared
+ * optional here only because every model in this layer is. An asserter written with a partial local identifier cannot
+ * be read back by those SDKs.
+ *
+ * Do not rely on the server to enforce any of the above. `asserters` is encrypted by default (see
+ * `EncryptedFieldsConfig.Defaults.healthElement`), so the server usually sees only ciphertext and its own checks - the
+ * exactly-one rule, id not blank - never run. They do run for a client that overrides `encryptedFieldsConfig` for
+ * health elements without keeping `asserters` in the list, and a violation then surfaces as a `400`. The pairing inside
+ * `LocalAsserterIdentifier` is never checked anywhere: `AsserterTypeEnum` bounds the vocabulary, not what the id
+ * actually points at. All of these invariants are the caller's responsibility.
  *
  * 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 = '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 = '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 {
     constructor(json: JSON | any);
     /**
-     * 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. Unset when the party is named by
+     * externalAsserterIdentifier.
      */
-    asserterId?: string;
+    localAsserterIdentifier?: HealthElementAsserter.LocalAsserterIdentifier;
     /**
-     * The kind of entity asserterId refers to. This is the entity-kind axis, not the role the party played in the
-     * assertion.
+     * The asserting party, as a business identifier from a system that is not this one. Unset when the party is named by
+     * localAsserterIdentifier. Carries no asserter type.
      */
-    asserterType?: HealthElementAsserter.AsserterTypeEnum;
+    externalAsserterIdentifier?: Identifier;
 }
 export declare namespace HealthElementAsserter {
+    /**
+     * A reference to the record, stored in iCure.
+     */
+    class LocalAsserterIdentifier {
+        constructor(json: JSON | any);
+        /**
+         * 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 entity-kind axis, not the role the party played in the assertion.
+         */
+        type?: AsserterTypeEnum;
+    }
+    /**
+     * The kind of entity a LocalAsserterIdentifier id refers to.
+     *
+     * There is no entry for an organisation: organisations are stored as healthcare party records, so they use
+     * `healthcareParty` (see the note on the class).
+     */
     type AsserterTypeEnum = 'patient' | 'healthcareParty' | 'relatedPerson';
+    const AsserterTypeEnum: {
+        Patient: AsserterTypeEnum;
+        HealthcareParty: AsserterTypeEnum;
+        RelatedPerson: AsserterTypeEnum;
+    };
 }

package/icc-api/model/HealthElementAsserter.js

@@ -9,15 +9,29 @@ exports.HealthElementAsserter = void 0;
  * report a condition on behalf of the patient, and a physician may assert a diagnosis: all three 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. The type 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.
+ * 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 `AsserterTypeEnum` saying
+ *   which kind of record that id points at;
+ * - `externalAsserterIdentifier` names a party that has no record here, through a business `Identifier` issued by
+ *   another system. There is deliberately no asserter type on this branch: the kind of a record we do not store is not
+ *   knowable to us.
+ *
+ * Both fields of `LocalAsserterIdentifier` are required by the server and by the other iCure SDKs, and are declared
+ * optional here only because every model in this layer is. An asserter written with a partial local identifier cannot
+ * be read back by those SDKs.
+ *
+ * Do not rely on the server to enforce any of the above. `asserters` is encrypted by default (see
+ * `EncryptedFieldsConfig.Defaults.healthElement`), so the server usually sees only ciphertext and its own checks - the
+ * exactly-one rule, id not blank - never run. They do run for a client that overrides `encryptedFieldsConfig` for
+ * health elements without keeping `asserters` in the list, and a violation then surfaces as a `400`. The pairing inside
+ * `LocalAsserterIdentifier` is never checked anywhere: `AsserterTypeEnum` bounds the vocabulary, not what the id
+ * actually points at. All of these invariants are the caller's responsibility.
  *
  * 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 = '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 = '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.
  */
 class HealthElementAsserter {
     constructor(json) {
@@ -25,4 +39,20 @@ class HealthElementAsserter {
     }
 }
 exports.HealthElementAsserter = HealthElementAsserter;
+(function (HealthElementAsserter) {
+    /**
+     * A reference to the record, stored in iCure.
+     */
+    class LocalAsserterIdentifier {
+        constructor(json) {
+            Object.assign(this, json);
+        }
+    }
+    HealthElementAsserter.LocalAsserterIdentifier = LocalAsserterIdentifier;
+    HealthElementAsserter.AsserterTypeEnum = {
+        Patient: 'patient',
+        HealthcareParty: 'healthcareParty',
+        RelatedPerson: 'relatedPerson',
+    };
+})(HealthElementAsserter || (exports.HealthElementAsserter = HealthElementAsserter = {}));
 //# sourceMappingURL=HealthElementAsserter.js.map

package/icc-api/model/HealthElementAsserter.js.map

@@ -1 +1 @@
-{"version":3,"file":"HealthElementAsserter.js","sourceRoot":"","sources":["../../../icc-api/model/HealthElementAsserter.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAa,qBAAqB;IAChC,YAAY,IAAgB;QAC1B,MAAM,CAAC,MAAM,CAAC,IAA6B,EAAE,IAAI,CAAC,CAAA;IACpD,CAAC;CAWF;AAdD,sDAcC","sourcesContent":["/**\n * The party asserting that the patient has the healthcare element this asserter is attached to.\n *\n * This is the FHIR-style asserter concept: it does not say who recorded or authored the healthcare element, it says on\n * whose word the healthcare element is held to be true. A patient may self-report an allergy, a family member may\n * report a condition on behalf of the patient, and a physician may assert a diagnosis: all three are asserters, and the\n * same healthcare element may carry more than one of them.\n *\n * The two fields must agree: `asserterType` declares which kind of entity `asserterId` points at. The type bounds the\n * vocabulary, but nothing enforces the pairing: the field is encrypted, so the server never sees the values and cannot\n * validate or repair them.\n *\n * Note on organisations: an organisation (hospital, practice, care home, ...) is not a distinct asserter type.\n * Organisations are stored as healthcare party records, distinguished from individual practitioners by tags set by the\n * client, so an organisation asserter is an entry with `asserterType = 'healthcareParty'` whose `asserterId` points to\n * such a record. The association between a practitioner and the organisation they were acting for at the time of the\n * assertion is deliberately not modelled here.\n */\nexport class HealthElementAsserter {\n  constructor(json: JSON | any) {\n    Object.assign(this as HealthElementAsserter, json)\n  }\n\n  /**\n   * The id of the entity making the assertion. Which entity it refers to is given by asserterType.\n   */\n  asserterId?: string\n  /**\n   * The kind of entity asserterId refers to. This is the entity-kind axis, not the role the party played in the\n   * assertion.\n   */\n  asserterType?: HealthElementAsserter.AsserterTypeEnum\n}\nexport namespace HealthElementAsserter {\n  export type AsserterTypeEnum = 'patient' | 'healthcareParty' | 'relatedPerson'\n}\n"]}
+{"version":3,"file":"HealthElementAsserter.js","sourceRoot":"","sources":["../../../icc-api/model/HealthElementAsserter.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAa,qBAAqB;IAChC,YAAY,IAAgB;QAC1B,MAAM,CAAC,MAAM,CAAC,IAA6B,EAAE,IAAI,CAAC,CAAA;IACpD,CAAC;CAYF;AAfD,sDAeC;AAED,WAAiB,qBAAqB;IACpC;;OAEG;IACH,MAAa,uBAAuB;QAClC,YAAY,IAAgB;YAC1B,MAAM,CAAC,MAAM,CAAC,IAA+B,EAAE,IAAI,CAAC,CAAA;QACtD,CAAC;KAUF;IAbY,6CAAuB,0BAanC,CAAA;IASY,sCAAgB,GAAG;QAC9B,OAAO,EAAE,SAA6B;QACtC,eAAe,EAAE,iBAAqC;QACtD,aAAa,EAAE,eAAmC;KACnD,CAAA;AACH,CAAC,EA/BgB,qBAAqB,qCAArB,qBAAqB,QA+BrC","sourcesContent":["import { Identifier } from './Identifier'\n\n/**\n * The party asserting that the patient has the healthcare element this asserter is attached to.\n *\n * This is the FHIR-style asserter concept: it does not say who recorded or authored the healthcare element, it says on\n * whose word the healthcare element is held to be true. A patient may self-report an allergy, a family member may\n * report a condition on behalf of the patient, and a physician may assert a diagnosis: all three are asserters, and the\n * same healthcare element may carry more than one of them.\n *\n * The party is named in exactly one of two ways, and exactly one of the two fields must be set:\n * - `localAsserterIdentifier` names a party stored in this iCure instance: an id, plus the `AsserterTypeEnum` saying\n *   which kind of record that id points at;\n * - `externalAsserterIdentifier` names a party that has no record here, through a business `Identifier` issued by\n *   another system. There is deliberately no asserter type on this branch: the kind of a record we do not store is not\n *   knowable to us.\n *\n * Both fields of `LocalAsserterIdentifier` are required by the server and by the other iCure SDKs, and are declared\n * optional here only because every model in this layer is. An asserter written with a partial local identifier cannot\n * be read back by those SDKs.\n *\n * Do not rely on the server to enforce any of the above. `asserters` is encrypted by default (see\n * `EncryptedFieldsConfig.Defaults.healthElement`), so the server usually sees only ciphertext and its own checks - the\n * exactly-one rule, id not blank - never run. They do run for a client that overrides `encryptedFieldsConfig` for\n * health elements without keeping `asserters` in the list, and a violation then surfaces as a `400`. The pairing inside\n * `LocalAsserterIdentifier` is never checked anywhere: `AsserterTypeEnum` bounds the vocabulary, not what the id\n * actually points at. All of these invariants are the caller's responsibility.\n *\n * Note on organisations: an organisation (hospital, practice, care home, ...) is not a distinct asserter type.\n * Organisations are stored as healthcare party records, distinguished from individual practitioners by tags set by the\n * client, so an organisation asserter is a `localAsserterIdentifier` with `type = 'healthcareParty'` whose `id` points\n * to such a record. The association between a practitioner and the organisation they were acting for at the time of\n * the assertion is deliberately not modelled here.\n */\nexport class HealthElementAsserter {\n  constructor(json: JSON | any) {\n    Object.assign(this as HealthElementAsserter, json)\n  }\n\n  /**\n   * The asserting party, as a reference to a record stored in this instance. Unset when the party is named by\n   * externalAsserterIdentifier.\n   */\n  localAsserterIdentifier?: HealthElementAsserter.LocalAsserterIdentifier\n  /**\n   * The asserting party, as a business identifier from a system that is not this one. Unset when the party is named by\n   * localAsserterIdentifier. Carries no asserter type.\n   */\n  externalAsserterIdentifier?: Identifier\n}\n\nexport namespace HealthElementAsserter {\n  /**\n   * A reference to the record, stored in iCure.\n   */\n  export class LocalAsserterIdentifier {\n    constructor(json: JSON | any) {\n      Object.assign(this as LocalAsserterIdentifier, json)\n    }\n\n    /**\n     * The id of the entity making the assertion. Which entity it refers to is given by type.\n     */\n    id?: string\n    /**\n     * The kind of entity id refers to. This is the entity-kind axis, not the role the party played in the assertion.\n     */\n    type?: AsserterTypeEnum\n  }\n\n  /**\n   * The kind of entity a LocalAsserterIdentifier id refers to.\n   *\n   * There is no entry for an organisation: organisations are stored as healthcare party records, so they use\n   * `healthcareParty` (see the note on the class).\n   */\n  export type AsserterTypeEnum = 'patient' | 'healthcareParty' | 'relatedPerson'\n  export const AsserterTypeEnum = {\n    Patient: 'patient' as AsserterTypeEnum,\n    HealthcareParty: 'healthcareParty' as AsserterTypeEnum,\n    RelatedPerson: 'relatedPerson' as AsserterTypeEnum,\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@icure/api",
-  "version": "8.13.0",
+  "version": "8.13.1",
   "description": "Typescript version of iCure standalone API client",
   "main": "index.js",
   "types": "index.d.ts",