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

package/model/couchdb/RemoteAuthentication.d.mts

@@ -2,4 +2,6 @@ import { Basic } from './Basic.mjs';
 export declare class RemoteAuthentication {
     basic: Basic | undefined;
     constructor(partial: Partial<RemoteAuthentication>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): RemoteAuthentication;
 }

package/model/couchdb/RemoteAuthentication.mjs

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

package/model/couchdb/ReplicationStats.d.mts

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

package/model/couchdb/ReplicationStats.mjs

@@ -1,4 +1,5 @@
 // auto-generated file
+import { expectNumber, expectString, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
 export class ReplicationStats {
     constructor(partial) {
         this.revisionsChecked = undefined;
@@ -29,4 +30,48 @@ export class ReplicationStats {
         if ('error' in partial)
             this.error = partial.error;
     }
+    toJSON() {
+        const res = {};
+        if (this.revisionsChecked != undefined)
+            res['revisionsChecked'] = this.revisionsChecked;
+        if (this.missingRevisionsFound != undefined)
+            res['missingRevisionsFound'] = this.missingRevisionsFound;
+        if (this.docsRead != undefined)
+            res['docsRead'] = this.docsRead;
+        if (this.docsWritten != undefined)
+            res['docsWritten'] = this.docsWritten;
+        if (this.changesPending != undefined)
+            res['changesPending'] = this.changesPending;
+        if (this.docWriteFailures != undefined)
+            res['docWriteFailures'] = this.docWriteFailures;
+        if (this.checkpointedSourceSeq != undefined)
+            res['checkpointedSourceSeq'] = this.checkpointedSourceSeq;
+        if (this.startTime != undefined)
+            res['startTime'] = this.startTime;
+        if (this.error != undefined)
+            res['error'] = this.error;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['ReplicationStats']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new ReplicationStats({
+            revisionsChecked: expectNumber(extractEntry(jCpy, 'revisionsChecked', false, path), true, true, [...path, ".revisionsChecked"]),
+            missingRevisionsFound: expectNumber(extractEntry(jCpy, 'missingRevisionsFound', false, path), true, true, [...path, ".missingRevisionsFound"]),
+            docsRead: expectNumber(extractEntry(jCpy, 'docsRead', false, path), true, true, [...path, ".docsRead"]),
+            docsWritten: expectNumber(extractEntry(jCpy, 'docsWritten', false, path), true, true, [...path, ".docsWritten"]),
+            changesPending: expectNumber(extractEntry(jCpy, 'changesPending', false, path), true, true, [...path, ".changesPending"]),
+            docWriteFailures: expectNumber(extractEntry(jCpy, 'docWriteFailures', false, path), true, true, [...path, ".docWriteFailures"]),
+            checkpointedSourceSeq: expectString(extractEntry(jCpy, 'checkpointedSourceSeq', false, path), true, [...path, ".checkpointedSourceSeq"]),
+            startTime: expectString(extractEntry(jCpy, 'startTime', false, path), true, [...path, ".startTime"]),
+            error: expectString(extractEntry(jCpy, 'error', false, path), true, [...path, ".error"]),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object ReplicationStats at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/couchdb/ReplicatorDocument.d.mts

@@ -21,4 +21,6 @@ export declare class ReplicatorDocument implements Versionable<string> {
         [key: string]: string;
     } | undefined;
     constructor(partial: Partial<ReplicatorDocument>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): ReplicatorDocument;
 }

package/model/couchdb/ReplicatorDocument.mjs

@@ -1,5 +1,8 @@
 // auto-generated file
+import { expectArray, expectBoolean, expectMap, expectNumber, expectObject, expectString, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
 import { randomUuid } from '../../utils/Id.mjs';
+import { Remote } from './Remote.mjs';
+import { ReplicationStats } from './ReplicationStats.mjs';
 export class ReplicatorDocument {
     constructor(partial) {
         var _a;
@@ -44,4 +47,62 @@ export class ReplicatorDocument {
         if ('revHistory' in partial)
             this.revHistory = partial.revHistory;
     }
+    toJSON() {
+        const res = {};
+        res['id'] = this.id;
+        if (this.rev != undefined)
+            res['rev'] = this.rev;
+        if (this.source != undefined)
+            res['source'] = this.source.toJSON();
+        if (this.target != undefined)
+            res['target'] = this.target.toJSON();
+        if (this.owner != undefined)
+            res['owner'] = this.owner;
+        if (this.create_target != undefined)
+            res['create_target'] = this.create_target;
+        if (this.continuous != undefined)
+            res['continuous'] = this.continuous;
+        if (this.doc_ids != undefined)
+            res['doc_ids'] = this.doc_ids.map((x0) => x0);
+        if (this.replicationState != undefined)
+            res['replicationState'] = this.replicationState;
+        if (this.replicationStateTime != undefined)
+            res['replicationStateTime'] = this.replicationStateTime;
+        if (this.replicationStats != undefined)
+            res['replicationStats'] = this.replicationStats.toJSON();
+        if (this.errorCount != undefined)
+            res['errorCount'] = this.errorCount;
+        if (this.revsInfo != undefined)
+            res['revsInfo'] = this.revsInfo.map((x0) => Object.fromEntries(Object.entries(x0).map(([k1, v1]) => [k1, v1])));
+        if (this.revHistory != undefined)
+            res['revHistory'] = Object.fromEntries(Object.entries(this.revHistory).map(([k0, v0]) => [k0, v0]));
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['ReplicatorDocument']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new ReplicatorDocument({
+            id: expectString(extractEntry(jCpy, 'id', true, path), false, [...path, ".id"]),
+            rev: expectString(extractEntry(jCpy, 'rev', false, path), true, [...path, ".rev"]),
+            source: expectObject(extractEntry(jCpy, 'source', false, path), true, ignoreUnknownKeys, [...path, ".source"], Remote.fromJSON),
+            target: expectObject(extractEntry(jCpy, 'target', false, path), true, ignoreUnknownKeys, [...path, ".target"], Remote.fromJSON),
+            owner: expectString(extractEntry(jCpy, 'owner', false, path), true, [...path, ".owner"]),
+            create_target: expectBoolean(extractEntry(jCpy, 'create_target', false, path), true, [...path, ".create_target"]),
+            continuous: expectBoolean(extractEntry(jCpy, 'continuous', false, path), true, [...path, ".continuous"]),
+            doc_ids: expectArray(extractEntry(jCpy, 'doc_ids', false, path), true, [...path, ".doc_ids"], (x0, p0) => expectString(x0, false, p0)),
+            replicationState: expectString(extractEntry(jCpy, 'replicationState', false, path), true, [...path, ".replicationState"]),
+            replicationStateTime: expectString(extractEntry(jCpy, 'replicationStateTime', false, path), true, [...path, ".replicationStateTime"]),
+            replicationStats: expectObject(extractEntry(jCpy, 'replicationStats', false, path), true, ignoreUnknownKeys, [...path, ".replicationStats"], ReplicationStats.fromJSON),
+            errorCount: expectNumber(extractEntry(jCpy, 'errorCount', false, path), true, true, [...path, ".errorCount"]),
+            revsInfo: expectArray(extractEntry(jCpy, 'revsInfo', false, path), true, [...path, ".revsInfo"], (x0, p0) => expectMap(x0, false, p0, (k1, p1) => expectString(k1, false, p1), (v1, p1) => expectString(v1, false, p1))),
+            revHistory: expectMap(extractEntry(jCpy, 'revHistory', false, path), true, [...path, ".revHistory"], (k0, p0) => expectString(k0, false, p0), (v0, p0) => expectString(v0, false, p0)),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object ReplicatorDocument at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/couchdb/View.d.mts

@@ -2,4 +2,6 @@ export declare class View {
     map: string;
     reduce: string | undefined;
     constructor(partial: Partial<View> & Pick<View, "map">);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): View;
 }

package/model/couchdb/View.mjs

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

package/model/data/LabelledOccurence.d.mts

@@ -2,4 +2,6 @@ export declare class LabelledOccurence {
     label: string;
     occurence: number;
     constructor(partial: Partial<LabelledOccurence> & Pick<LabelledOccurence, "label" | "occurence">);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): LabelledOccurence;
 }

package/model/data/LabelledOccurence.mjs

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

package/model/embed/Address.d.mts

@@ -22,6 +22,7 @@ export interface Address extends Encryptable, HasTags, HasCodes {
     notes: Array<Annotation>;
     telecoms: Array<Telecom>;
     readonly isEncrypted: boolean;
+    toJSON(): object;
 }
 export declare class DecryptedAddress {
     tags: Array<CodeStub>;
@@ -42,6 +43,8 @@ export declare class DecryptedAddress {
     encryptedSelf: Base64String | undefined;
     readonly isEncrypted: false;
     constructor(partial: Partial<DecryptedAddress>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): DecryptedAddress;
 }
 export declare class EncryptedAddress {
     tags: Array<CodeStub>;
@@ -62,4 +65,6 @@ export declare class EncryptedAddress {
     encryptedSelf: Base64String | undefined;
     readonly isEncrypted: true;
     constructor(partial: Partial<EncryptedAddress>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): EncryptedAddress;
 }

package/model/embed/Address.mjs

@@ -1,3 +1,10 @@
+// auto-generated file
+import { expectArray, expectObject, expectString, expectStringEnum, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
+import { CodeStub } from '../base/CodeStub.mjs';
+import { Identifier } from '../base/Identifier.mjs';
+import { AddressType } from './AddressType.mjs';
+import { Annotation } from './Annotation.mjs';
+import { DecryptedTelecom, EncryptedTelecom } from './Telecom.mjs';
 export class DecryptedAddress {
     constructor(partial) {
         this.tags = [];
@@ -52,6 +59,69 @@ export class DecryptedAddress {
         if ('encryptedSelf' in partial)
             this.encryptedSelf = partial.encryptedSelf;
     }
+    toJSON() {
+        const res = {};
+        res['tags'] = this.tags.map((x0) => x0.toJSON());
+        res['codes'] = this.codes.map((x0) => x0.toJSON());
+        res['identifier'] = this.identifier.map((x0) => x0.toJSON());
+        if (this.addressType != undefined)
+            res['addressType'] = this.addressType;
+        if (this.descr != undefined)
+            res['descr'] = this.descr;
+        if (this.street != undefined)
+            res['street'] = this.street;
+        if (this.houseNumber != undefined)
+            res['houseNumber'] = this.houseNumber;
+        if (this.postboxNumber != undefined)
+            res['postboxNumber'] = this.postboxNumber;
+        if (this.postalCode != undefined)
+            res['postalCode'] = this.postalCode;
+        if (this.city != undefined)
+            res['city'] = this.city;
+        if (this.state != undefined)
+            res['state'] = this.state;
+        if (this.country != undefined)
+            res['country'] = this.country;
+        if (this.note != undefined)
+            res['note'] = this.note;
+        res['notes'] = this.notes.map((x0) => x0.toJSON());
+        res['telecoms'] = this.telecoms.map((x0) => x0.toJSON());
+        if (this.encryptedSelf != undefined)
+            res['encryptedSelf'] = this.encryptedSelf;
+        res['isEncrypted'] = false;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['DecryptedAddress']) {
+        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 DecryptedAddress`);
+        const res = new DecryptedAddress({
+            tags: expectArray(extractEntry(jCpy, 'tags', false, path), false, [...path, ".tags"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, CodeStub.fromJSON)),
+            codes: expectArray(extractEntry(jCpy, 'codes', false, path), false, [...path, ".codes"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, CodeStub.fromJSON)),
+            identifier: expectArray(extractEntry(jCpy, 'identifier', false, path), false, [...path, ".identifier"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, Identifier.fromJSON)),
+            addressType: expectStringEnum(extractEntry(jCpy, 'addressType', false, path), true, [...path, ".addressType"], AddressType, 'AddressType'),
+            descr: expectString(extractEntry(jCpy, 'descr', false, path), true, [...path, ".descr"]),
+            street: expectString(extractEntry(jCpy, 'street', false, path), true, [...path, ".street"]),
+            houseNumber: expectString(extractEntry(jCpy, 'houseNumber', false, path), true, [...path, ".houseNumber"]),
+            postboxNumber: expectString(extractEntry(jCpy, 'postboxNumber', false, path), true, [...path, ".postboxNumber"]),
+            postalCode: expectString(extractEntry(jCpy, 'postalCode', false, path), true, [...path, ".postalCode"]),
+            city: expectString(extractEntry(jCpy, 'city', false, path), true, [...path, ".city"]),
+            state: expectString(extractEntry(jCpy, 'state', false, path), true, [...path, ".state"]),
+            country: expectString(extractEntry(jCpy, 'country', false, path), true, [...path, ".country"]),
+            note: expectString(extractEntry(jCpy, 'note', false, path), true, [...path, ".note"]),
+            notes: expectArray(extractEntry(jCpy, 'notes', false, path), false, [...path, ".notes"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, Annotation.fromJSON)),
+            telecoms: expectArray(extractEntry(jCpy, 'telecoms', false, path), false, [...path, ".telecoms"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, DecryptedTelecom.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 DecryptedAddress at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }
 export class EncryptedAddress {
     constructor(partial) {
@@ -107,4 +177,67 @@ export class EncryptedAddress {
         if ('encryptedSelf' in partial)
             this.encryptedSelf = partial.encryptedSelf;
     }
+    toJSON() {
+        const res = {};
+        res['tags'] = this.tags.map((x0) => x0.toJSON());
+        res['codes'] = this.codes.map((x0) => x0.toJSON());
+        res['identifier'] = this.identifier.map((x0) => x0.toJSON());
+        if (this.addressType != undefined)
+            res['addressType'] = this.addressType;
+        if (this.descr != undefined)
+            res['descr'] = this.descr;
+        if (this.street != undefined)
+            res['street'] = this.street;
+        if (this.houseNumber != undefined)
+            res['houseNumber'] = this.houseNumber;
+        if (this.postboxNumber != undefined)
+            res['postboxNumber'] = this.postboxNumber;
+        if (this.postalCode != undefined)
+            res['postalCode'] = this.postalCode;
+        if (this.city != undefined)
+            res['city'] = this.city;
+        if (this.state != undefined)
+            res['state'] = this.state;
+        if (this.country != undefined)
+            res['country'] = this.country;
+        if (this.note != undefined)
+            res['note'] = this.note;
+        res['notes'] = this.notes.map((x0) => x0.toJSON());
+        res['telecoms'] = this.telecoms.map((x0) => x0.toJSON());
+        if (this.encryptedSelf != undefined)
+            res['encryptedSelf'] = this.encryptedSelf;
+        res['isEncrypted'] = true;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['EncryptedAddress']) {
+        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 EncryptedAddress`);
+        const res = new EncryptedAddress({
+            tags: expectArray(extractEntry(jCpy, 'tags', false, path), false, [...path, ".tags"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, CodeStub.fromJSON)),
+            codes: expectArray(extractEntry(jCpy, 'codes', false, path), false, [...path, ".codes"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, CodeStub.fromJSON)),
+            identifier: expectArray(extractEntry(jCpy, 'identifier', false, path), false, [...path, ".identifier"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, Identifier.fromJSON)),
+            addressType: expectStringEnum(extractEntry(jCpy, 'addressType', false, path), true, [...path, ".addressType"], AddressType, 'AddressType'),
+            descr: expectString(extractEntry(jCpy, 'descr', false, path), true, [...path, ".descr"]),
+            street: expectString(extractEntry(jCpy, 'street', false, path), true, [...path, ".street"]),
+            houseNumber: expectString(extractEntry(jCpy, 'houseNumber', false, path), true, [...path, ".houseNumber"]),
+            postboxNumber: expectString(extractEntry(jCpy, 'postboxNumber', false, path), true, [...path, ".postboxNumber"]),
+            postalCode: expectString(extractEntry(jCpy, 'postalCode', false, path), true, [...path, ".postalCode"]),
+            city: expectString(extractEntry(jCpy, 'city', false, path), true, [...path, ".city"]),
+            state: expectString(extractEntry(jCpy, 'state', false, path), true, [...path, ".state"]),
+            country: expectString(extractEntry(jCpy, 'country', false, path), true, [...path, ".country"]),
+            note: expectString(extractEntry(jCpy, 'note', false, path), true, [...path, ".note"]),
+            notes: expectArray(extractEntry(jCpy, 'notes', false, path), false, [...path, ".notes"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, Annotation.fromJSON)),
+            telecoms: expectArray(extractEntry(jCpy, 'telecoms', false, path), false, [...path, ".telecoms"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, EncryptedTelecom.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 EncryptedAddress at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/embed/AdministrationQuantity.d.mts

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

package/model/embed/AdministrationQuantity.mjs

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

package/model/embed/AgendaSlottingAlgorithm.d.mts

@@ -4,5 +4,8 @@ export declare namespace AgendaSlottingAlgorithm {
         intervalMinutes: number;
         readonly $ktClass: 'com.icure.cardinal.sdk.model.embed.AgendaSlottingAlgorithm.FixedIntervals';
         constructor(partial: Partial<FixedIntervals> & Pick<FixedIntervals, "intervalMinutes">);
+        toJSON(): object;
+        static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): FixedIntervals;
     }
+    function fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): AgendaSlottingAlgorithm;
 }

package/model/embed/AgendaSlottingAlgorithm.mjs

@@ -1,4 +1,5 @@
 // auto-generated file
+import { expectNumber, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
 export var AgendaSlottingAlgorithm;
 (function (AgendaSlottingAlgorithm) {
     class FixedIntervals {
@@ -6,6 +7,35 @@ export var AgendaSlottingAlgorithm;
             this.$ktClass = 'com.icure.cardinal.sdk.model.embed.AgendaSlottingAlgorithm.FixedIntervals';
             this.intervalMinutes = partial.intervalMinutes;
         }
+        toJSON() {
+            const res = {};
+            res['intervalMinutes'] = this.intervalMinutes;
+            res['$ktClass'] = 'com.icure.cardinal.sdk.model.embed.AgendaSlottingAlgorithm.FixedIntervals';
+            return res;
+        }
+        static fromJSON(json, ignoreUnknownKeys = false, path = ['FixedIntervals']) {
+            if (typeof json != 'object')
+                throw new Error(`Expected json object at path ${path.join("")}`);
+            const jCpy = Object.assign({}, json);
+            if (extractEntry(jCpy, '\$ktClass', true, path) !== 'com.icure.cardinal.sdk.model.embed.AgendaSlottingAlgorithm.FixedIntervals')
+                throw new Error(`Unexpected value for ${path.join("")} class marker, should be "com.icure.cardinal.sdk.model.embed.AgendaSlottingAlgorithm.FixedIntervals". The provided json doesn't represent a FixedIntervals`);
+            const res = new FixedIntervals({
+                intervalMinutes: expectNumber(extractEntry(jCpy, 'intervalMinutes', true, path), false, true, [...path, ".intervalMinutes"]),
+            });
+            if (!ignoreUnknownKeys) {
+                const unused = Object.keys(jCpy);
+                if (unused.length > 0)
+                    throw new Error(`Unexpected key(s) for json object FixedIntervals at path ${path.join("")}: ${unused}`);
+            }
+            return res;
+        }
     }
     AgendaSlottingAlgorithm.FixedIntervals = FixedIntervals;
+    function fromJSON(json, ignoreUnknownKeys = false, path = ['AgendaSlottingAlgorithm']) {
+        switch (json.$ktClass) {
+            case 'com.icure.cardinal.sdk.model.embed.AgendaSlottingAlgorithm.FixedIntervals': return FixedIntervals.fromJSON(json, ignoreUnknownKeys);
+            default: throw new Error('Unexpected discriminator for AgendaSlottingAlgorithm: ' + json.$ktClass);
+        }
+    }
+    AgendaSlottingAlgorithm.fromJSON = fromJSON;
 })(AgendaSlottingAlgorithm || (AgendaSlottingAlgorithm = {}));

package/model/embed/AgreementAppendix.d.mts

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

package/model/embed/AgreementAppendix.mjs

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

package/model/embed/Annotation.d.mts

@@ -14,4 +14,6 @@ export declare class Annotation implements Identifiable<string> {
     tags: Array<CodeStub>;
     encryptedSelf: string | undefined;
     constructor(partial: Partial<Annotation>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): Annotation;
 }

package/model/embed/Annotation.mjs

@@ -1,5 +1,7 @@
 // auto-generated file
+import { expectArray, expectBoolean, expectMap, expectNumber, expectObject, expectString, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
 import { randomUuid } from '../../utils/Id.mjs';
+import { CodeStub } from '../base/CodeStub.mjs';
 export class Annotation {
     constructor(partial) {
         var _a;
@@ -32,4 +34,48 @@ export class Annotation {
         if ('encryptedSelf' in partial)
             this.encryptedSelf = partial.encryptedSelf;
     }
+    toJSON() {
+        const res = {};
+        res['id'] = this.id;
+        if (this.author != undefined)
+            res['author'] = this.author;
+        if (this.created != undefined)
+            res['created'] = this.created;
+        if (this.modified != undefined)
+            res['modified'] = this.modified;
+        if (this.text != undefined)
+            res['text'] = this.text;
+        res['markdown'] = Object.fromEntries(Object.entries(this.markdown).map(([k0, v0]) => [k0, v0]));
+        if (this.location != undefined)
+            res['location'] = this.location;
+        if (this.confidential != undefined)
+            res['confidential'] = this.confidential;
+        res['tags'] = this.tags.map((x0) => x0.toJSON());
+        if (this.encryptedSelf != undefined)
+            res['encryptedSelf'] = this.encryptedSelf;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['Annotation']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new Annotation({
+            id: expectString(extractEntry(jCpy, 'id', true, path), false, [...path, ".id"]),
+            author: expectString(extractEntry(jCpy, 'author', false, path), true, [...path, ".author"]),
+            created: expectNumber(extractEntry(jCpy, 'created', false, path), true, true, [...path, ".created"]),
+            modified: expectNumber(extractEntry(jCpy, 'modified', false, path), true, true, [...path, ".modified"]),
+            text: expectString(extractEntry(jCpy, 'text', false, path), true, [...path, ".text"]),
+            markdown: expectMap(extractEntry(jCpy, 'markdown', false, path), false, [...path, ".markdown"], (k0, p0) => expectString(k0, false, p0), (v0, p0) => expectString(v0, false, p0)),
+            location: expectString(extractEntry(jCpy, 'location', false, path), true, [...path, ".location"]),
+            confidential: expectBoolean(extractEntry(jCpy, 'confidential', false, path), true, [...path, ".confidential"]),
+            tags: expectArray(extractEntry(jCpy, 'tags', false, path), false, [...path, ".tags"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, 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 Annotation at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }