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

package/model/base/CodeFlag.mjs

@@ -0,0 +1,82 @@
+// auto-generated file
+export var CodeFlag;
+(function (CodeFlag) {
+    CodeFlag["MaleOnly"] = "MaleOnly";
+    CodeFlag["FemaleOnly"] = "FemaleOnly";
+    CodeFlag["Deptkinesitherapy"] = "Deptkinesitherapy";
+    CodeFlag["Deptnursing"] = "Deptnursing";
+    CodeFlag["Deptgeneralpractice"] = "Deptgeneralpractice";
+    CodeFlag["Deptsocialworker"] = "Deptsocialworker";
+    CodeFlag["Deptpsychology"] = "Deptpsychology";
+    CodeFlag["Deptadministrative"] = "Deptadministrative";
+    CodeFlag["Deptdietetics"] = "Deptdietetics";
+    CodeFlag["Deptspeechtherapy"] = "Deptspeechtherapy";
+    CodeFlag["Deptdentistry"] = "Deptdentistry";
+    CodeFlag["Deptoccupationaltherapy"] = "Deptoccupationaltherapy";
+    CodeFlag["Depthealthcare"] = "Depthealthcare";
+    CodeFlag["Deptgynecology"] = "Deptgynecology";
+    CodeFlag["Deptpediatry"] = "Deptpediatry";
+    CodeFlag["Deptalgology"] = "Deptalgology";
+    CodeFlag["Deptanatomopathology"] = "Deptanatomopathology";
+    CodeFlag["Deptanesthesiology"] = "Deptanesthesiology";
+    CodeFlag["Deptbacteriology"] = "Deptbacteriology";
+    CodeFlag["Deptcardiacsurgery"] = "Deptcardiacsurgery";
+    CodeFlag["Deptcardiology"] = "Deptcardiology";
+    CodeFlag["Deptchildandadolescentpsychiatry"] = "Deptchildandadolescentpsychiatry";
+    CodeFlag["Deptdermatology"] = "Deptdermatology";
+    CodeFlag["Deptdiabetology"] = "Deptdiabetology";
+    CodeFlag["Deptemergency"] = "Deptemergency";
+    CodeFlag["Deptendocrinology"] = "Deptendocrinology";
+    CodeFlag["Deptgastroenterology"] = "Deptgastroenterology";
+    CodeFlag["Deptgenetics"] = "Deptgenetics";
+    CodeFlag["Deptgeriatry"] = "Deptgeriatry";
+    CodeFlag["Depthandsurgery"] = "Depthandsurgery";
+    CodeFlag["Depthematology"] = "Depthematology";
+    CodeFlag["Deptinfectiousdisease"] = "Deptinfectiousdisease";
+    CodeFlag["Deptintensivecare"] = "Deptintensivecare";
+    CodeFlag["Deptlaboratory"] = "Deptlaboratory";
+    CodeFlag["Deptmajorburns"] = "Deptmajorburns";
+    CodeFlag["Deptmaxillofacialsurgery"] = "Deptmaxillofacialsurgery";
+    CodeFlag["Deptmedicine"] = "Deptmedicine";
+    CodeFlag["Deptmolecularbiology"] = "Deptmolecularbiology";
+    CodeFlag["Deptneonatalogy"] = "Deptneonatalogy";
+    CodeFlag["Deptnephrology"] = "Deptnephrology";
+    CodeFlag["Deptneurology"] = "Deptneurology";
+    CodeFlag["Deptneurosurgery"] = "Deptneurosurgery";
+    CodeFlag["Deptnte"] = "Deptnte";
+    CodeFlag["Deptnuclear"] = "Deptnuclear";
+    CodeFlag["Deptnutritiondietetics"] = "Deptnutritiondietetics";
+    CodeFlag["Deptobstetrics"] = "Deptobstetrics";
+    CodeFlag["Deptoncology"] = "Deptoncology";
+    CodeFlag["Deptophtalmology"] = "Deptophtalmology";
+    CodeFlag["Deptorthopedy"] = "Deptorthopedy";
+    CodeFlag["Deptpalliativecare"] = "Deptpalliativecare";
+    CodeFlag["Deptpediatricintensivecare"] = "Deptpediatricintensivecare";
+    CodeFlag["Deptpediatricsurgery"] = "Deptpediatricsurgery";
+    CodeFlag["Deptpharmacy"] = "Deptpharmacy";
+    CodeFlag["Deptphysicalmedecine"] = "Deptphysicalmedecine";
+    CodeFlag["Deptphysiotherapy"] = "Deptphysiotherapy";
+    CodeFlag["Deptplasticandreparatorysurgery"] = "Deptplasticandreparatorysurgery";
+    CodeFlag["Deptpneumology"] = "Deptpneumology";
+    CodeFlag["Deptpodiatry"] = "Deptpodiatry";
+    CodeFlag["Deptpsychiatry"] = "Deptpsychiatry";
+    CodeFlag["Deptradiology"] = "Deptradiology";
+    CodeFlag["Deptradiotherapy"] = "Deptradiotherapy";
+    CodeFlag["Deptrevalidation"] = "Deptrevalidation";
+    CodeFlag["Deptrheumatology"] = "Deptrheumatology";
+    CodeFlag["Deptrhumatology"] = "Deptrhumatology";
+    CodeFlag["Deptsenology"] = "Deptsenology";
+    CodeFlag["Deptsocialservice"] = "Deptsocialservice";
+    CodeFlag["Deptsportsmedecine"] = "Deptsportsmedecine";
+    CodeFlag["Deptstomatology"] = "Deptstomatology";
+    CodeFlag["Deptsurgery"] = "Deptsurgery";
+    CodeFlag["Deptthoracicsurgery"] = "Deptthoracicsurgery";
+    CodeFlag["Depttoxicology"] = "Depttoxicology";
+    CodeFlag["Depttropicalmedecine"] = "Depttropicalmedecine";
+    CodeFlag["Depturology"] = "Depturology";
+    CodeFlag["Deptvascularsurgery"] = "Deptvascularsurgery";
+    CodeFlag["Deptvisceraldigestiveabdominalsurgery"] = "Deptvisceraldigestiveabdominalsurgery";
+    CodeFlag["Depttransplantsurgery"] = "Depttransplantsurgery";
+    CodeFlag["Deptpercutaneous"] = "Deptpercutaneous";
+    CodeFlag["Deptchildbirth"] = "Deptchildbirth";
+})(CodeFlag || (CodeFlag = {}));

