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

package/model/embed/CalendarItemTag.d.mts

@@ -6,6 +6,7 @@ export interface CalendarItemTag extends Encryptable {
     userId: string | undefined;
     userName: string | undefined;
     readonly isEncrypted: boolean;
+    toJSON(): object;
 }
 export declare class DecryptedCalendarItemTag {
     code: string | undefined;
@@ -15,6 +16,8 @@ export declare class DecryptedCalendarItemTag {
     encryptedSelf: Base64String | undefined;
     readonly isEncrypted: false;
     constructor(partial: Partial<DecryptedCalendarItemTag>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): DecryptedCalendarItemTag;
 }
 export declare class EncryptedCalendarItemTag {
     code: string | undefined;
@@ -24,4 +27,6 @@ export declare class EncryptedCalendarItemTag {
     encryptedSelf: Base64String | undefined;
     readonly isEncrypted: true;
     constructor(partial: Partial<EncryptedCalendarItemTag>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): EncryptedCalendarItemTag;
 }

package/model/embed/CalendarItemTag.mjs

@@ -1,3 +1,5 @@
+// auto-generated file
+import { expectNumber, expectString, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
 export class DecryptedCalendarItemTag {
     constructor(partial) {
         this.code = undefined;
@@ -19,6 +21,41 @@ export class DecryptedCalendarItemTag {
         if ('encryptedSelf' in partial)
             this.encryptedSelf = partial.encryptedSelf;
     }
+    toJSON() {
+        const res = {};
+        if (this.code != undefined)
+            res['code'] = this.code;
+        if (this.date != undefined)
+            res['date'] = this.date;
+        if (this.userId != undefined)
+            res['userId'] = this.userId;
+        if (this.userName != undefined)
+            res['userName'] = this.userName;
+        if (this.encryptedSelf != undefined)
+            res['encryptedSelf'] = this.encryptedSelf;
+        res['isEncrypted'] = false;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['DecryptedCalendarItemTag']) {
+        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 DecryptedCalendarItemTag`);
+        const res = new DecryptedCalendarItemTag({
+            code: expectString(extractEntry(jCpy, 'code', false, path), true, [...path, ".code"]),
+            date: expectNumber(extractEntry(jCpy, 'date', false, path), true, true, [...path, ".date"]),
+            userId: expectString(extractEntry(jCpy, 'userId', false, path), true, [...path, ".userId"]),
+            userName: expectString(extractEntry(jCpy, 'userName', false, path), true, [...path, ".userName"]),
+            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 DecryptedCalendarItemTag at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }
 export class EncryptedCalendarItemTag {
     constructor(partial) {
@@ -41,4 +78,39 @@ export class EncryptedCalendarItemTag {
         if ('encryptedSelf' in partial)
             this.encryptedSelf = partial.encryptedSelf;
     }
+    toJSON() {
+        const res = {};
+        if (this.code != undefined)
+            res['code'] = this.code;
+        if (this.date != undefined)
+            res['date'] = this.date;
+        if (this.userId != undefined)
+            res['userId'] = this.userId;
+        if (this.userName != undefined)
+            res['userName'] = this.userName;
+        if (this.encryptedSelf != undefined)
+            res['encryptedSelf'] = this.encryptedSelf;
+        res['isEncrypted'] = true;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['EncryptedCalendarItemTag']) {
+        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 EncryptedCalendarItemTag`);
+        const res = new EncryptedCalendarItemTag({
+            code: expectString(extractEntry(jCpy, 'code', false, path), true, [...path, ".code"]),
+            date: expectNumber(extractEntry(jCpy, 'date', false, path), true, true, [...path, ".date"]),
+            userId: expectString(extractEntry(jCpy, 'userId', false, path), true, [...path, ".userId"]),
+            userName: expectString(extractEntry(jCpy, 'userName', false, path), true, [...path, ".userName"]),
+            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 EncryptedCalendarItemTag at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/embed/CareTeamMember.d.mts

@@ -8,6 +8,7 @@ export interface CareTeamMember extends Encryptable, Identifiable<string> {
     healthcarePartyId: string | undefined;
     quality: CodeStub | undefined;
     readonly isEncrypted: boolean;
+    toJSON(): object;
 }
 export declare class DecryptedCareTeamMember {
     id: string;
@@ -17,6 +18,8 @@ export declare class DecryptedCareTeamMember {
     encryptedSelf: Base64String | undefined;
     readonly isEncrypted: false;
     constructor(partial: Partial<DecryptedCareTeamMember>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): DecryptedCareTeamMember;
 }
 export declare class EncryptedCareTeamMember {
     id: string;
@@ -26,4 +29,6 @@ export declare class EncryptedCareTeamMember {
     encryptedSelf: Base64String | undefined;
     readonly isEncrypted: true;
     constructor(partial: Partial<EncryptedCareTeamMember>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): EncryptedCareTeamMember;
 }

package/model/embed/CareTeamMember.mjs

@@ -1,5 +1,8 @@
 // auto-generated file
+import { expectObject, expectString, expectStringEnum, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
 import { randomUuid } from '../../utils/Id.mjs';
+import { CodeStub } from '../base/CodeStub.mjs';
+import { CareTeamMemberType } from './CareTeamMemberType.mjs';
 export class DecryptedCareTeamMember {
     constructor(partial) {
         var _a;
@@ -20,6 +23,40 @@ export class DecryptedCareTeamMember {
         if ('encryptedSelf' in partial)
             this.encryptedSelf = partial.encryptedSelf;
     }
+    toJSON() {
+        const res = {};
+        res['id'] = this.id;
+        if (this.careTeamMemberType != undefined)
+            res['careTeamMemberType'] = this.careTeamMemberType;
+        if (this.healthcarePartyId != undefined)
+            res['healthcarePartyId'] = this.healthcarePartyId;
+        if (this.quality != undefined)
+            res['quality'] = this.quality.toJSON();
+        if (this.encryptedSelf != undefined)
+            res['encryptedSelf'] = this.encryptedSelf;
+        res['isEncrypted'] = false;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['DecryptedCareTeamMember']) {
+        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 DecryptedCareTeamMember`);
+        const res = new DecryptedCareTeamMember({
+            id: expectString(extractEntry(jCpy, 'id', true, path), false, [...path, ".id"]),
+            careTeamMemberType: expectStringEnum(extractEntry(jCpy, 'careTeamMemberType', false, path), true, [...path, ".careTeamMemberType"], CareTeamMemberType, 'CareTeamMemberType'),
+            healthcarePartyId: expectString(extractEntry(jCpy, 'healthcarePartyId', false, path), true, [...path, ".healthcarePartyId"]),
+            quality: expectObject(extractEntry(jCpy, 'quality', false, path), true, ignoreUnknownKeys, [...path, ".quality"], CodeStub.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 DecryptedCareTeamMember at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }
 export class EncryptedCareTeamMember {
     constructor(partial) {
@@ -41,4 +78,38 @@ export class EncryptedCareTeamMember {
         if ('encryptedSelf' in partial)
             this.encryptedSelf = partial.encryptedSelf;
     }
+    toJSON() {
+        const res = {};
+        res['id'] = this.id;
+        if (this.careTeamMemberType != undefined)
+            res['careTeamMemberType'] = this.careTeamMemberType;
+        if (this.healthcarePartyId != undefined)
+            res['healthcarePartyId'] = this.healthcarePartyId;
+        if (this.quality != undefined)
+            res['quality'] = this.quality.toJSON();
+        if (this.encryptedSelf != undefined)
+            res['encryptedSelf'] = this.encryptedSelf;
+        res['isEncrypted'] = true;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['EncryptedCareTeamMember']) {
+        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 EncryptedCareTeamMember`);
+        const res = new EncryptedCareTeamMember({
+            id: expectString(extractEntry(jCpy, 'id', true, path), false, [...path, ".id"]),
+            careTeamMemberType: expectStringEnum(extractEntry(jCpy, 'careTeamMemberType', false, path), true, [...path, ".careTeamMemberType"], CareTeamMemberType, 'CareTeamMemberType'),
+            healthcarePartyId: expectString(extractEntry(jCpy, 'healthcarePartyId', false, path), true, [...path, ".healthcarePartyId"]),
+            quality: expectObject(extractEntry(jCpy, 'quality', false, path), true, ignoreUnknownKeys, [...path, ".quality"], CodeStub.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 EncryptedCareTeamMember at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/embed/CareTeamMembership.d.mts

@@ -7,6 +7,7 @@ export interface CareTeamMembership extends Encryptable {
     careTeamMemberId: string | undefined;
     membershipType: MembershipType | undefined;
     readonly isEncrypted: boolean;
+    toJSON(): object;
 }
 export declare class DecryptedCareTeamMembership {
     startDate: number | undefined;
@@ -16,6 +17,8 @@ export declare class DecryptedCareTeamMembership {
     encryptedSelf: Base64String | undefined;
     readonly isEncrypted: false;
     constructor(partial: Partial<DecryptedCareTeamMembership>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): DecryptedCareTeamMembership;
 }
 export declare class EncryptedCareTeamMembership {
     startDate: number | undefined;
@@ -25,4 +28,6 @@ export declare class EncryptedCareTeamMembership {
     encryptedSelf: Base64String | undefined;
     readonly isEncrypted: true;
     constructor(partial: Partial<EncryptedCareTeamMembership>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): EncryptedCareTeamMembership;
 }

package/model/embed/CareTeamMembership.mjs

@@ -1,3 +1,6 @@
+// auto-generated file
+import { expectNumber, expectString, expectStringEnum, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
+import { MembershipType } from './MembershipType.mjs';
 export class DecryptedCareTeamMembership {
     constructor(partial) {
         this.startDate = undefined;
@@ -19,6 +22,41 @@ export class DecryptedCareTeamMembership {
         if ('encryptedSelf' in partial)
             this.encryptedSelf = partial.encryptedSelf;
     }
+    toJSON() {
+        const res = {};
+        if (this.startDate != undefined)
+            res['startDate'] = this.startDate;
+        if (this.endDate != undefined)
+            res['endDate'] = this.endDate;
+        if (this.careTeamMemberId != undefined)
+            res['careTeamMemberId'] = this.careTeamMemberId;
+        if (this.membershipType != undefined)
+            res['membershipType'] = this.membershipType;
+        if (this.encryptedSelf != undefined)
+            res['encryptedSelf'] = this.encryptedSelf;
+        res['isEncrypted'] = false;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['DecryptedCareTeamMembership']) {
+        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 DecryptedCareTeamMembership`);
+        const res = new DecryptedCareTeamMembership({
+            startDate: expectNumber(extractEntry(jCpy, 'startDate', false, path), true, true, [...path, ".startDate"]),
+            endDate: expectNumber(extractEntry(jCpy, 'endDate', false, path), true, true, [...path, ".endDate"]),
+            careTeamMemberId: expectString(extractEntry(jCpy, 'careTeamMemberId', false, path), true, [...path, ".careTeamMemberId"]),
+            membershipType: expectStringEnum(extractEntry(jCpy, 'membershipType', false, path), true, [...path, ".membershipType"], MembershipType, 'MembershipType'),
+            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 DecryptedCareTeamMembership at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }
 export class EncryptedCareTeamMembership {
     constructor(partial) {
@@ -41,4 +79,39 @@ export class EncryptedCareTeamMembership {
         if ('encryptedSelf' in partial)
             this.encryptedSelf = partial.encryptedSelf;
     }
+    toJSON() {
+        const res = {};
+        if (this.startDate != undefined)
+            res['startDate'] = this.startDate;
+        if (this.endDate != undefined)
+            res['endDate'] = this.endDate;
+        if (this.careTeamMemberId != undefined)
+            res['careTeamMemberId'] = this.careTeamMemberId;
+        if (this.membershipType != undefined)
+            res['membershipType'] = this.membershipType;
+        if (this.encryptedSelf != undefined)
+            res['encryptedSelf'] = this.encryptedSelf;
+        res['isEncrypted'] = true;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['EncryptedCareTeamMembership']) {
+        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 EncryptedCareTeamMembership`);
+        const res = new EncryptedCareTeamMembership({
+            startDate: expectNumber(extractEntry(jCpy, 'startDate', false, path), true, true, [...path, ".startDate"]),
+            endDate: expectNumber(extractEntry(jCpy, 'endDate', false, path), true, true, [...path, ".endDate"]),
+            careTeamMemberId: expectString(extractEntry(jCpy, 'careTeamMemberId', false, path), true, [...path, ".careTeamMemberId"]),
+            membershipType: expectStringEnum(extractEntry(jCpy, 'membershipType', false, path), true, [...path, ".membershipType"], MembershipType, 'MembershipType'),
+            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 EncryptedCareTeamMembership at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/embed/Content.d.mts

@@ -17,6 +17,7 @@ export interface Content {
     ratio: Array<Measure> | undefined;
     range: Array<Measure> | undefined;
     readonly isEncrypted: boolean;
+    toJSON(): object;
 }
 export declare class DecryptedContent {
     stringValue: string | undefined;
@@ -34,6 +35,8 @@ export declare class DecryptedContent {
     range: Array<Measure> | undefined;
     readonly isEncrypted: false;
     constructor(partial: Partial<DecryptedContent>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): DecryptedContent;
 }
 export declare class EncryptedContent {
     stringValue: string | undefined;
@@ -51,4 +54,6 @@ export declare class EncryptedContent {
     range: Array<Measure> | undefined;
     readonly isEncrypted: true;
     constructor(partial: Partial<EncryptedContent>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): EncryptedContent;
 }

package/model/embed/Content.mjs

@@ -1,3 +1,10 @@
+// auto-generated file
+import { decodeBase64, encodeBase64 } from '../../internal/BytesEncoding.mjs';
+import { expectArray, expectBoolean, expectNumber, expectObject, expectString, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
+import { Measure } from './Measure.mjs';
+import { Medication } from './Medication.mjs';
+import { DecryptedService, EncryptedService } from './Service.mjs';
+import { TimeSeries } from './TimeSeries.mjs';
 export class DecryptedContent {
     constructor(partial) {
         this.stringValue = undefined;
@@ -43,6 +50,65 @@ export class DecryptedContent {
         if ('range' in partial)
             this.range = partial.range;
     }
+    toJSON() {
+        const res = {};
+        if (this.stringValue != undefined)
+            res['stringValue'] = this.stringValue;
+        if (this.numberValue != undefined)
+            res['numberValue'] = this.numberValue;
+        if (this.booleanValue != undefined)
+            res['booleanValue'] = this.booleanValue;
+        if (this.instantValue != undefined)
+            res['instantValue'] = this.instantValue;
+        if (this.fuzzyDateValue != undefined)
+            res['fuzzyDateValue'] = this.fuzzyDateValue;
+        if (this.binaryValue != undefined)
+            res['binaryValue'] = encodeBase64(this.binaryValue);
+        if (this.documentId != undefined)
+            res['documentId'] = this.documentId;
+        if (this.measureValue != undefined)
+            res['measureValue'] = this.measureValue.toJSON();
+        if (this.medicationValue != undefined)
+            res['medicationValue'] = this.medicationValue.toJSON();
+        if (this.timeSeries != undefined)
+            res['timeSeries'] = this.timeSeries.toJSON();
+        if (this.compoundValue != undefined)
+            res['compoundValue'] = this.compoundValue.map((x0) => x0.toJSON());
+        if (this.ratio != undefined)
+            res['ratio'] = this.ratio.map((x0) => x0.toJSON());
+        if (this.range != undefined)
+            res['range'] = this.range.map((x0) => x0.toJSON());
+        res['isEncrypted'] = false;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['DecryptedContent']) {
+        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 DecryptedContent`);
+        const res = new DecryptedContent({
+            stringValue: expectString(extractEntry(jCpy, 'stringValue', false, path), true, [...path, ".stringValue"]),
+            numberValue: expectNumber(extractEntry(jCpy, 'numberValue', false, path), true, false, [...path, ".numberValue"]),
+            booleanValue: expectBoolean(extractEntry(jCpy, 'booleanValue', false, path), true, [...path, ".booleanValue"]),
+            instantValue: expectNumber(extractEntry(jCpy, 'instantValue', false, path), true, true, [...path, ".instantValue"]),
+            fuzzyDateValue: expectNumber(extractEntry(jCpy, 'fuzzyDateValue', false, path), true, true, [...path, ".fuzzyDateValue"]),
+            binaryValue: decodeBase64(expectString(extractEntry(jCpy, 'binaryValue', false, path), true, [...path, ".binaryValue"]), [...path, ".binaryValue"]),
+            documentId: expectString(extractEntry(jCpy, 'documentId', false, path), true, [...path, ".documentId"]),
+            measureValue: expectObject(extractEntry(jCpy, 'measureValue', false, path), true, ignoreUnknownKeys, [...path, ".measureValue"], Measure.fromJSON),
+            medicationValue: expectObject(extractEntry(jCpy, 'medicationValue', false, path), true, ignoreUnknownKeys, [...path, ".medicationValue"], Medication.fromJSON),
+            timeSeries: expectObject(extractEntry(jCpy, 'timeSeries', false, path), true, ignoreUnknownKeys, [...path, ".timeSeries"], TimeSeries.fromJSON),
+            compoundValue: expectArray(extractEntry(jCpy, 'compoundValue', false, path), true, [...path, ".compoundValue"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, DecryptedService.fromJSON)),
+            ratio: expectArray(extractEntry(jCpy, 'ratio', false, path), true, [...path, ".ratio"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, Measure.fromJSON)),
+            range: expectArray(extractEntry(jCpy, 'range', false, path), true, [...path, ".range"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, Measure.fromJSON)),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object DecryptedContent at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }
 export class EncryptedContent {
     constructor(partial) {
@@ -89,4 +155,63 @@ export class EncryptedContent {
         if ('range' in partial)
             this.range = partial.range;
     }
+    toJSON() {
+        const res = {};
+        if (this.stringValue != undefined)
+            res['stringValue'] = this.stringValue;
+        if (this.numberValue != undefined)
+            res['numberValue'] = this.numberValue;
+        if (this.booleanValue != undefined)
+            res['booleanValue'] = this.booleanValue;
+        if (this.instantValue != undefined)
+            res['instantValue'] = this.instantValue;
+        if (this.fuzzyDateValue != undefined)
+            res['fuzzyDateValue'] = this.fuzzyDateValue;
+        if (this.binaryValue != undefined)
+            res['binaryValue'] = encodeBase64(this.binaryValue);
+        if (this.documentId != undefined)
+            res['documentId'] = this.documentId;
+        if (this.measureValue != undefined)
+            res['measureValue'] = this.measureValue.toJSON();
+        if (this.medicationValue != undefined)
+            res['medicationValue'] = this.medicationValue.toJSON();
+        if (this.timeSeries != undefined)
+            res['timeSeries'] = this.timeSeries.toJSON();
+        if (this.compoundValue != undefined)
+            res['compoundValue'] = this.compoundValue.map((x0) => x0.toJSON());
+        if (this.ratio != undefined)
+            res['ratio'] = this.ratio.map((x0) => x0.toJSON());
+        if (this.range != undefined)
+            res['range'] = this.range.map((x0) => x0.toJSON());
+        res['isEncrypted'] = true;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['EncryptedContent']) {
+        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 EncryptedContent`);
+        const res = new EncryptedContent({
+            stringValue: expectString(extractEntry(jCpy, 'stringValue', false, path), true, [...path, ".stringValue"]),
+            numberValue: expectNumber(extractEntry(jCpy, 'numberValue', false, path), true, false, [...path, ".numberValue"]),
+            booleanValue: expectBoolean(extractEntry(jCpy, 'booleanValue', false, path), true, [...path, ".booleanValue"]),
+            instantValue: expectNumber(extractEntry(jCpy, 'instantValue', false, path), true, true, [...path, ".instantValue"]),
+            fuzzyDateValue: expectNumber(extractEntry(jCpy, 'fuzzyDateValue', false, path), true, true, [...path, ".fuzzyDateValue"]),
+            binaryValue: decodeBase64(expectString(extractEntry(jCpy, 'binaryValue', false, path), true, [...path, ".binaryValue"]), [...path, ".binaryValue"]),
+            documentId: expectString(extractEntry(jCpy, 'documentId', false, path), true, [...path, ".documentId"]),
+            measureValue: expectObject(extractEntry(jCpy, 'measureValue', false, path), true, ignoreUnknownKeys, [...path, ".measureValue"], Measure.fromJSON),
+            medicationValue: expectObject(extractEntry(jCpy, 'medicationValue', false, path), true, ignoreUnknownKeys, [...path, ".medicationValue"], Medication.fromJSON),
+            timeSeries: expectObject(extractEntry(jCpy, 'timeSeries', false, path), true, ignoreUnknownKeys, [...path, ".timeSeries"], TimeSeries.fromJSON),
+            compoundValue: expectArray(extractEntry(jCpy, 'compoundValue', false, path), true, [...path, ".compoundValue"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, EncryptedService.fromJSON)),
+            ratio: expectArray(extractEntry(jCpy, 'ratio', false, path), true, [...path, ".ratio"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, Measure.fromJSON)),
+            range: expectArray(extractEntry(jCpy, 'range', false, path), true, [...path, ".range"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, Measure.fromJSON)),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object EncryptedContent at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/embed/DataAttachment.d.mts

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

package/model/embed/DataAttachment.mjs

@@ -1,4 +1,5 @@
 // auto-generated file
+import { expectArray, expectString, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
 export class DataAttachment {
     constructor(partial) {
         this.couchDbAttachmentId = undefined;
@@ -11,4 +12,29 @@ export class DataAttachment {
         if ('utis' in partial && partial.utis !== undefined)
             this.utis = partial.utis;
     }
+    toJSON() {
+        const res = {};
+        if (this.couchDbAttachmentId != undefined)
+            res['couchDbAttachmentId'] = this.couchDbAttachmentId;
+        if (this.objectStoreAttachmentId != undefined)
+            res['objectStoreAttachmentId'] = this.objectStoreAttachmentId;
+        res['utis'] = this.utis.map((x0) => x0);
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['DataAttachment']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new DataAttachment({
+            couchDbAttachmentId: expectString(extractEntry(jCpy, 'couchDbAttachmentId', false, path), true, [...path, ".couchDbAttachmentId"]),
+            objectStoreAttachmentId: expectString(extractEntry(jCpy, 'objectStoreAttachmentId', false, path), true, [...path, ".objectStoreAttachmentId"]),
+            utis: expectArray(extractEntry(jCpy, 'utis', false, path), false, [...path, ".utis"], (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 DataAttachment at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/embed/DatabaseSynchronization.d.mts

@@ -4,6 +4,8 @@ export declare class DatabaseSynchronization {
     filter: string | undefined;
     localTarget: DatabaseSynchronization.Target | undefined;
     constructor(partial: Partial<DatabaseSynchronization>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): DatabaseSynchronization;
 }
 export declare namespace DatabaseSynchronization {
     enum Target {

package/model/embed/DatabaseSynchronization.mjs

@@ -1,4 +1,5 @@
 // auto-generated file
+import { expectString, expectStringEnum, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
 export class DatabaseSynchronization {
     constructor(partial) {
         this.source = undefined;
@@ -14,6 +15,35 @@ export class DatabaseSynchronization {
         if ('localTarget' in partial)
             this.localTarget = partial.localTarget;
     }
+    toJSON() {
+        const res = {};
+        if (this.source != undefined)
+            res['source'] = this.source;
+        if (this.target != undefined)
+            res['target'] = this.target;
+        if (this.filter != undefined)
+            res['filter'] = this.filter;
+        if (this.localTarget != undefined)
+            res['localTarget'] = this.localTarget;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['DatabaseSynchronization']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new DatabaseSynchronization({
+            source: expectString(extractEntry(jCpy, 'source', false, path), true, [...path, ".source"]),
+            target: expectString(extractEntry(jCpy, 'target', false, path), true, [...path, ".target"]),
+            filter: expectString(extractEntry(jCpy, 'filter', false, path), true, [...path, ".filter"]),
+            localTarget: expectStringEnum(extractEntry(jCpy, 'localTarget', false, path), true, [...path, ".localTarget"], DatabaseSynchronization.Target, 'DatabaseSynchronization.Target'),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object DatabaseSynchronization at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }
 (function (DatabaseSynchronization) {
     let Target;

package/model/embed/Delegation.d.mts

@@ -5,4 +5,6 @@ export declare class Delegation {
     key: HexString | undefined;
     tags: Array<string>;
     constructor(partial: Partial<Delegation>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): Delegation;
 }

package/model/embed/Delegation.mjs

@@ -1,3 +1,5 @@
+// auto-generated file
+import { expectArray, expectString, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
 export class Delegation {
     constructor(partial) {
         this.owner = undefined;
@@ -13,4 +15,32 @@ export class Delegation {
         if ('tags' in partial && partial.tags !== undefined)
             this.tags = partial.tags;
     }
+    toJSON() {
+        const res = {};
+        if (this.owner != undefined)
+            res['owner'] = this.owner;
+        if (this.delegatedTo != undefined)
+            res['delegatedTo'] = this.delegatedTo;
+        if (this.key != undefined)
+            res['key'] = this.key;
+        res['tags'] = this.tags.map((x0) => x0);
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['Delegation']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new Delegation({
+            owner: expectString(extractEntry(jCpy, 'owner', false, path), true, [...path, ".owner"]),
+            delegatedTo: expectString(extractEntry(jCpy, 'delegatedTo', false, path), true, [...path, ".delegatedTo"]),
+            key: expectString(extractEntry(jCpy, 'key', false, path), true, [...path, ".key"]),
+            tags: expectArray(extractEntry(jCpy, 'tags', false, path), false, [...path, ".tags"], (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 Delegation at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/embed/DeletedAttachment.d.mts

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