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

package/model/ReplicationInfo.d.mts

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

package/model/ReplicationInfo.mjs

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

package/model/Role.d.mts

@@ -7,4 +7,6 @@ export declare class Role implements StoredDocument {
     inheritableUpTo: number | undefined;
     permissions: Array<string>;
     constructor(partial: Partial<Role>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): Role;
 }

package/model/Role.mjs

@@ -1,4 +1,5 @@
 // auto-generated file
+import { expectArray, expectNumber, expectString, extractEntry } from '../internal/JsonDecodeUtils.mjs';
 import { randomUuid } from '../utils/Id.mjs';
 export class Role {
     constructor(partial) {
@@ -20,4 +21,37 @@ export class Role {
         if ('permissions' in partial && partial.permissions !== undefined)
             this.permissions = partial.permissions;
     }
+    toJSON() {
+        const res = {};
+        res['id'] = this.id;
+        if (this.rev != undefined)
+            res['rev'] = this.rev;
+        if (this.deletionDate != undefined)
+            res['deletionDate'] = this.deletionDate;
+        if (this.name != undefined)
+            res['name'] = this.name;
+        if (this.inheritableUpTo != undefined)
+            res['inheritableUpTo'] = this.inheritableUpTo;
+        res['permissions'] = this.permissions.map((x0) => x0);
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['Role']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new Role({
+            id: expectString(extractEntry(jCpy, 'id', true, path), false, [...path, ".id"]),
+            rev: expectString(extractEntry(jCpy, 'rev', false, path), true, [...path, ".rev"]),
+            deletionDate: expectNumber(extractEntry(jCpy, 'deletionDate', false, path), true, true, [...path, ".deletionDate"]),
+            name: expectString(extractEntry(jCpy, 'name', false, path), true, [...path, ".name"]),
+            inheritableUpTo: expectNumber(extractEntry(jCpy, 'inheritableUpTo', false, path), true, true, [...path, ".inheritableUpTo"]),
+            permissions: expectArray(extractEntry(jCpy, 'permissions', false, path), false, [...path, ".permissions"], (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 Role at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/StoredDocumentIdentifier.d.mts

@@ -3,4 +3,6 @@ export declare class StoredDocumentIdentifier implements Identifiable<string> {
     id: string;
     rev: string;
     constructor(partial: Partial<StoredDocumentIdentifier> & Pick<StoredDocumentIdentifier, "rev">);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): StoredDocumentIdentifier;
 }

package/model/StoredDocumentIdentifier.mjs

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

package/model/Tarification.d.mts

@@ -45,4 +45,6 @@ export declare class Tarification implements StoredDocument, CodeIdentification<
     ngroup: string | undefined;
     letterValues: Array<LetterValue>;
     constructor(partial: Partial<Tarification>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): Tarification;
 }

package/model/Tarification.mjs

@@ -1,5 +1,12 @@
 // auto-generated file
+import { expectArray, expectBoolean, expectMap, expectNumber, expectObject, expectString, expectStringEnum, extractEntry } from '../internal/JsonDecodeUtils.mjs';
 import { randomUuid } from '../utils/Id.mjs';
+import { AppendixType } from './base/AppendixType.mjs';
+import { CodeFlag } from './base/CodeFlag.mjs';
+import { LinkQualification } from './base/LinkQualification.mjs';
+import { LetterValue } from './embed/LetterValue.mjs';
+import { Periodicity } from './embed/Periodicity.mjs';
+import { DecryptedValorisation } from './embed/Valorisation.mjs';
 export class Tarification {
     constructor(partial) {
         var _a;
@@ -83,4 +90,89 @@ export class Tarification {
         if ('letterValues' in partial && partial.letterValues !== undefined)
             this.letterValues = partial.letterValues;
     }
+    toJSON() {
+        const res = {};
+        res['id'] = this.id;
+        if (this.rev != undefined)
+            res['rev'] = this.rev;
+        if (this.deletionDate != undefined)
+            res['deletionDate'] = this.deletionDate;
+        if (this.label != undefined)
+            res['label'] = Object.fromEntries(Object.entries(this.label).map(([k0, v0]) => [k0, v0]));
+        if (this.context != undefined)
+            res['context'] = this.context;
+        if (this.type != undefined)
+            res['type'] = this.type;
+        if (this.code != undefined)
+            res['code'] = this.code;
+        if (this.version != undefined)
+            res['version'] = this.version;
+        if (this.author != undefined)
+            res['author'] = this.author;
+        res['regions'] = this.regions.map((x0) => x0);
+        res['periodicity'] = this.periodicity.map((x0) => x0.toJSON());
+        if (this.level != undefined)
+            res['level'] = this.level;
+        res['links'] = this.links.map((x0) => x0);
+        res['qualifiedLinks'] = Object.fromEntries(Object.entries(this.qualifiedLinks).map(([k0, v0]) => [k0, v0.map((x1) => x1)]));
+        res['flags'] = this.flags.map((x0) => x0);
+        res['searchTerms'] = Object.fromEntries(Object.entries(this.searchTerms).map(([k0, v0]) => [k0, v0.map((x1) => x1)]));
+        if (this.data != undefined)
+            res['data'] = this.data;
+        res['appendices'] = Object.fromEntries(Object.entries(this.appendices).map(([k0, v0]) => [k0, v0]));
+        res['disabled'] = this.disabled;
+        res['valorisations'] = this.valorisations.map((x0) => x0.toJSON());
+        res['category'] = Object.fromEntries(Object.entries(this.category).map(([k0, v0]) => [k0, v0]));
+        if (this.consultationCode != undefined)
+            res['consultationCode'] = this.consultationCode;
+        if (this.hasRelatedCode != undefined)
+            res['hasRelatedCode'] = this.hasRelatedCode;
+        if (this.needsPrescriber != undefined)
+            res['needsPrescriber'] = this.needsPrescriber;
+        res['relatedCodes'] = this.relatedCodes.map((x0) => x0);
+        if (this.ngroup != undefined)
+            res['ngroup'] = this.ngroup;
+        res['letterValues'] = this.letterValues.map((x0) => x0.toJSON());
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['Tarification']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new Tarification({
+            id: expectString(extractEntry(jCpy, 'id', true, path), false, [...path, ".id"]),
+            rev: expectString(extractEntry(jCpy, 'rev', false, path), true, [...path, ".rev"]),
+            deletionDate: expectNumber(extractEntry(jCpy, 'deletionDate', false, path), true, true, [...path, ".deletionDate"]),
+            label: expectMap(extractEntry(jCpy, 'label', false, path), true, [...path, ".label"], (k0, p0) => expectString(k0, false, p0), (v0, p0) => expectString(v0, false, p0)),
+            context: expectString(extractEntry(jCpy, 'context', false, path), true, [...path, ".context"]),
+            type: expectString(extractEntry(jCpy, 'type', false, path), true, [...path, ".type"]),
+            code: expectString(extractEntry(jCpy, 'code', false, path), true, [...path, ".code"]),
+            version: expectString(extractEntry(jCpy, 'version', false, path), true, [...path, ".version"]),
+            author: expectString(extractEntry(jCpy, 'author', false, path), true, [...path, ".author"]),
+            regions: expectArray(extractEntry(jCpy, 'regions', false, path), false, [...path, ".regions"], (x0, p0) => expectString(x0, false, p0)),
+            periodicity: expectArray(extractEntry(jCpy, 'periodicity', false, path), false, [...path, ".periodicity"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, Periodicity.fromJSON)),
+            level: expectNumber(extractEntry(jCpy, 'level', false, path), true, true, [...path, ".level"]),
+            links: expectArray(extractEntry(jCpy, 'links', false, path), false, [...path, ".links"], (x0, p0) => expectString(x0, false, p0)),
+            qualifiedLinks: expectMap(extractEntry(jCpy, 'qualifiedLinks', false, path), false, [...path, ".qualifiedLinks"], (k0, p0) => expectStringEnum(k0, false, p0, LinkQualification, 'LinkQualification'), (v0, p0) => expectArray(v0, false, p0, (x1, p1) => expectString(x1, false, p1))),
+            flags: expectArray(extractEntry(jCpy, 'flags', false, path), false, [...path, ".flags"], (x0, p0) => expectStringEnum(x0, false, p0, CodeFlag, 'CodeFlag')),
+            searchTerms: expectMap(extractEntry(jCpy, 'searchTerms', false, path), false, [...path, ".searchTerms"], (k0, p0) => expectString(k0, false, p0), (v0, p0) => expectArray(v0, false, p0, (x1, p1) => expectString(x1, false, p1))),
+            data: expectString(extractEntry(jCpy, 'data', false, path), true, [...path, ".data"]),
+            appendices: expectMap(extractEntry(jCpy, 'appendices', false, path), false, [...path, ".appendices"], (k0, p0) => expectStringEnum(k0, false, p0, AppendixType, 'AppendixType'), (v0, p0) => expectString(v0, false, p0)),
+            disabled: expectBoolean(extractEntry(jCpy, 'disabled', false, path), false, [...path, ".disabled"]),
+            valorisations: expectArray(extractEntry(jCpy, 'valorisations', false, path), false, [...path, ".valorisations"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, DecryptedValorisation.fromJSON)),
+            category: expectMap(extractEntry(jCpy, 'category', false, path), false, [...path, ".category"], (k0, p0) => expectString(k0, false, p0), (v0, p0) => expectString(v0, false, p0)),
+            consultationCode: expectBoolean(extractEntry(jCpy, 'consultationCode', false, path), true, [...path, ".consultationCode"]),
+            hasRelatedCode: expectBoolean(extractEntry(jCpy, 'hasRelatedCode', false, path), true, [...path, ".hasRelatedCode"]),
+            needsPrescriber: expectBoolean(extractEntry(jCpy, 'needsPrescriber', false, path), true, [...path, ".needsPrescriber"]),
+            relatedCodes: expectArray(extractEntry(jCpy, 'relatedCodes', false, path), false, [...path, ".relatedCodes"], (x0, p0) => expectString(x0, false, p0)),
+            ngroup: expectString(extractEntry(jCpy, 'ngroup', false, path), true, [...path, ".ngroup"]),
+            letterValues: expectArray(extractEntry(jCpy, 'letterValues', false, path), false, [...path, ".letterValues"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, LetterValue.fromJSON)),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object Tarification at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/TimeTable.d.mts

@@ -20,4 +20,6 @@ export declare class TimeTable implements StoredDocument, ICureDocument<string>
     endTime: number | undefined;
     items: Array<TimeTableItem>;
     constructor(partial: Partial<TimeTable>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): TimeTable;
 }

package/model/TimeTable.mjs

@@ -1,5 +1,8 @@
 // auto-generated file
+import { expectArray, expectNumber, expectObject, expectString, extractEntry } from '../internal/JsonDecodeUtils.mjs';
 import { randomUuid } from '../utils/Id.mjs';
+import { CodeStub } from './base/CodeStub.mjs';
+import { TimeTableItem } from './embed/TimeTableItem.mjs';
 export class TimeTable {
     constructor(partial) {
         var _a;
@@ -50,4 +53,65 @@ export class TimeTable {
         if ('items' in partial && partial.items !== undefined)
             this.items = partial.items;
     }
+    toJSON() {
+        const res = {};
+        res['id'] = this.id;
+        if (this.rev != undefined)
+            res['rev'] = this.rev;
+        if (this.created != undefined)
+            res['created'] = this.created;
+        if (this.modified != undefined)
+            res['modified'] = this.modified;
+        if (this.author != undefined)
+            res['author'] = this.author;
+        if (this.responsible != undefined)
+            res['responsible'] = this.responsible;
+        if (this.medicalLocationId != undefined)
+            res['medicalLocationId'] = this.medicalLocationId;
+        res['tags'] = this.tags.map((x0) => x0.toJSON());
+        res['codes'] = this.codes.map((x0) => x0.toJSON());
+        if (this.endOfLife != undefined)
+            res['endOfLife'] = this.endOfLife;
+        if (this.deletionDate != undefined)
+            res['deletionDate'] = this.deletionDate;
+        if (this.name != undefined)
+            res['name'] = this.name;
+        if (this.agendaId != undefined)
+            res['agendaId'] = this.agendaId;
+        if (this.startTime != undefined)
+            res['startTime'] = this.startTime;
+        if (this.endTime != undefined)
+            res['endTime'] = this.endTime;
+        res['items'] = this.items.map((x0) => x0.toJSON());
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['TimeTable']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new TimeTable({
+            id: expectString(extractEntry(jCpy, 'id', true, path), false, [...path, ".id"]),
+            rev: expectString(extractEntry(jCpy, 'rev', false, path), true, [...path, ".rev"]),
+            created: expectNumber(extractEntry(jCpy, 'created', false, path), true, true, [...path, ".created"]),
+            modified: expectNumber(extractEntry(jCpy, 'modified', false, path), true, true, [...path, ".modified"]),
+            author: expectString(extractEntry(jCpy, 'author', false, path), true, [...path, ".author"]),
+            responsible: expectString(extractEntry(jCpy, 'responsible', false, path), true, [...path, ".responsible"]),
+            medicalLocationId: expectString(extractEntry(jCpy, 'medicalLocationId', false, path), true, [...path, ".medicalLocationId"]),
+            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)),
+            endOfLife: expectNumber(extractEntry(jCpy, 'endOfLife', false, path), true, true, [...path, ".endOfLife"]),
+            deletionDate: expectNumber(extractEntry(jCpy, 'deletionDate', false, path), true, true, [...path, ".deletionDate"]),
+            name: expectString(extractEntry(jCpy, 'name', false, path), true, [...path, ".name"]),
+            agendaId: expectString(extractEntry(jCpy, 'agendaId', false, path), true, [...path, ".agendaId"]),
+            startTime: expectNumber(extractEntry(jCpy, 'startTime', false, path), true, true, [...path, ".startTime"]),
+            endTime: expectNumber(extractEntry(jCpy, 'endTime', false, path), true, true, [...path, ".endTime"]),
+            items: expectArray(extractEntry(jCpy, 'items', false, path), false, [...path, ".items"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, TimeTableItem.fromJSON)),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object TimeTable at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/Topic.d.mts

@@ -17,6 +17,7 @@ export interface Topic extends StoredDocument, ICureDocument<string>, HasEncrypt
     linkedHealthElements: Array<string>;
     linkedServices: Array<string>;
     readonly isEncrypted: boolean;
+    toJSON(): object;
 }
 export declare class DecryptedTopic {
     id: string;
@@ -52,6 +53,8 @@ export declare class DecryptedTopic {
     linkedServices: Array<string>;
     readonly isEncrypted: false;
     constructor(partial: Partial<DecryptedTopic>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): DecryptedTopic;
 }
 export declare class EncryptedTopic {
     id: string;
@@ -87,4 +90,6 @@ export declare class EncryptedTopic {
     linkedServices: Array<string>;
     readonly isEncrypted: true;
     constructor(partial: Partial<EncryptedTopic>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): EncryptedTopic;
 }

package/model/Topic.mjs

@@ -1,5 +1,10 @@
 // auto-generated file
+import { expectArray, expectMap, expectNumber, expectObject, expectString, expectStringEnum, extractEntry } from '../internal/JsonDecodeUtils.mjs';
 import { randomUuid } from '../utils/Id.mjs';
+import { TopicRole } from './TopicRole.mjs';
+import { CodeStub } from './base/CodeStub.mjs';
+import { Delegation } from './embed/Delegation.mjs';
+import { SecurityMetadata } from './embed/SecurityMetadata.mjs';
 export class DecryptedTopic {
     constructor(partial) {
         var _a;
@@ -74,6 +79,85 @@ export class DecryptedTopic {
         if ('linkedServices' in partial && partial.linkedServices !== undefined)
             this.linkedServices = partial.linkedServices;
     }
+    toJSON() {
+        const res = {};
+        res['id'] = this.id;
+        if (this.rev != undefined)
+            res['rev'] = this.rev;
+        if (this.created != undefined)
+            res['created'] = this.created;
+        if (this.modified != undefined)
+            res['modified'] = this.modified;
+        if (this.healthElementId != undefined)
+            res['healthElementId'] = this.healthElementId;
+        if (this.contactId != undefined)
+            res['contactId'] = this.contactId;
+        if (this.description != undefined)
+            res['description'] = this.description;
+        res['codes'] = this.codes.map((x0) => x0.toJSON());
+        res['tags'] = this.tags.map((x0) => x0.toJSON());
+        if (this.author != undefined)
+            res['author'] = this.author;
+        if (this.responsible != undefined)
+            res['responsible'] = this.responsible;
+        if (this.medicalLocationId != undefined)
+            res['medicalLocationId'] = this.medicalLocationId;
+        if (this.endOfLife != undefined)
+            res['endOfLife'] = this.endOfLife;
+        if (this.deletionDate != undefined)
+            res['deletionDate'] = this.deletionDate;
+        res['activeParticipants'] = Object.fromEntries(Object.entries(this.activeParticipants).map(([k0, v0]) => [k0, v0]));
+        if (this.securityMetadata != undefined)
+            res['securityMetadata'] = this.securityMetadata.toJSON();
+        res['secretForeignKeys'] = this.secretForeignKeys.map((x0) => x0);
+        res['cryptedForeignKeys'] = Object.fromEntries(Object.entries(this.cryptedForeignKeys).map(([k0, v0]) => [k0, v0.map((x1) => x1.toJSON())]));
+        res['delegations'] = Object.fromEntries(Object.entries(this.delegations).map(([k0, v0]) => [k0, v0.map((x1) => x1.toJSON())]));
+        res['encryptionKeys'] = Object.fromEntries(Object.entries(this.encryptionKeys).map(([k0, v0]) => [k0, v0.map((x1) => x1.toJSON())]));
+        if (this.encryptedSelf != undefined)
+            res['encryptedSelf'] = this.encryptedSelf;
+        res['linkedHealthElements'] = this.linkedHealthElements.map((x0) => x0);
+        res['linkedServices'] = this.linkedServices.map((x0) => x0);
+        res['isEncrypted'] = false;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['DecryptedTopic']) {
+        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 DecryptedTopic`);
+        const res = new DecryptedTopic({
+            id: expectString(extractEntry(jCpy, 'id', true, path), false, [...path, ".id"]),
+            rev: expectString(extractEntry(jCpy, 'rev', false, path), true, [...path, ".rev"]),
+            created: expectNumber(extractEntry(jCpy, 'created', false, path), true, true, [...path, ".created"]),
+            modified: expectNumber(extractEntry(jCpy, 'modified', false, path), true, true, [...path, ".modified"]),
+            healthElementId: expectString(extractEntry(jCpy, 'healthElementId', false, path), true, [...path, ".healthElementId"]),
+            contactId: expectString(extractEntry(jCpy, 'contactId', false, path), true, [...path, ".contactId"]),
+            description: expectString(extractEntry(jCpy, 'description', false, path), true, [...path, ".description"]),
+            codes: expectArray(extractEntry(jCpy, 'codes', false, path), false, [...path, ".codes"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, CodeStub.fromJSON)),
+            tags: expectArray(extractEntry(jCpy, 'tags', false, path), false, [...path, ".tags"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, CodeStub.fromJSON)),
+            author: expectString(extractEntry(jCpy, 'author', false, path), true, [...path, ".author"]),
+            responsible: expectString(extractEntry(jCpy, 'responsible', false, path), true, [...path, ".responsible"]),
+            medicalLocationId: expectString(extractEntry(jCpy, 'medicalLocationId', false, path), true, [...path, ".medicalLocationId"]),
+            endOfLife: expectNumber(extractEntry(jCpy, 'endOfLife', false, path), true, true, [...path, ".endOfLife"]),
+            deletionDate: expectNumber(extractEntry(jCpy, 'deletionDate', false, path), true, true, [...path, ".deletionDate"]),
+            activeParticipants: expectMap(extractEntry(jCpy, 'activeParticipants', false, path), false, [...path, ".activeParticipants"], (k0, p0) => expectString(k0, false, p0), (v0, p0) => expectStringEnum(v0, false, p0, TopicRole, 'TopicRole')),
+            securityMetadata: expectObject(extractEntry(jCpy, 'securityMetadata', false, path), true, ignoreUnknownKeys, [...path, ".securityMetadata"], SecurityMetadata.fromJSON),
+            secretForeignKeys: expectArray(extractEntry(jCpy, 'secretForeignKeys', false, path), false, [...path, ".secretForeignKeys"], (x0, p0) => expectString(x0, false, p0)),
+            cryptedForeignKeys: expectMap(extractEntry(jCpy, 'cryptedForeignKeys', false, path), false, [...path, ".cryptedForeignKeys"], (k0, p0) => expectString(k0, false, p0), (v0, p0) => expectArray(v0, false, p0, (x1, p1) => expectObject(x1, false, ignoreUnknownKeys, p1, Delegation.fromJSON))),
+            delegations: expectMap(extractEntry(jCpy, 'delegations', false, path), false, [...path, ".delegations"], (k0, p0) => expectString(k0, false, p0), (v0, p0) => expectArray(v0, false, p0, (x1, p1) => expectObject(x1, false, ignoreUnknownKeys, p1, Delegation.fromJSON))),
+            encryptionKeys: expectMap(extractEntry(jCpy, 'encryptionKeys', false, path), false, [...path, ".encryptionKeys"], (k0, p0) => expectString(k0, false, p0), (v0, p0) => expectArray(v0, false, p0, (x1, p1) => expectObject(x1, false, ignoreUnknownKeys, p1, Delegation.fromJSON))),
+            encryptedSelf: expectString(extractEntry(jCpy, 'encryptedSelf', false, path), true, [...path, ".encryptedSelf"]),
+            linkedHealthElements: expectArray(extractEntry(jCpy, 'linkedHealthElements', false, path), false, [...path, ".linkedHealthElements"], (x0, p0) => expectString(x0, false, p0)),
+            linkedServices: expectArray(extractEntry(jCpy, 'linkedServices', false, path), false, [...path, ".linkedServices"], (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 DecryptedTopic at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }
 export class EncryptedTopic {
     constructor(partial) {
@@ -149,4 +233,83 @@ export class EncryptedTopic {
         if ('linkedServices' in partial && partial.linkedServices !== undefined)
             this.linkedServices = partial.linkedServices;
     }
+    toJSON() {
+        const res = {};
+        res['id'] = this.id;
+        if (this.rev != undefined)
+            res['rev'] = this.rev;
+        if (this.created != undefined)
+            res['created'] = this.created;
+        if (this.modified != undefined)
+            res['modified'] = this.modified;
+        if (this.healthElementId != undefined)
+            res['healthElementId'] = this.healthElementId;
+        if (this.contactId != undefined)
+            res['contactId'] = this.contactId;
+        if (this.description != undefined)
+            res['description'] = this.description;
+        res['codes'] = this.codes.map((x0) => x0.toJSON());
+        res['tags'] = this.tags.map((x0) => x0.toJSON());
+        if (this.author != undefined)
+            res['author'] = this.author;
+        if (this.responsible != undefined)
+            res['responsible'] = this.responsible;
+        if (this.medicalLocationId != undefined)
+            res['medicalLocationId'] = this.medicalLocationId;
+        if (this.endOfLife != undefined)
+            res['endOfLife'] = this.endOfLife;
+        if (this.deletionDate != undefined)
+            res['deletionDate'] = this.deletionDate;
+        res['activeParticipants'] = Object.fromEntries(Object.entries(this.activeParticipants).map(([k0, v0]) => [k0, v0]));
+        if (this.securityMetadata != undefined)
+            res['securityMetadata'] = this.securityMetadata.toJSON();
+        res['secretForeignKeys'] = this.secretForeignKeys.map((x0) => x0);
+        res['cryptedForeignKeys'] = Object.fromEntries(Object.entries(this.cryptedForeignKeys).map(([k0, v0]) => [k0, v0.map((x1) => x1.toJSON())]));
+        res['delegations'] = Object.fromEntries(Object.entries(this.delegations).map(([k0, v0]) => [k0, v0.map((x1) => x1.toJSON())]));
+        res['encryptionKeys'] = Object.fromEntries(Object.entries(this.encryptionKeys).map(([k0, v0]) => [k0, v0.map((x1) => x1.toJSON())]));
+        if (this.encryptedSelf != undefined)
+            res['encryptedSelf'] = this.encryptedSelf;
+        res['linkedHealthElements'] = this.linkedHealthElements.map((x0) => x0);
+        res['linkedServices'] = this.linkedServices.map((x0) => x0);
+        res['isEncrypted'] = true;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['EncryptedTopic']) {
+        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 EncryptedTopic`);
+        const res = new EncryptedTopic({
+            id: expectString(extractEntry(jCpy, 'id', true, path), false, [...path, ".id"]),
+            rev: expectString(extractEntry(jCpy, 'rev', false, path), true, [...path, ".rev"]),
+            created: expectNumber(extractEntry(jCpy, 'created', false, path), true, true, [...path, ".created"]),
+            modified: expectNumber(extractEntry(jCpy, 'modified', false, path), true, true, [...path, ".modified"]),
+            healthElementId: expectString(extractEntry(jCpy, 'healthElementId', false, path), true, [...path, ".healthElementId"]),
+            contactId: expectString(extractEntry(jCpy, 'contactId', false, path), true, [...path, ".contactId"]),
+            description: expectString(extractEntry(jCpy, 'description', false, path), true, [...path, ".description"]),
+            codes: expectArray(extractEntry(jCpy, 'codes', false, path), false, [...path, ".codes"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, CodeStub.fromJSON)),
+            tags: expectArray(extractEntry(jCpy, 'tags', false, path), false, [...path, ".tags"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, CodeStub.fromJSON)),
+            author: expectString(extractEntry(jCpy, 'author', false, path), true, [...path, ".author"]),
+            responsible: expectString(extractEntry(jCpy, 'responsible', false, path), true, [...path, ".responsible"]),
+            medicalLocationId: expectString(extractEntry(jCpy, 'medicalLocationId', false, path), true, [...path, ".medicalLocationId"]),
+            endOfLife: expectNumber(extractEntry(jCpy, 'endOfLife', false, path), true, true, [...path, ".endOfLife"]),
+            deletionDate: expectNumber(extractEntry(jCpy, 'deletionDate', false, path), true, true, [...path, ".deletionDate"]),
+            activeParticipants: expectMap(extractEntry(jCpy, 'activeParticipants', false, path), false, [...path, ".activeParticipants"], (k0, p0) => expectString(k0, false, p0), (v0, p0) => expectStringEnum(v0, false, p0, TopicRole, 'TopicRole')),
+            securityMetadata: expectObject(extractEntry(jCpy, 'securityMetadata', false, path), true, ignoreUnknownKeys, [...path, ".securityMetadata"], SecurityMetadata.fromJSON),
+            secretForeignKeys: expectArray(extractEntry(jCpy, 'secretForeignKeys', false, path), false, [...path, ".secretForeignKeys"], (x0, p0) => expectString(x0, false, p0)),
+            cryptedForeignKeys: expectMap(extractEntry(jCpy, 'cryptedForeignKeys', false, path), false, [...path, ".cryptedForeignKeys"], (k0, p0) => expectString(k0, false, p0), (v0, p0) => expectArray(v0, false, p0, (x1, p1) => expectObject(x1, false, ignoreUnknownKeys, p1, Delegation.fromJSON))),
+            delegations: expectMap(extractEntry(jCpy, 'delegations', false, path), false, [...path, ".delegations"], (k0, p0) => expectString(k0, false, p0), (v0, p0) => expectArray(v0, false, p0, (x1, p1) => expectObject(x1, false, ignoreUnknownKeys, p1, Delegation.fromJSON))),
+            encryptionKeys: expectMap(extractEntry(jCpy, 'encryptionKeys', false, path), false, [...path, ".encryptionKeys"], (k0, p0) => expectString(k0, false, p0), (v0, p0) => expectArray(v0, false, p0, (x1, p1) => expectObject(x1, false, ignoreUnknownKeys, p1, Delegation.fromJSON))),
+            encryptedSelf: expectString(extractEntry(jCpy, 'encryptedSelf', false, path), true, [...path, ".encryptedSelf"]),
+            linkedHealthElements: expectArray(extractEntry(jCpy, 'linkedHealthElements', false, path), false, [...path, ".linkedHealthElements"], (x0, p0) => expectString(x0, false, p0)),
+            linkedServices: expectArray(extractEntry(jCpy, 'linkedServices', false, path), false, [...path, ".linkedServices"], (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 EncryptedTopic at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/User.d.mts

@@ -40,6 +40,8 @@ export declare class User implements StoredDocument {
     };
     systemMetadata: User.SystemMetadata | undefined;
     constructor(partial: Partial<User>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): User;
 }
 export declare namespace User {
     class SystemMetadata {
@@ -48,5 +50,7 @@ export declare namespace User {
         inheritsRoles: boolean;
         loginIdentifiers: Array<LoginIdentifier>;
         constructor(partial: Partial<SystemMetadata> & Pick<SystemMetadata, "roles" | "isAdmin" | "inheritsRoles">);
+        toJSON(): object;
+        static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): SystemMetadata;
     }
 }