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

package/model/Place.mjs

@@ -1,5 +1,7 @@
 // auto-generated file
+import { expectNumber, expectObject, expectString, extractEntry } from '../internal/JsonDecodeUtils.mjs';
 import { randomUuid } from '../utils/Id.mjs';
+import { DecryptedAddress } from './embed/Address.mjs';
 export class Place {
     constructor(partial) {
         var _a;
@@ -17,4 +19,35 @@ export class Place {
         if ('address' in partial)
             this.address = partial.address;
     }
+    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.address != undefined)
+            res['address'] = this.address.toJSON();
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['Place']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new Place({
+            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"]),
+            address: expectObject(extractEntry(jCpy, 'address', false, path), true, ignoreUnknownKeys, [...path, ".address"], DecryptedAddress.fromJSON),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object Place at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/PropertyStub.d.mts

@@ -8,6 +8,7 @@ export interface PropertyStub extends Encryptable {
     typedValue: TypedValue | undefined;
     deletionDate: number | undefined;
     readonly isEncrypted: boolean;
+    toJSON(): object;
 }
 export declare class DecryptedPropertyStub {
     id: string | undefined;
@@ -17,6 +18,8 @@ export declare class DecryptedPropertyStub {
     encryptedSelf: Base64String | undefined;
     readonly isEncrypted: false;
     constructor(partial: Partial<DecryptedPropertyStub>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): DecryptedPropertyStub;
 }
 export declare class EncryptedPropertyStub {
     id: string | undefined;
@@ -26,4 +29,6 @@ export declare class EncryptedPropertyStub {
     encryptedSelf: Base64String | undefined;
     readonly isEncrypted: true;
     constructor(partial: Partial<EncryptedPropertyStub>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): EncryptedPropertyStub;
 }

package/model/PropertyStub.mjs

@@ -1,3 +1,7 @@
+// auto-generated file
+import { expectNumber, expectObject, expectString, extractEntry } from '../internal/JsonDecodeUtils.mjs';
+import { PropertyTypeStub } from './PropertyTypeStub.mjs';
+import { DecryptedTypedValue, EncryptedTypedValue } from './embed/TypedValue.mjs';
 export class DecryptedPropertyStub {
     constructor(partial) {
         this.id = undefined;
@@ -19,6 +23,41 @@ export class DecryptedPropertyStub {
         if ('encryptedSelf' in partial)
             this.encryptedSelf = partial.encryptedSelf;
     }
+    toJSON() {
+        const res = {};
+        if (this.id != undefined)
+            res['id'] = this.id;
+        if (this.type != undefined)
+            res['type'] = this.type.toJSON();
+        if (this.typedValue != undefined)
+            res['typedValue'] = this.typedValue.toJSON();
+        if (this.deletionDate != undefined)
+            res['deletionDate'] = this.deletionDate;
+        if (this.encryptedSelf != undefined)
+            res['encryptedSelf'] = this.encryptedSelf;
+        res['isEncrypted'] = false;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['DecryptedPropertyStub']) {
+        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 DecryptedPropertyStub`);
+        const res = new DecryptedPropertyStub({
+            id: expectString(extractEntry(jCpy, 'id', false, path), true, [...path, ".id"]),
+            type: expectObject(extractEntry(jCpy, 'type', false, path), true, ignoreUnknownKeys, [...path, ".type"], PropertyTypeStub.fromJSON),
+            typedValue: expectObject(extractEntry(jCpy, 'typedValue', false, path), true, ignoreUnknownKeys, [...path, ".typedValue"], DecryptedTypedValue.fromJSON),
+            deletionDate: expectNumber(extractEntry(jCpy, 'deletionDate', false, path), true, true, [...path, ".deletionDate"]),
+            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 DecryptedPropertyStub at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }
 export class EncryptedPropertyStub {
     constructor(partial) {
@@ -41,4 +80,39 @@ export class EncryptedPropertyStub {
         if ('encryptedSelf' in partial)
             this.encryptedSelf = partial.encryptedSelf;
     }
+    toJSON() {
+        const res = {};
+        if (this.id != undefined)
+            res['id'] = this.id;
+        if (this.type != undefined)
+            res['type'] = this.type.toJSON();
+        if (this.typedValue != undefined)
+            res['typedValue'] = this.typedValue.toJSON();
+        if (this.deletionDate != undefined)
+            res['deletionDate'] = this.deletionDate;
+        if (this.encryptedSelf != undefined)
+            res['encryptedSelf'] = this.encryptedSelf;
+        res['isEncrypted'] = true;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['EncryptedPropertyStub']) {
+        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 EncryptedPropertyStub`);
+        const res = new EncryptedPropertyStub({
+            id: expectString(extractEntry(jCpy, 'id', false, path), true, [...path, ".id"]),
+            type: expectObject(extractEntry(jCpy, 'type', false, path), true, ignoreUnknownKeys, [...path, ".type"], PropertyTypeStub.fromJSON),
+            typedValue: expectObject(extractEntry(jCpy, 'typedValue', false, path), true, ignoreUnknownKeys, [...path, ".typedValue"], EncryptedTypedValue.fromJSON),
+            deletionDate: expectNumber(extractEntry(jCpy, 'deletionDate', false, path), true, true, [...path, ".deletionDate"]),
+            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 EncryptedPropertyStub at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/PropertyTypeStub.d.mts

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

package/model/PropertyTypeStub.mjs

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

package/model/PublicAgendasAndCalendarItemTypes.d.mts

@@ -4,4 +4,6 @@ export declare class PublicAgendasAndCalendarItemTypes {
     agendas: Array<Agenda>;
     calendarItemTypes: Array<CalendarItemType>;
     constructor(partial: Partial<PublicAgendasAndCalendarItemTypes> & Pick<PublicAgendasAndCalendarItemTypes, "agendas" | "calendarItemTypes">);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): PublicAgendasAndCalendarItemTypes;
 }

package/model/PublicAgendasAndCalendarItemTypes.mjs

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

package/model/PublicKey.d.mts

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

package/model/PublicKey.mjs

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

package/model/Receipt.d.mts

@@ -16,6 +16,7 @@ export interface Receipt extends StoredDocument, ICureDocument<string>, HasEncry
     category: string | undefined;
     subCategory: string | undefined;
     readonly isEncrypted: boolean;
+    toJSON(): object;
 }
 export declare class DecryptedReceipt {
     id: string;
@@ -50,6 +51,8 @@ export declare class DecryptedReceipt {
     securityMetadata: SecurityMetadata | undefined;
     readonly isEncrypted: false;
     constructor(partial: Partial<DecryptedReceipt>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): DecryptedReceipt;
 }
 export declare class EncryptedReceipt {
     id: string;
@@ -84,4 +87,6 @@ export declare class EncryptedReceipt {
     securityMetadata: SecurityMetadata | undefined;
     readonly isEncrypted: true;
     constructor(partial: Partial<EncryptedReceipt>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): EncryptedReceipt;
 }

package/model/Receipt.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 { CodeStub } from './base/CodeStub.mjs';
+import { Delegation } from './embed/Delegation.mjs';
+import { ReceiptBlobType } from './embed/ReceiptBlobType.mjs';
+import { SecurityMetadata } from './embed/SecurityMetadata.mjs';
 export class DecryptedReceipt {
     constructor(partial) {
         var _a;
@@ -71,6 +76,83 @@ export class DecryptedReceipt {
         if ('securityMetadata' in partial)
             this.securityMetadata = partial.securityMetadata;
     }
+    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;
+        res['attachmentIds'] = Object.fromEntries(Object.entries(this.attachmentIds).map(([k0, v0]) => [k0, v0]));
+        res['references'] = this.references.map((x0) => x0);
+        if (this.documentId != undefined)
+            res['documentId'] = this.documentId;
+        if (this.category != undefined)
+            res['category'] = this.category;
+        if (this.subCategory != undefined)
+            res['subCategory'] = this.subCategory;
+        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;
+        if (this.securityMetadata != undefined)
+            res['securityMetadata'] = this.securityMetadata.toJSON();
+        res['isEncrypted'] = false;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['DecryptedReceipt']) {
+        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 DecryptedReceipt`);
+        const res = new DecryptedReceipt({
+            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"]),
+            attachmentIds: expectMap(extractEntry(jCpy, 'attachmentIds', false, path), false, [...path, ".attachmentIds"], (k0, p0) => expectStringEnum(k0, false, p0, ReceiptBlobType, 'ReceiptBlobType'), (v0, p0) => expectString(v0, false, p0)),
+            references: expectArray(extractEntry(jCpy, 'references', false, path), false, [...path, ".references"], (x0, p0) => expectString(x0, false, p0)),
+            documentId: expectString(extractEntry(jCpy, 'documentId', false, path), true, [...path, ".documentId"]),
+            category: expectString(extractEntry(jCpy, 'category', false, path), true, [...path, ".category"]),
+            subCategory: expectString(extractEntry(jCpy, 'subCategory', false, path), true, [...path, ".subCategory"]),
+            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"]),
+            securityMetadata: expectObject(extractEntry(jCpy, 'securityMetadata', false, path), true, ignoreUnknownKeys, [...path, ".securityMetadata"], SecurityMetadata.fromJSON),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object DecryptedReceipt at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }
 export class EncryptedReceipt {
     constructor(partial) {
@@ -143,4 +225,81 @@ export class EncryptedReceipt {
         if ('securityMetadata' in partial)
             this.securityMetadata = partial.securityMetadata;
     }
+    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;
+        res['attachmentIds'] = Object.fromEntries(Object.entries(this.attachmentIds).map(([k0, v0]) => [k0, v0]));
+        res['references'] = this.references.map((x0) => x0);
+        if (this.documentId != undefined)
+            res['documentId'] = this.documentId;
+        if (this.category != undefined)
+            res['category'] = this.category;
+        if (this.subCategory != undefined)
+            res['subCategory'] = this.subCategory;
+        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;
+        if (this.securityMetadata != undefined)
+            res['securityMetadata'] = this.securityMetadata.toJSON();
+        res['isEncrypted'] = true;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['EncryptedReceipt']) {
+        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 EncryptedReceipt`);
+        const res = new EncryptedReceipt({
+            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"]),
+            attachmentIds: expectMap(extractEntry(jCpy, 'attachmentIds', false, path), false, [...path, ".attachmentIds"], (k0, p0) => expectStringEnum(k0, false, p0, ReceiptBlobType, 'ReceiptBlobType'), (v0, p0) => expectString(v0, false, p0)),
+            references: expectArray(extractEntry(jCpy, 'references', false, path), false, [...path, ".references"], (x0, p0) => expectString(x0, false, p0)),
+            documentId: expectString(extractEntry(jCpy, 'documentId', false, path), true, [...path, ".documentId"]),
+            category: expectString(extractEntry(jCpy, 'category', false, path), true, [...path, ".category"]),
+            subCategory: expectString(extractEntry(jCpy, 'subCategory', false, path), true, [...path, ".subCategory"]),
+            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"]),
+            securityMetadata: expectObject(extractEntry(jCpy, 'securityMetadata', false, path), true, ignoreUnknownKeys, [...path, ".securityMetadata"], SecurityMetadata.fromJSON),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object EncryptedReceipt at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/RegistrationInformation.d.mts

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

package/model/RegistrationInformation.mjs

@@ -1,4 +1,5 @@
 // auto-generated file
+import { expectArray, expectString, extractEntry } from '../internal/JsonDecodeUtils.mjs';
 export class RegistrationInformation {
     constructor(partial) {
         this.applicationId = undefined;
@@ -27,4 +28,46 @@ export class RegistrationInformation {
         if ('cluster' in partial)
             this.cluster = partial.cluster;
     }
+    toJSON() {
+        const res = {};
+        if (this.applicationId != undefined)
+            res['applicationId'] = this.applicationId;
+        if (this.firstName != undefined)
+            res['firstName'] = this.firstName;
+        if (this.lastName != undefined)
+            res['lastName'] = this.lastName;
+        if (this.companyName != undefined)
+            res['companyName'] = this.companyName;
+        res['emailAddress'] = this.emailAddress;
+        if (this.userOptions != undefined)
+            res['userOptions'] = this.userOptions;
+        res['userRoles'] = this.userRoles.map((x0) => x0);
+        if (this.minimumKrakenVersion != undefined)
+            res['minimumKrakenVersion'] = this.minimumKrakenVersion;
+        if (this.cluster != undefined)
+            res['cluster'] = this.cluster;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['RegistrationInformation']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new RegistrationInformation({
+            applicationId: expectString(extractEntry(jCpy, 'applicationId', false, path), true, [...path, ".applicationId"]),
+            firstName: expectString(extractEntry(jCpy, 'firstName', false, path), true, [...path, ".firstName"]),
+            lastName: expectString(extractEntry(jCpy, 'lastName', false, path), true, [...path, ".lastName"]),
+            companyName: expectString(extractEntry(jCpy, 'companyName', false, path), true, [...path, ".companyName"]),
+            emailAddress: expectString(extractEntry(jCpy, 'emailAddress', true, path), false, [...path, ".emailAddress"]),
+            userOptions: expectString(extractEntry(jCpy, 'userOptions', false, path), true, [...path, ".userOptions"]),
+            userRoles: expectArray(extractEntry(jCpy, 'userRoles', false, path), false, [...path, ".userRoles"], (x0, p0) => expectString(x0, false, p0)),
+            minimumKrakenVersion: expectString(extractEntry(jCpy, 'minimumKrakenVersion', false, path), true, [...path, ".minimumKrakenVersion"]),
+            cluster: expectString(extractEntry(jCpy, 'cluster', false, path), true, [...path, ".cluster"]),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object RegistrationInformation at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/RegistrationSuccess.d.mts

@@ -3,4 +3,6 @@ export declare class RegistrationSuccess {
     userId: string;
     token: string;
     constructor(partial: Partial<RegistrationSuccess> & Pick<RegistrationSuccess, "groupId" | "userId" | "token">);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): RegistrationSuccess;
 }

package/model/RegistrationSuccess.mjs

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

package/model/Replication.d.mts

@@ -10,4 +10,6 @@ export declare class Replication implements StoredDocument, Identifiable<string>
     context: string | undefined;
     databaseSynchronizations: Array<DatabaseSynchronization>;
     constructor(partial: Partial<Replication>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): Replication;
 }

package/model/Replication.mjs

@@ -1,5 +1,7 @@
 // auto-generated file
+import { expectArray, expectNumber, expectObject, expectString, extractEntry } from '../internal/JsonDecodeUtils.mjs';
 import { randomUuid } from '../utils/Id.mjs';
+import { DatabaseSynchronization } from './embed/DatabaseSynchronization.mjs';
 export class Replication {
     constructor(partial) {
         var _a;
@@ -20,4 +22,37 @@ export class Replication {
         if ('databaseSynchronizations' in partial && partial.databaseSynchronizations !== undefined)
             this.databaseSynchronizations = partial.databaseSynchronizations;
     }
+    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.context != undefined)
+            res['context'] = this.context;
+        res['databaseSynchronizations'] = this.databaseSynchronizations.map((x0) => x0.toJSON());
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['Replication']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new Replication({
+            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"]),
+            context: expectString(extractEntry(jCpy, 'context', false, path), true, [...path, ".context"]),
+            databaseSynchronizations: expectArray(extractEntry(jCpy, 'databaseSynchronizations', false, path), false, [...path, ".databaseSynchronizations"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, DatabaseSynchronization.fromJSON)),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object Replication at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }