@icure/cardinal-sdk 2.0.0-PREVIEW-18.1 → 2.0.0-PREVIEW-21

package/model/embed/ParagraphAgreement.mjs

@@ -1,3 +1,6 @@
+// auto-generated file
+import { expectArray, expectBoolean, expectMap, expectNumber, expectObject, expectString, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
+import { AgreementAppendix } from './AgreementAppendix.mjs';
 export class ParagraphAgreement {
     constructor(partial) {
         this.timestamp = undefined;
@@ -67,4 +70,87 @@ export class ParagraphAgreement {
         if ('documentId' in partial)
             this.documentId = partial.documentId;
     }
+    toJSON() {
+        const res = {};
+        if (this.timestamp != undefined)
+            res['timestamp'] = this.timestamp;
+        if (this.paragraph != undefined)
+            res['paragraph'] = this.paragraph;
+        if (this.accepted != undefined)
+            res['accepted'] = this.accepted;
+        if (this.inTreatment != undefined)
+            res['inTreatment'] = this.inTreatment;
+        if (this.canceled != undefined)
+            res['canceled'] = this.canceled;
+        if (this.careProviderReference != undefined)
+            res['careProviderReference'] = this.careProviderReference;
+        if (this.decisionReference != undefined)
+            res['decisionReference'] = this.decisionReference;
+        if (this.start != undefined)
+            res['start'] = this.start;
+        if (this.end != undefined)
+            res['end'] = this.end;
+        if (this.cancelationDate != undefined)
+            res['cancelationDate'] = this.cancelationDate;
+        if (this.quantityValue != undefined)
+            res['quantityValue'] = this.quantityValue;
+        if (this.quantityUnit != undefined)
+            res['quantityUnit'] = this.quantityUnit;
+        if (this.ioRequestReference != undefined)
+            res['ioRequestReference'] = this.ioRequestReference;
+        if (this.responseType != undefined)
+            res['responseType'] = this.responseType;
+        if (this.refusalJustification != undefined)
+            res['refusalJustification'] = Object.fromEntries(Object.entries(this.refusalJustification).map(([k0, v0]) => [k0, v0]));
+        if (this.verses != undefined)
+            res['verses'] = this.verses.map((x0) => x0);
+        if (this.coverageType != undefined)
+            res['coverageType'] = this.coverageType;
+        if (this.unitNumber != undefined)
+            res['unitNumber'] = this.unitNumber;
+        if (this.strength != undefined)
+            res['strength'] = this.strength;
+        if (this.strengthUnit != undefined)
+            res['strengthUnit'] = this.strengthUnit;
+        if (this.agreementAppendices != undefined)
+            res['agreementAppendices'] = this.agreementAppendices.map((x0) => x0.toJSON());
+        if (this.documentId != undefined)
+            res['documentId'] = this.documentId;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['ParagraphAgreement']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new ParagraphAgreement({
+            timestamp: expectNumber(extractEntry(jCpy, 'timestamp', false, path), true, true, [...path, ".timestamp"]),
+            paragraph: expectString(extractEntry(jCpy, 'paragraph', false, path), true, [...path, ".paragraph"]),
+            accepted: expectBoolean(extractEntry(jCpy, 'accepted', false, path), true, [...path, ".accepted"]),
+            inTreatment: expectBoolean(extractEntry(jCpy, 'inTreatment', false, path), true, [...path, ".inTreatment"]),
+            canceled: expectBoolean(extractEntry(jCpy, 'canceled', false, path), true, [...path, ".canceled"]),
+            careProviderReference: expectString(extractEntry(jCpy, 'careProviderReference', false, path), true, [...path, ".careProviderReference"]),
+            decisionReference: expectString(extractEntry(jCpy, 'decisionReference', false, path), true, [...path, ".decisionReference"]),
+            start: expectNumber(extractEntry(jCpy, 'start', false, path), true, true, [...path, ".start"]),
+            end: expectNumber(extractEntry(jCpy, 'end', false, path), true, true, [...path, ".end"]),
+            cancelationDate: expectNumber(extractEntry(jCpy, 'cancelationDate', false, path), true, true, [...path, ".cancelationDate"]),
+            quantityValue: expectNumber(extractEntry(jCpy, 'quantityValue', false, path), true, false, [...path, ".quantityValue"]),
+            quantityUnit: expectString(extractEntry(jCpy, 'quantityUnit', false, path), true, [...path, ".quantityUnit"]),
+            ioRequestReference: expectString(extractEntry(jCpy, 'ioRequestReference', false, path), true, [...path, ".ioRequestReference"]),
+            responseType: expectString(extractEntry(jCpy, 'responseType', false, path), true, [...path, ".responseType"]),
+            refusalJustification: expectMap(extractEntry(jCpy, 'refusalJustification', false, path), true, [...path, ".refusalJustification"], (k0, p0) => expectString(k0, false, p0), (v0, p0) => expectString(v0, false, p0)),
+            verses: expectArray(extractEntry(jCpy, 'verses', false, path), true, [...path, ".verses"], (x0, p0) => expectNumber(x0, false, true, p0)),
+            coverageType: expectString(extractEntry(jCpy, 'coverageType', false, path), true, [...path, ".coverageType"]),
+            unitNumber: expectNumber(extractEntry(jCpy, 'unitNumber', false, path), true, false, [...path, ".unitNumber"]),
+            strength: expectNumber(extractEntry(jCpy, 'strength', false, path), true, false, [...path, ".strength"]),
+            strengthUnit: expectString(extractEntry(jCpy, 'strengthUnit', false, path), true, [...path, ".strengthUnit"]),
+            agreementAppendices: expectArray(extractEntry(jCpy, 'agreementAppendices', false, path), true, [...path, ".agreementAppendices"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, AgreementAppendix.fromJSON)),
+            documentId: expectString(extractEntry(jCpy, 'documentId', false, path), true, [...path, ".documentId"]),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object ParagraphAgreement at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/embed/Partnership.d.mts

@@ -7,4 +7,6 @@ export declare class Partnership {
     meToOtherRelationshipDescription: string | undefined;
     otherToMeRelationshipDescription: string | undefined;
     constructor(partial: Partial<Partnership>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): Partnership;
 }

package/model/embed/Partnership.mjs

@@ -1,3 +1,7 @@
+// auto-generated file
+import { expectString, expectStringEnum, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
+import { PartnershipStatus } from './PartnershipStatus.mjs';
+import { PartnershipType } from './PartnershipType.mjs';
 export class Partnership {
     constructor(partial) {
         this.type = undefined;
@@ -16,4 +20,36 @@ export class Partnership {
         if ('otherToMeRelationshipDescription' in partial)
             this.otherToMeRelationshipDescription = partial.otherToMeRelationshipDescription;
     }
+    toJSON() {
+        const res = {};
+        if (this.type != undefined)
+            res['type'] = this.type;
+        if (this.status != undefined)
+            res['status'] = this.status;
+        if (this.partnerId != undefined)
+            res['partnerId'] = this.partnerId;
+        if (this.meToOtherRelationshipDescription != undefined)
+            res['meToOtherRelationshipDescription'] = this.meToOtherRelationshipDescription;
+        if (this.otherToMeRelationshipDescription != undefined)
+            res['otherToMeRelationshipDescription'] = this.otherToMeRelationshipDescription;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['Partnership']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new Partnership({
+            type: expectStringEnum(extractEntry(jCpy, 'type', false, path), true, [...path, ".type"], PartnershipType, 'PartnershipType'),
+            status: expectStringEnum(extractEntry(jCpy, 'status', false, path), true, [...path, ".status"], PartnershipStatus, 'PartnershipStatus'),
+            partnerId: expectString(extractEntry(jCpy, 'partnerId', false, path), true, [...path, ".partnerId"]),
+            meToOtherRelationshipDescription: expectString(extractEntry(jCpy, 'meToOtherRelationshipDescription', false, path), true, [...path, ".meToOtherRelationshipDescription"]),
+            otherToMeRelationshipDescription: expectString(extractEntry(jCpy, 'otherToMeRelationshipDescription', false, path), true, [...path, ".otherToMeRelationshipDescription"]),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object Partnership at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/embed/PatientHealthCareParty.d.mts

@@ -1,3 +1,4 @@
+import { DecryptedPropertyStub, EncryptedPropertyStub, PropertyStub } from '../PropertyStub.mjs';
 import { Base64String } from '../specializations/Base64String.mjs';
 import { Encryptable } from './Encryptable.mjs';
 import { PatientHealthCarePartyType } from './PatientHealthCarePartyType.mjs';
@@ -11,7 +12,9 @@ export interface PatientHealthCareParty extends Encryptable {
     };
     referralPeriods: Array<ReferralPeriod>;
     referral: boolean;
+    properties: Array<PropertyStub> | undefined;
     readonly isEncrypted: boolean;
+    toJSON(): object;
 }
 export declare class DecryptedPatientHealthCareParty {
     type: PatientHealthCarePartyType | undefined;
@@ -21,9 +24,12 @@ export declare class DecryptedPatientHealthCareParty {
     };
     referralPeriods: Array<ReferralPeriod>;
     referral: boolean;
+    properties: Array<DecryptedPropertyStub> | undefined;
     encryptedSelf: Base64String | undefined;
     readonly isEncrypted: false;
     constructor(partial: Partial<DecryptedPatientHealthCareParty>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): DecryptedPatientHealthCareParty;
 }
 export declare class EncryptedPatientHealthCareParty {
     type: PatientHealthCarePartyType | undefined;
@@ -33,7 +39,10 @@ export declare class EncryptedPatientHealthCareParty {
     };
     referralPeriods: Array<ReferralPeriod>;
     referral: boolean;
+    properties: Array<EncryptedPropertyStub> | undefined;
     encryptedSelf: Base64String | undefined;
     readonly isEncrypted: true;
     constructor(partial: Partial<EncryptedPatientHealthCareParty>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): EncryptedPatientHealthCareParty;
 }

package/model/embed/PatientHealthCareParty.mjs

@@ -1,3 +1,9 @@
+// auto-generated file
+import { expectArray, expectBoolean, expectMap, expectObject, expectString, expectStringEnum, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
+import { DecryptedPropertyStub, EncryptedPropertyStub } from '../PropertyStub.mjs';
+import { PatientHealthCarePartyType } from './PatientHealthCarePartyType.mjs';
+import { ReferralPeriod } from './ReferralPeriod.mjs';
+import { TelecomType } from './TelecomType.mjs';
 export class DecryptedPatientHealthCareParty {
     constructor(partial) {
         this.type = undefined;
@@ -5,6 +11,7 @@ export class DecryptedPatientHealthCareParty {
         this.sendFormats = {};
         this.referralPeriods = [];
         this.referral = false;
+        this.properties = undefined;
         this.encryptedSelf = undefined;
         this.isEncrypted = false;
         if (partial.isEncrypted !== undefined && partial.isEncrypted !== false)
@@ -19,9 +26,49 @@ export class DecryptedPatientHealthCareParty {
             this.referralPeriods = partial.referralPeriods;
         if ('referral' in partial && partial.referral !== undefined)
             this.referral = partial.referral;
+        if ('properties' in partial)
+            this.properties = partial.properties;
         if ('encryptedSelf' in partial)
             this.encryptedSelf = partial.encryptedSelf;
     }
+    toJSON() {
+        const res = {};
+        if (this.type != undefined)
+            res['type'] = this.type;
+        if (this.healthcarePartyId != undefined)
+            res['healthcarePartyId'] = this.healthcarePartyId;
+        res['sendFormats'] = Object.fromEntries(Object.entries(this.sendFormats).map(([k0, v0]) => [k0, v0]));
+        res['referralPeriods'] = this.referralPeriods.map((x0) => x0.toJSON());
+        res['referral'] = this.referral;
+        if (this.properties != undefined)
+            res['properties'] = this.properties.map((x0) => x0.toJSON());
+        if (this.encryptedSelf != undefined)
+            res['encryptedSelf'] = this.encryptedSelf;
+        res['isEncrypted'] = false;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['DecryptedPatientHealthCareParty']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        if (extractEntry(jCpy, "isEncrypted", true, path) !== false)
+            throw new Error(`Unexpected value for ${path.join("")} isEncrypted marker, should be false. The provided json doesn't represent a DecryptedPatientHealthCareParty`);
+        const res = new DecryptedPatientHealthCareParty({
+            type: expectStringEnum(extractEntry(jCpy, 'type', false, path), true, [...path, ".type"], PatientHealthCarePartyType, 'PatientHealthCarePartyType'),
+            healthcarePartyId: expectString(extractEntry(jCpy, 'healthcarePartyId', false, path), true, [...path, ".healthcarePartyId"]),
+            sendFormats: expectMap(extractEntry(jCpy, 'sendFormats', false, path), false, [...path, ".sendFormats"], (k0, p0) => expectStringEnum(k0, false, p0, TelecomType, 'TelecomType'), (v0, p0) => expectString(v0, false, p0)),
+            referralPeriods: expectArray(extractEntry(jCpy, 'referralPeriods', false, path), false, [...path, ".referralPeriods"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, ReferralPeriod.fromJSON)),
+            referral: expectBoolean(extractEntry(jCpy, 'referral', false, path), false, [...path, ".referral"]),
+            properties: expectArray(extractEntry(jCpy, 'properties', false, path), true, [...path, ".properties"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, DecryptedPropertyStub.fromJSON)),
+            encryptedSelf: expectString(extractEntry(jCpy, 'encryptedSelf', false, path), true, [...path, ".encryptedSelf"]),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object DecryptedPatientHealthCareParty at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }
 export class EncryptedPatientHealthCareParty {
     constructor(partial) {
@@ -30,6 +77,7 @@ export class EncryptedPatientHealthCareParty {
         this.sendFormats = {};
         this.referralPeriods = [];
         this.referral = false;
+        this.properties = undefined;
         this.encryptedSelf = undefined;
         this.isEncrypted = true;
         if (partial.isEncrypted !== undefined && partial.isEncrypted !== true)
@@ -44,7 +92,47 @@ export class EncryptedPatientHealthCareParty {
             this.referralPeriods = partial.referralPeriods;
         if ('referral' in partial && partial.referral !== undefined)
             this.referral = partial.referral;
+        if ('properties' in partial)
+            this.properties = partial.properties;
         if ('encryptedSelf' in partial)
             this.encryptedSelf = partial.encryptedSelf;
     }
+    toJSON() {
+        const res = {};
+        if (this.type != undefined)
+            res['type'] = this.type;
+        if (this.healthcarePartyId != undefined)
+            res['healthcarePartyId'] = this.healthcarePartyId;
+        res['sendFormats'] = Object.fromEntries(Object.entries(this.sendFormats).map(([k0, v0]) => [k0, v0]));
+        res['referralPeriods'] = this.referralPeriods.map((x0) => x0.toJSON());
+        res['referral'] = this.referral;
+        if (this.properties != undefined)
+            res['properties'] = this.properties.map((x0) => x0.toJSON());
+        if (this.encryptedSelf != undefined)
+            res['encryptedSelf'] = this.encryptedSelf;
+        res['isEncrypted'] = true;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['EncryptedPatientHealthCareParty']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        if (extractEntry(jCpy, "isEncrypted", true, path) !== true)
+            throw new Error(`Unexpected value for ${path.join("")} isEncrypted marker, should be true. The provided json doesn't represent a EncryptedPatientHealthCareParty`);
+        const res = new EncryptedPatientHealthCareParty({
+            type: expectStringEnum(extractEntry(jCpy, 'type', false, path), true, [...path, ".type"], PatientHealthCarePartyType, 'PatientHealthCarePartyType'),
+            healthcarePartyId: expectString(extractEntry(jCpy, 'healthcarePartyId', false, path), true, [...path, ".healthcarePartyId"]),
+            sendFormats: expectMap(extractEntry(jCpy, 'sendFormats', false, path), false, [...path, ".sendFormats"], (k0, p0) => expectStringEnum(k0, false, p0, TelecomType, 'TelecomType'), (v0, p0) => expectString(v0, false, p0)),
+            referralPeriods: expectArray(extractEntry(jCpy, 'referralPeriods', false, path), false, [...path, ".referralPeriods"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, ReferralPeriod.fromJSON)),
+            referral: expectBoolean(extractEntry(jCpy, 'referral', false, path), false, [...path, ".referral"]),
+            properties: expectArray(extractEntry(jCpy, 'properties', false, path), true, [...path, ".properties"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, EncryptedPropertyStub.fromJSON)),
+            encryptedSelf: expectString(extractEntry(jCpy, 'encryptedSelf', false, path), true, [...path, ".encryptedSelf"]),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object EncryptedPatientHealthCareParty at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/embed/Payment.d.mts

@@ -4,4 +4,6 @@ export declare class Payment {
     paymentType: PaymentType | undefined;
     paid: number | undefined;
     constructor(partial: Partial<Payment>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): Payment;
 }

package/model/embed/Payment.mjs

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

package/model/embed/Periodicity.d.mts

@@ -3,4 +3,6 @@ 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

@@ -1,3 +1,6 @@
+// auto-generated file
+import { expectObject, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
+import { CodeStub } from '../base/CodeStub.mjs';
 export class Periodicity {
     constructor(partial) {
         this.relatedCode = undefined;
@@ -7,4 +10,27 @@ export class Periodicity {
         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/PersonName.d.mts

@@ -9,4 +9,6 @@ export declare class PersonName {
     text: string | undefined;
     use: PersonNameUse | undefined;
     constructor(partial: Partial<PersonName>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): PersonName;
 }

package/model/embed/PersonName.mjs

@@ -1,3 +1,6 @@
+// auto-generated file
+import { expectArray, expectNumber, expectString, expectStringEnum, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
+import { PersonNameUse } from './PersonNameUse.mjs';
 export class PersonName {
     constructor(partial) {
         this.lastName = undefined;
@@ -25,4 +28,42 @@ export class PersonName {
         if ('use' in partial)
             this.use = partial.use;
     }
+    toJSON() {
+        const res = {};
+        if (this.lastName != undefined)
+            res['lastName'] = this.lastName;
+        res['firstNames'] = this.firstNames.map((x0) => x0);
+        if (this.start != undefined)
+            res['start'] = this.start;
+        if (this.end != undefined)
+            res['end'] = this.end;
+        res['prefix'] = this.prefix.map((x0) => x0);
+        res['suffix'] = this.suffix.map((x0) => x0);
+        if (this.text != undefined)
+            res['text'] = this.text;
+        if (this.use != undefined)
+            res['use'] = this.use;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['PersonName']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new PersonName({
+            lastName: expectString(extractEntry(jCpy, 'lastName', false, path), true, [...path, ".lastName"]),
+            firstNames: expectArray(extractEntry(jCpy, 'firstNames', false, path), false, [...path, ".firstNames"], (x0, p0) => expectString(x0, false, p0)),
+            start: expectNumber(extractEntry(jCpy, 'start', false, path), true, true, [...path, ".start"]),
+            end: expectNumber(extractEntry(jCpy, 'end', false, path), true, true, [...path, ".end"]),
+            prefix: expectArray(extractEntry(jCpy, 'prefix', false, path), false, [...path, ".prefix"], (x0, p0) => expectString(x0, false, p0)),
+            suffix: expectArray(extractEntry(jCpy, 'suffix', false, path), false, [...path, ".suffix"], (x0, p0) => expectString(x0, false, p0)),
+            text: expectString(extractEntry(jCpy, 'text', false, path), true, [...path, ".text"]),
+            use: expectStringEnum(extractEntry(jCpy, 'use', false, path), true, [...path, ".use"], PersonNameUse, 'PersonNameUse'),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object PersonName at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/embed/PlanOfAction.d.mts

@@ -17,9 +17,10 @@ export interface PlanOfAction extends Encryptable, ICureDocument<string>, Named
     status: number;
     documentIds: Array<string>;
     numberOfCares: number | undefined;
-    careTeamMemberships: Array<CareTeamMembership | undefined>;
+    careTeamMemberships: Array<CareTeamMembership>;
     relevant: boolean;
     readonly isEncrypted: boolean;
+    toJSON(): object;
 }
 export declare class DecryptedPlanOfAction {
     id: string;
@@ -44,11 +45,13 @@ export declare class DecryptedPlanOfAction {
     status: number;
     documentIds: Array<string>;
     numberOfCares: number | undefined;
-    careTeamMemberships: Array<DecryptedCareTeamMembership | undefined>;
+    careTeamMemberships: Array<DecryptedCareTeamMembership>;
     relevant: boolean;
     encryptedSelf: Base64String | undefined;
     readonly isEncrypted: false;
     constructor(partial: Partial<DecryptedPlanOfAction>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): DecryptedPlanOfAction;
 }
 export declare class EncryptedPlanOfAction {
     id: string;
@@ -73,9 +76,11 @@ export declare class EncryptedPlanOfAction {
     status: number;
     documentIds: Array<string>;
     numberOfCares: number | undefined;
-    careTeamMemberships: Array<EncryptedCareTeamMembership | undefined>;
+    careTeamMemberships: Array<EncryptedCareTeamMembership>;
     relevant: boolean;
     encryptedSelf: Base64String | undefined;
     readonly isEncrypted: true;
     constructor(partial: Partial<EncryptedPlanOfAction>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): EncryptedPlanOfAction;
 }