package/model/base/ReportVersion.d.mts

@@ -0,0 +1,3 @@
+export declare enum ReportVersion {
+    V1_0_0 = "V1_0_0"
+}

package/model/base/ReportVersion.mjs

@@ -0,0 +1,5 @@
+// auto-generated file
+export var ReportVersion;
+(function (ReportVersion) {
+    ReportVersion["V1_0_0"] = "V1_0_0";
+})(ReportVersion || (ReportVersion = {}));

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/model/embed/KeywordSubword.d.mts

@@ -0,0 +1,8 @@
+import { KeywordSubword as KeywordSubword_ } from './KeywordSubword.mjs';
+export declare class KeywordSubword {
+    value: string | undefined;
+    subWords: Array<KeywordSubword_> | undefined;
+    constructor(partial: Partial<KeywordSubword>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): KeywordSubword;
+}

package/model/embed/KeywordSubword.mjs

@@ -0,0 +1,35 @@
+// auto-generated file
+import { expectArray, expectObject, expectString, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
+export class KeywordSubword {
+    constructor(partial) {
+        this.value = undefined;
+        this.subWords = undefined;
+        if ('value' in partial)
+            this.value = partial.value;
+        if ('subWords' in partial)
+            this.subWords = partial.subWords;
+    }
+    toJSON() {
+        const res = {};
+        if (this.value != undefined)
+            res['value'] = this.value;
+        if (this.subWords != undefined)
+            res['subWords'] = this.subWords.map((x0) => x0.toJSON());
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['KeywordSubword']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new KeywordSubword({
+            value: expectString(extractEntry(jCpy, 'value', false, path), true, [...path, ".value"]),
+            subWords: expectArray(extractEntry(jCpy, 'subWords', false, path), true, [...path, ".subWords"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, KeywordSubword.fromJSON)),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object KeywordSubword at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
+}

package/model/embed/LetterValue.d.mts

@@ -0,0 +1,9 @@
+export declare class LetterValue {
+    letter: string | undefined;
+    index: string | undefined;
+    coefficient: number | undefined;
+    value: number | undefined;
+    constructor(partial: Partial<LetterValue>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): LetterValue;
+}

package/model/embed/LetterValue.mjs

@@ -0,0 +1,47 @@
+// auto-generated file
+import { expectNumber, expectString, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
+export class LetterValue {
+    constructor(partial) {
+        this.letter = undefined;
+        this.index = undefined;
+        this.coefficient = undefined;
+        this.value = undefined;
+        if ('letter' in partial)
+            this.letter = partial.letter;
+        if ('index' in partial)
+            this.index = partial.index;
+        if ('coefficient' in partial)
+            this.coefficient = partial.coefficient;
+        if ('value' in partial)
+            this.value = partial.value;
+    }
+    toJSON() {
+        const res = {};
+        if (this.letter != undefined)
+            res['letter'] = this.letter;
+        if (this.index != undefined)
+            res['index'] = this.index;
+        if (this.coefficient != undefined)
+            res['coefficient'] = this.coefficient;
+        if (this.value != undefined)
+            res['value'] = this.value;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['LetterValue']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new LetterValue({
+            letter: expectString(extractEntry(jCpy, 'letter', false, path), true, [...path, ".letter"]),
+            index: expectString(extractEntry(jCpy, 'index', false, path), true, [...path, ".index"]),
+            coefficient: expectNumber(extractEntry(jCpy, 'coefficient', false, path), true, false, [...path, ".coefficient"]),
+            value: expectNumber(extractEntry(jCpy, 'value', false, path), true, false, [...path, ".value"]),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object LetterValue at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
+}

package/model/embed/Periodicity.d.mts

@@ -0,0 +1,8 @@
+import { CodeStub } from '../base/CodeStub.mjs';
+export declare class Periodicity {
+    relatedCode: CodeStub | undefined;
+    relatedPeriodicity: CodeStub | undefined;
+    constructor(partial: Partial<Periodicity>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): Periodicity;
+}

package/model/embed/Periodicity.mjs

@@ -0,0 +1,36 @@
+// auto-generated file
+import { expectObject, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
+import { CodeStub } from '../base/CodeStub.mjs';
+export class Periodicity {
+    constructor(partial) {
+        this.relatedCode = undefined;
+        this.relatedPeriodicity = undefined;
+        if ('relatedCode' in partial)
+            this.relatedCode = partial.relatedCode;
+        if ('relatedPeriodicity' in partial)
+            this.relatedPeriodicity = partial.relatedPeriodicity;
+    }
+    toJSON() {
+        const res = {};
+        if (this.relatedCode != undefined)
+            res['relatedCode'] = this.relatedCode.toJSON();
+        if (this.relatedPeriodicity != undefined)
+            res['relatedPeriodicity'] = this.relatedPeriodicity.toJSON();
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['Periodicity']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new Periodicity({
+            relatedCode: expectObject(extractEntry(jCpy, 'relatedCode', false, path), true, ignoreUnknownKeys, [...path, ".relatedCode"], CodeStub.fromJSON),
+            relatedPeriodicity: expectObject(extractEntry(jCpy, 'relatedPeriodicity', false, path), true, ignoreUnknownKeys, [...path, ".relatedPeriodicity"], CodeStub.fromJSON),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object Periodicity at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
+}

package/model/embed/TimeTableHour.d.mts

@@ -0,0 +1,7 @@
+export declare class TimeTableHour {
+    startHour: number | undefined;
+    endHour: number | undefined;
+    constructor(partial: Partial<TimeTableHour>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): TimeTableHour;
+}

package/model/embed/TimeTableHour.mjs

@@ -0,0 +1,35 @@
+// auto-generated file
+import { expectNumber, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
+export class TimeTableHour {
+    constructor(partial) {
+        this.startHour = undefined;
+        this.endHour = undefined;
+        if ('startHour' in partial)
+            this.startHour = partial.startHour;
+        if ('endHour' in partial)
+            this.endHour = partial.endHour;
+    }
+    toJSON() {
+        const res = {};
+        if (this.startHour != undefined)
+            res['startHour'] = this.startHour;
+        if (this.endHour != undefined)
+            res['endHour'] = this.endHour;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['TimeTableHour']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new TimeTableHour({
+            startHour: expectNumber(extractEntry(jCpy, 'startHour', false, path), true, true, [...path, ".startHour"]),
+            endHour: expectNumber(extractEntry(jCpy, 'endHour', false, path), true, true, [...path, ".endHour"]),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object TimeTableHour at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
+}

package/model/embed/TimeTableItem.d.mts

@@ -0,0 +1,19 @@
+import { TimeTableHour } from './TimeTableHour.mjs';
+export declare class TimeTableItem {
+    rruleStartDate: number | undefined;
+    rrule: string | undefined;
+    notBeforeInMinutes: number | undefined;
+    notAfterInMinutes: number | undefined;
+    zoneId: string | undefined;
+    hours: Array<TimeTableHour>;
+    calendarItemTypeId: string | undefined;
+    homeVisit: boolean;
+    placeId: string | undefined;
+    publicTimeTableItem: boolean;
+    acceptsNewPatient: boolean;
+    unavailable: boolean;
+    reservingRights: Array<string>;
+    constructor(partial: Partial<TimeTableItem>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): TimeTableItem;
+}

package/model/embed/TimeTableItem.mjs

@@ -0,0 +1,96 @@
+// auto-generated file
+import { expectArray, expectBoolean, expectNumber, expectObject, expectString, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
+import { TimeTableHour } from './TimeTableHour.mjs';
+export class TimeTableItem {
+    constructor(partial) {
+        this.rruleStartDate = undefined;
+        this.rrule = undefined;
+        this.notBeforeInMinutes = undefined;
+        this.notAfterInMinutes = undefined;
+        this.zoneId = undefined;
+        this.hours = [];
+        this.calendarItemTypeId = undefined;
+        this.homeVisit = false;
+        this.placeId = undefined;
+        this.publicTimeTableItem = false;
+        this.acceptsNewPatient = true;
+        this.unavailable = false;
+        this.reservingRights = [];
+        if ('rruleStartDate' in partial)
+            this.rruleStartDate = partial.rruleStartDate;
+        if ('rrule' in partial)
+            this.rrule = partial.rrule;
+        if ('notBeforeInMinutes' in partial)
+            this.notBeforeInMinutes = partial.notBeforeInMinutes;
+        if ('notAfterInMinutes' in partial)
+            this.notAfterInMinutes = partial.notAfterInMinutes;
+        if ('zoneId' in partial)
+            this.zoneId = partial.zoneId;
+        if ('hours' in partial && partial.hours !== undefined)
+            this.hours = partial.hours;
+        if ('calendarItemTypeId' in partial)
+            this.calendarItemTypeId = partial.calendarItemTypeId;
+        if ('homeVisit' in partial && partial.homeVisit !== undefined)
+            this.homeVisit = partial.homeVisit;
+        if ('placeId' in partial)
+            this.placeId = partial.placeId;
+        if ('publicTimeTableItem' in partial && partial.publicTimeTableItem !== undefined)
+            this.publicTimeTableItem = partial.publicTimeTableItem;
+        if ('acceptsNewPatient' in partial && partial.acceptsNewPatient !== undefined)
+            this.acceptsNewPatient = partial.acceptsNewPatient;
+        if ('unavailable' in partial && partial.unavailable !== undefined)
+            this.unavailable = partial.unavailable;
+        if ('reservingRights' in partial && partial.reservingRights !== undefined)
+            this.reservingRights = partial.reservingRights;
+    }
+    toJSON() {
+        const res = {};
+        if (this.rruleStartDate != undefined)
+            res['rruleStartDate'] = this.rruleStartDate;
+        if (this.rrule != undefined)
+            res['rrule'] = this.rrule;
+        if (this.notBeforeInMinutes != undefined)
+            res['notBeforeInMinutes'] = this.notBeforeInMinutes;
+        if (this.notAfterInMinutes != undefined)
+            res['notAfterInMinutes'] = this.notAfterInMinutes;
+        if (this.zoneId != undefined)
+            res['zoneId'] = this.zoneId;
+        res['hours'] = this.hours.map((x0) => x0.toJSON());
+        if (this.calendarItemTypeId != undefined)
+            res['calendarItemTypeId'] = this.calendarItemTypeId;
+        res['homeVisit'] = this.homeVisit;
+        if (this.placeId != undefined)
+            res['placeId'] = this.placeId;
+        res['publicTimeTableItem'] = this.publicTimeTableItem;
+        res['acceptsNewPatient'] = this.acceptsNewPatient;
+        res['unavailable'] = this.unavailable;
+        res['reservingRights'] = this.reservingRights.map((x0) => x0);
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['TimeTableItem']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new TimeTableItem({
+            rruleStartDate: expectNumber(extractEntry(jCpy, 'rruleStartDate', false, path), true, true, [...path, ".rruleStartDate"]),
+            rrule: expectString(extractEntry(jCpy, 'rrule', false, path), true, [...path, ".rrule"]),
+            notBeforeInMinutes: expectNumber(extractEntry(jCpy, 'notBeforeInMinutes', false, path), true, true, [...path, ".notBeforeInMinutes"]),
+            notAfterInMinutes: expectNumber(extractEntry(jCpy, 'notAfterInMinutes', false, path), true, true, [...path, ".notAfterInMinutes"]),
+            zoneId: expectString(extractEntry(jCpy, 'zoneId', false, path), true, [...path, ".zoneId"]),
+            hours: expectArray(extractEntry(jCpy, 'hours', false, path), false, [...path, ".hours"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, TimeTableHour.fromJSON)),
+            calendarItemTypeId: expectString(extractEntry(jCpy, 'calendarItemTypeId', false, path), true, [...path, ".calendarItemTypeId"]),
+            homeVisit: expectBoolean(extractEntry(jCpy, 'homeVisit', false, path), false, [...path, ".homeVisit"]),
+            placeId: expectString(extractEntry(jCpy, 'placeId', false, path), true, [...path, ".placeId"]),
+            publicTimeTableItem: expectBoolean(extractEntry(jCpy, 'publicTimeTableItem', false, path), false, [...path, ".publicTimeTableItem"]),
+            acceptsNewPatient: expectBoolean(extractEntry(jCpy, 'acceptsNewPatient', false, path), false, [...path, ".acceptsNewPatient"]),
+            unavailable: expectBoolean(extractEntry(jCpy, 'unavailable', false, path), false, [...path, ".unavailable"]),
+            reservingRights: expectArray(extractEntry(jCpy, 'reservingRights', false, path), false, [...path, ".reservingRights"], (x0, p0) => expectString(x0, false, p0)),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object TimeTableItem at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
+}

package/model/embed/Valorisation.d.mts

@@ -0,0 +1,56 @@
+import { Base64String } from '../specializations/Base64String.mjs';
+import { Encryptable } from './Encryptable.mjs';
+export interface Valorisation extends Encryptable {
+    startOfValidity: number | undefined;
+    endOfValidity: number | undefined;
+    predicate: string | undefined;
+    reference: Array<number> | undefined;
+    totalAmount: number | undefined;
+    reimbursement: number | undefined;
+    patientIntervention: number | undefined;
+    doctorSupplement: number | undefined;
+    vat: number | undefined;
+    label: {
+        [key: string]: string;
+    } | undefined;
+    readonly isEncrypted: boolean;
+    toJSON(): object;
+}
+export declare class DecryptedValorisation {
+    startOfValidity: number | undefined;
+    endOfValidity: number | undefined;
+    predicate: string | undefined;
+    reference: Array<number> | undefined;
+    totalAmount: number | undefined;
+    reimbursement: number | undefined;
+    patientIntervention: number | undefined;
+    doctorSupplement: number | undefined;
+    vat: number | undefined;
+    label: {
+        [key: string]: string;
+    } | undefined;
+    encryptedSelf: Base64String | undefined;
+    readonly isEncrypted: false;
+    constructor(partial: Partial<DecryptedValorisation>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): DecryptedValorisation;
+}
+export declare class EncryptedValorisation {
+    startOfValidity: number | undefined;
+    endOfValidity: number | undefined;
+    predicate: string | undefined;
+    reference: Array<number> | undefined;
+    totalAmount: number | undefined;
+    reimbursement: number | undefined;
+    patientIntervention: number | undefined;
+    doctorSupplement: number | undefined;
+    vat: number | undefined;
+    label: {
+        [key: string]: string;
+    } | undefined;
+    encryptedSelf: Base64String | undefined;
+    readonly isEncrypted: true;
+    constructor(partial: Partial<EncryptedValorisation>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): EncryptedValorisation;
+}