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

package/model/User.mjs

@@ -1,5 +1,14 @@
 // auto-generated file
+import { expectArray, expectBoolean, expectMap, expectNumber, expectObject, expectString, expectStringEnum, extractEntry } from '../internal/JsonDecodeUtils.mjs';
 import { randomUuid } from '../utils/Id.mjs';
+import { DecryptedPropertyStub } from './PropertyStub.mjs';
+import { Identifier } from './base/Identifier.mjs';
+import { DelegationTag } from './embed/DelegationTag.mjs';
+import { UsersStatus } from './enums/UsersStatus.mjs';
+import { UsersType } from './enums/UsersType.mjs';
+import { AuthenticationToken } from './security/AuthenticationToken.mjs';
+import { LoginIdentifier } from './security/LoginIdentifier.mjs';
+import { Permission } from './security/Permission.mjs';
 export class User {
     constructor(partial) {
         var _a;
@@ -77,6 +86,90 @@ export class User {
         if ('systemMetadata' in partial)
             this.systemMetadata = partial.systemMetadata;
     }
+    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.created != undefined)
+            res['created'] = this.created;
+        res['identifier'] = this.identifier.map((x0) => x0.toJSON());
+        if (this.name != undefined)
+            res['name'] = this.name;
+        res['properties'] = this.properties.map((x0) => x0.toJSON());
+        res['permissions'] = this.permissions.map((x0) => x0.toJSON());
+        res['roles'] = this.roles.map((x0) => x0);
+        if (this.type != undefined)
+            res['type'] = this.type;
+        if (this.status != undefined)
+            res['status'] = this.status;
+        if (this.login != undefined)
+            res['login'] = this.login;
+        if (this.passwordHash != undefined)
+            res['passwordHash'] = this.passwordHash;
+        if (this.groupId != undefined)
+            res['groupId'] = this.groupId;
+        if (this.healthcarePartyId != undefined)
+            res['healthcarePartyId'] = this.healthcarePartyId;
+        if (this.patientId != undefined)
+            res['patientId'] = this.patientId;
+        if (this.deviceId != undefined)
+            res['deviceId'] = this.deviceId;
+        res['autoDelegations'] = Object.fromEntries(Object.entries(this.autoDelegations).map(([k0, v0]) => [k0, v0.map((x1) => x1)]));
+        if (this.createdDate != undefined)
+            res['createdDate'] = this.createdDate;
+        if (this.termsOfUseDate != undefined)
+            res['termsOfUseDate'] = this.termsOfUseDate;
+        if (this.email != undefined)
+            res['email'] = this.email;
+        if (this.mobilePhone != undefined)
+            res['mobilePhone'] = this.mobilePhone;
+        res['applicationTokens'] = Object.fromEntries(Object.entries(this.applicationTokens).map(([k0, v0]) => [k0, v0]));
+        res['authenticationTokens'] = Object.fromEntries(Object.entries(this.authenticationTokens).map(([k0, v0]) => [k0, v0.toJSON()]));
+        if (this.systemMetadata != undefined)
+            res['systemMetadata'] = this.systemMetadata.toJSON();
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['User']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new User({
+            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"]),
+            created: expectNumber(extractEntry(jCpy, 'created', false, path), true, true, [...path, ".created"]),
+            identifier: expectArray(extractEntry(jCpy, 'identifier', false, path), false, [...path, ".identifier"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, Identifier.fromJSON)),
+            name: expectString(extractEntry(jCpy, 'name', false, path), true, [...path, ".name"]),
+            properties: expectArray(extractEntry(jCpy, 'properties', false, path), false, [...path, ".properties"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, DecryptedPropertyStub.fromJSON)),
+            permissions: expectArray(extractEntry(jCpy, 'permissions', false, path), false, [...path, ".permissions"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, Permission.fromJSON)),
+            roles: expectArray(extractEntry(jCpy, 'roles', false, path), false, [...path, ".roles"], (x0, p0) => expectString(x0, false, p0)),
+            type: expectStringEnum(extractEntry(jCpy, 'type', false, path), true, [...path, ".type"], UsersType, 'UsersType'),
+            status: expectStringEnum(extractEntry(jCpy, 'status', false, path), true, [...path, ".status"], UsersStatus, 'UsersStatus'),
+            login: expectString(extractEntry(jCpy, 'login', false, path), true, [...path, ".login"]),
+            passwordHash: expectString(extractEntry(jCpy, 'passwordHash', false, path), true, [...path, ".passwordHash"]),
+            groupId: expectString(extractEntry(jCpy, 'groupId', false, path), true, [...path, ".groupId"]),
+            healthcarePartyId: expectString(extractEntry(jCpy, 'healthcarePartyId', false, path), true, [...path, ".healthcarePartyId"]),
+            patientId: expectString(extractEntry(jCpy, 'patientId', false, path), true, [...path, ".patientId"]),
+            deviceId: expectString(extractEntry(jCpy, 'deviceId', false, path), true, [...path, ".deviceId"]),
+            autoDelegations: expectMap(extractEntry(jCpy, 'autoDelegations', false, path), false, [...path, ".autoDelegations"], (k0, p0) => expectStringEnum(k0, false, p0, DelegationTag, 'DelegationTag'), (v0, p0) => expectArray(v0, false, p0, (x1, p1) => expectString(x1, false, p1))),
+            createdDate: expectNumber(extractEntry(jCpy, 'createdDate', false, path), true, true, [...path, ".createdDate"]),
+            termsOfUseDate: expectNumber(extractEntry(jCpy, 'termsOfUseDate', false, path), true, true, [...path, ".termsOfUseDate"]),
+            email: expectString(extractEntry(jCpy, 'email', false, path), true, [...path, ".email"]),
+            mobilePhone: expectString(extractEntry(jCpy, 'mobilePhone', false, path), true, [...path, ".mobilePhone"]),
+            applicationTokens: expectMap(extractEntry(jCpy, 'applicationTokens', false, path), false, [...path, ".applicationTokens"], (k0, p0) => expectString(k0, false, p0), (v0, p0) => expectString(v0, false, p0)),
+            authenticationTokens: expectMap(extractEntry(jCpy, 'authenticationTokens', false, path), false, [...path, ".authenticationTokens"], (k0, p0) => expectString(k0, false, p0), (v0, p0) => expectObject(v0, false, ignoreUnknownKeys, p0, AuthenticationToken.fromJSON)),
+            systemMetadata: expectObject(extractEntry(jCpy, 'systemMetadata', false, path), true, ignoreUnknownKeys, [...path, ".systemMetadata"], User.SystemMetadata.fromJSON),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object User at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }
 (function (User) {
     class SystemMetadata {
@@ -88,6 +181,31 @@ export class User {
             if ('loginIdentifiers' in partial && partial.loginIdentifiers !== undefined)
                 this.loginIdentifiers = partial.loginIdentifiers;
         }
+        toJSON() {
+            const res = {};
+            res['roles'] = this.roles.map((x0) => x0);
+            res['isAdmin'] = this.isAdmin;
+            res['inheritsRoles'] = this.inheritsRoles;
+            res['loginIdentifiers'] = this.loginIdentifiers.map((x0) => x0.toJSON());
+            return res;
+        }
+        static fromJSON(json, ignoreUnknownKeys = false, path = ['SystemMetadata']) {
+            if (typeof json != 'object')
+                throw new Error(`Expected json object at path ${path.join("")}`);
+            const jCpy = Object.assign({}, json);
+            const res = new SystemMetadata({
+                roles: expectArray(extractEntry(jCpy, 'roles', true, path), false, [...path, ".roles"], (x0, p0) => expectString(x0, false, p0)),
+                isAdmin: expectBoolean(extractEntry(jCpy, 'isAdmin', true, path), false, [...path, ".isAdmin"]),
+                inheritsRoles: expectBoolean(extractEntry(jCpy, 'inheritsRoles', true, path), false, [...path, ".inheritsRoles"]),
+                loginIdentifiers: expectArray(extractEntry(jCpy, 'loginIdentifiers', false, path), false, [...path, ".loginIdentifiers"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, LoginIdentifier.fromJSON)),
+            });
+            if (!ignoreUnknownKeys) {
+                const unused = Object.keys(jCpy);
+                if (unused.length > 0)
+                    throw new Error(`Unexpected key(s) for json object SystemMetadata at path ${path.join("")}: ${unused}`);
+            }
+            return res;
+        }
     }
     User.SystemMetadata = SystemMetadata;
 })(User || (User = {}));

package/model/UserGroup.d.mts

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

package/model/UserGroup.mjs

@@ -1,3 +1,6 @@
+// auto-generated file
+import { expectArray, expectObject, expectString, extractEntry } from '../internal/JsonDecodeUtils.mjs';
+import { Group } from './Group.mjs';
 export class UserGroup {
     constructor(partial) {
         this.groupId = undefined;
@@ -37,4 +40,56 @@ export class UserGroup {
         if ('nameOfParentOfTopmostGroupInHierarchy' in partial)
             this.nameOfParentOfTopmostGroupInHierarchy = partial.nameOfParentOfTopmostGroupInHierarchy;
     }
+    toJSON() {
+        const res = {};
+        if (this.groupId != undefined)
+            res['groupId'] = this.groupId;
+        if (this.groupName != undefined)
+            res['groupName'] = this.groupName;
+        res['groupsHierarchy'] = this.groupsHierarchy.map((x0) => x0.toJSON());
+        if (this.userId != undefined)
+            res['userId'] = this.userId;
+        if (this.login != undefined)
+            res['login'] = this.login;
+        if (this.name != undefined)
+            res['name'] = this.name;
+        if (this.email != undefined)
+            res['email'] = this.email;
+        if (this.phone != undefined)
+            res['phone'] = this.phone;
+        if (this.patientId != undefined)
+            res['patientId'] = this.patientId;
+        if (this.healthcarePartyId != undefined)
+            res['healthcarePartyId'] = this.healthcarePartyId;
+        if (this.deviceId != undefined)
+            res['deviceId'] = this.deviceId;
+        if (this.nameOfParentOfTopmostGroupInHierarchy != undefined)
+            res['nameOfParentOfTopmostGroupInHierarchy'] = this.nameOfParentOfTopmostGroupInHierarchy;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['UserGroup']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new UserGroup({
+            groupId: expectString(extractEntry(jCpy, 'groupId', false, path), true, [...path, ".groupId"]),
+            groupName: expectString(extractEntry(jCpy, 'groupName', false, path), true, [...path, ".groupName"]),
+            groupsHierarchy: expectArray(extractEntry(jCpy, 'groupsHierarchy', false, path), false, [...path, ".groupsHierarchy"], (x0, p0) => expectObject(x0, false, ignoreUnknownKeys, p0, Group.fromJSON)),
+            userId: expectString(extractEntry(jCpy, 'userId', false, path), true, [...path, ".userId"]),
+            login: expectString(extractEntry(jCpy, 'login', false, path), true, [...path, ".login"]),
+            name: expectString(extractEntry(jCpy, 'name', false, path), true, [...path, ".name"]),
+            email: expectString(extractEntry(jCpy, 'email', false, path), true, [...path, ".email"]),
+            phone: expectString(extractEntry(jCpy, 'phone', false, path), true, [...path, ".phone"]),
+            patientId: expectString(extractEntry(jCpy, 'patientId', false, path), true, [...path, ".patientId"]),
+            healthcarePartyId: expectString(extractEntry(jCpy, 'healthcarePartyId', false, path), true, [...path, ".healthcarePartyId"]),
+            deviceId: expectString(extractEntry(jCpy, 'deviceId', false, path), true, [...path, ".deviceId"]),
+            nameOfParentOfTopmostGroupInHierarchy: expectString(extractEntry(jCpy, 'nameOfParentOfTopmostGroupInHierarchy', false, path), true, [...path, ".nameOfParentOfTopmostGroupInHierarchy"]),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object UserGroup at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/base/CodeStub.d.mts

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

package/model/base/CodeStub.mjs

@@ -1,3 +1,5 @@
+// auto-generated file
+import { expectMap, expectString, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
 export class CodeStub {
     constructor(partial) {
         this.id = undefined;
@@ -22,4 +24,42 @@ export class CodeStub {
         if ('label' in partial)
             this.label = partial.label;
     }
+    toJSON() {
+        const res = {};
+        if (this.id != undefined)
+            res['id'] = this.id;
+        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.contextLabel != undefined)
+            res['contextLabel'] = this.contextLabel;
+        if (this.label != undefined)
+            res['label'] = Object.fromEntries(Object.entries(this.label).map(([k0, v0]) => [k0, v0]));
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['CodeStub']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new CodeStub({
+            id: expectString(extractEntry(jCpy, 'id', false, path), true, [...path, ".id"]),
+            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"]),
+            contextLabel: expectString(extractEntry(jCpy, 'contextLabel', false, path), true, [...path, ".contextLabel"]),
+            label: expectMap(extractEntry(jCpy, 'label', false, path), true, [...path, ".label"], (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 CodeStub at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/base/CryptoActor.d.mts

@@ -27,3 +27,6 @@ export interface CryptoActor extends Versionable<string> {
     cryptoActorProperties: Array<DecryptedPropertyStub> | undefined;
     readonly $ktClass: string;
 }
+export declare namespace CryptoActor {
+    function fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): CryptoActor;
+}

package/model/base/CryptoActor.mjs

@@ -1 +1,19 @@
-export {};
+// auto-generated file
+import { CryptoActorStub } from '../CryptoActorStub.mjs';
+import { Device } from '../Device.mjs';
+import { HealthcareParty } from '../HealthcareParty.mjs';
+import { DecryptedPatient, EncryptedPatient } from '../Patient.mjs';
+export var CryptoActor;
+(function (CryptoActor) {
+    function fromJSON(json, ignoreUnknownKeys = false, path = ['CryptoActor']) {
+        switch (json.$ktClass) {
+            case 'com.icure.cardinal.sdk.model.CryptoActorStub': return CryptoActorStub.fromJSON(json, ignoreUnknownKeys);
+            case 'com.icure.cardinal.sdk.model.EncryptedPatient': return EncryptedPatient.fromJSON(json, ignoreUnknownKeys);
+            case 'com.icure.cardinal.sdk.model.DecryptedPatient': return DecryptedPatient.fromJSON(json, ignoreUnknownKeys);
+            case 'com.icure.cardinal.sdk.model.Device': return Device.fromJSON(json, ignoreUnknownKeys);
+            case 'com.icure.cardinal.sdk.model.HealthcareParty': return HealthcareParty.fromJSON(json, ignoreUnknownKeys);
+            default: throw new Error('Unexpected discriminator for CryptoActor: ' + json.$ktClass);
+        }
+    }
+    CryptoActor.fromJSON = fromJSON;
+})(CryptoActor || (CryptoActor = {}));

package/model/base/Identifier.d.mts

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

package/model/base/Identifier.mjs

@@ -1,3 +1,6 @@
+// auto-generated file
+import { expectObject, expectString, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
+import { CodeStub } from './CodeStub.mjs';
 export class Identifier {
     constructor(partial) {
         this.id = undefined;
@@ -25,4 +28,45 @@ export class Identifier {
         if ('value' in partial)
             this.value = partial.value;
     }
+    toJSON() {
+        const res = {};
+        if (this.id != undefined)
+            res['id'] = this.id;
+        if (this.assigner != undefined)
+            res['assigner'] = this.assigner;
+        if (this.start != undefined)
+            res['start'] = this.start;
+        if (this.end != undefined)
+            res['end'] = this.end;
+        if (this.system != undefined)
+            res['system'] = this.system;
+        if (this.type != undefined)
+            res['type'] = this.type.toJSON();
+        if (this.use != undefined)
+            res['use'] = this.use;
+        if (this.value != undefined)
+            res['value'] = this.value;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['Identifier']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new Identifier({
+            id: expectString(extractEntry(jCpy, 'id', false, path), true, [...path, ".id"]),
+            assigner: expectString(extractEntry(jCpy, 'assigner', false, path), true, [...path, ".assigner"]),
+            start: expectString(extractEntry(jCpy, 'start', false, path), true, [...path, ".start"]),
+            end: expectString(extractEntry(jCpy, 'end', false, path), true, [...path, ".end"]),
+            system: expectString(extractEntry(jCpy, 'system', false, path), true, [...path, ".system"]),
+            type: expectObject(extractEntry(jCpy, 'type', false, path), true, ignoreUnknownKeys, [...path, ".type"], CodeStub.fromJSON),
+            use: expectString(extractEntry(jCpy, 'use', false, path), true, [...path, ".use"]),
+            value: expectString(extractEntry(jCpy, 'value', false, path), true, [...path, ".value"]),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object Identifier at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/couchdb/Basic.d.mts

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

package/model/couchdb/Basic.mjs

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

package/model/couchdb/DatabaseInfo.d.mts

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

package/model/couchdb/DatabaseInfo.mjs

@@ -1,4 +1,5 @@
 // auto-generated file
+import { expectNumber, expectString, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
 import { randomUuid } from '../../utils/Id.mjs';
 export class DatabaseInfo {
     constructor(partial) {
@@ -32,4 +33,50 @@ export class DatabaseInfo {
         if ('r' in partial)
             this.r = partial.r;
     }
+    toJSON() {
+        const res = {};
+        res['id'] = this.id;
+        if (this.updateSeq != undefined)
+            res['updateSeq'] = this.updateSeq;
+        if (this.fileSize != undefined)
+            res['fileSize'] = this.fileSize;
+        if (this.externalSize != undefined)
+            res['externalSize'] = this.externalSize;
+        if (this.activeSize != undefined)
+            res['activeSize'] = this.activeSize;
+        if (this.docs != undefined)
+            res['docs'] = this.docs;
+        if (this.q != undefined)
+            res['q'] = this.q;
+        if (this.n != undefined)
+            res['n'] = this.n;
+        if (this.w != undefined)
+            res['w'] = this.w;
+        if (this.r != undefined)
+            res['r'] = this.r;
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['DatabaseInfo']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new DatabaseInfo({
+            id: expectString(extractEntry(jCpy, 'id', true, path), false, [...path, ".id"]),
+            updateSeq: expectString(extractEntry(jCpy, 'updateSeq', false, path), true, [...path, ".updateSeq"]),
+            fileSize: expectNumber(extractEntry(jCpy, 'fileSize', false, path), true, true, [...path, ".fileSize"]),
+            externalSize: expectNumber(extractEntry(jCpy, 'externalSize', false, path), true, true, [...path, ".externalSize"]),
+            activeSize: expectNumber(extractEntry(jCpy, 'activeSize', false, path), true, true, [...path, ".activeSize"]),
+            docs: expectNumber(extractEntry(jCpy, 'docs', false, path), true, true, [...path, ".docs"]),
+            q: expectNumber(extractEntry(jCpy, 'q', false, path), true, true, [...path, ".q"]),
+            n: expectNumber(extractEntry(jCpy, 'n', false, path), true, true, [...path, ".n"]),
+            w: expectNumber(extractEntry(jCpy, 'w', false, path), true, true, [...path, ".w"]),
+            r: expectNumber(extractEntry(jCpy, 'r', false, path), true, true, [...path, ".r"]),
+        });
+        if (!ignoreUnknownKeys) {
+            const unused = Object.keys(jCpy);
+            if (unused.length > 0)
+                throw new Error(`Unexpected key(s) for json object DatabaseInfo at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/couchdb/DesignDocument.d.mts

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

package/model/couchdb/DesignDocument.mjs

@@ -1,5 +1,7 @@
 // auto-generated file
+import { expectMap, expectObject, expectString, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
 import { randomUuid } from '../../utils/Id.mjs';
+import { View } from './View.mjs';
 export class DesignDocument {
     constructor(partial) {
         var _a;
@@ -29,4 +31,42 @@ export class DesignDocument {
         if ('filters' in partial && partial.filters !== undefined)
             this.filters = partial.filters;
     }
+    toJSON() {
+        const res = {};
+        res['id'] = this.id;
+        if (this.rev != undefined)
+            res['rev'] = this.rev;
+        res['revHistory'] = Object.fromEntries(Object.entries(this.revHistory).map(([k0, v0]) => [k0, v0]));
+        if (this.language != undefined)
+            res['language'] = this.language;
+        res['views'] = Object.fromEntries(Object.entries(this.views).map(([k0, v0]) => [k0, v0.toJSON()]));
+        res['lists'] = Object.fromEntries(Object.entries(this.lists).map(([k0, v0]) => [k0, v0]));
+        res['shows'] = Object.fromEntries(Object.entries(this.shows).map(([k0, v0]) => [k0, v0]));
+        if (this.updateHandlers != undefined)
+            res['updateHandlers'] = Object.fromEntries(Object.entries(this.updateHandlers).map(([k0, v0]) => [k0, v0]));
+        res['filters'] = Object.fromEntries(Object.entries(this.filters).map(([k0, v0]) => [k0, v0]));
+        return res;
+    }
+    static fromJSON(json, ignoreUnknownKeys = false, path = ['DesignDocument']) {
+        if (typeof json != 'object')
+            throw new Error(`Expected json object at path ${path.join("")}`);
+        const jCpy = Object.assign({}, json);
+        const res = new DesignDocument({
+            id: expectString(extractEntry(jCpy, 'id', true, path), false, [...path, ".id"]),
+            rev: expectString(extractEntry(jCpy, 'rev', false, path), true, [...path, ".rev"]),
+            revHistory: expectMap(extractEntry(jCpy, 'revHistory', false, path), false, [...path, ".revHistory"], (k0, p0) => expectString(k0, false, p0), (v0, p0) => expectString(v0, false, p0)),
+            language: expectString(extractEntry(jCpy, 'language', false, path), true, [...path, ".language"]),
+            views: expectMap(extractEntry(jCpy, 'views', false, path), false, [...path, ".views"], (k0, p0) => expectString(k0, false, p0), (v0, p0) => expectObject(v0, false, ignoreUnknownKeys, p0, View.fromJSON)),
+            lists: expectMap(extractEntry(jCpy, 'lists', false, path), false, [...path, ".lists"], (k0, p0) => expectString(k0, false, p0), (v0, p0) => expectString(v0, false, p0)),
+            shows: expectMap(extractEntry(jCpy, 'shows', false, path), false, [...path, ".shows"], (k0, p0) => expectString(k0, false, p0), (v0, p0) => expectString(v0, false, p0)),
+            updateHandlers: expectMap(extractEntry(jCpy, 'updateHandlers', false, path), true, [...path, ".updateHandlers"], (k0, p0) => expectString(k0, false, p0), (v0, p0) => expectString(v0, false, p0)),
+            filters: expectMap(extractEntry(jCpy, 'filters', false, path), false, [...path, ".filters"], (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 DesignDocument at path ${path.join("")}: ${unused}`);
+        }
+        return res;
+    }
 }

package/model/couchdb/DocIdentifier.d.mts

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

package/model/couchdb/DocIdentifier.mjs

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

package/model/couchdb/GroupDatabasesInfo.d.mts

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

package/model/couchdb/GroupDatabasesInfo.mjs

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

package/model/couchdb/Remote.d.mts

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

package/model/couchdb/Remote.mjs

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