@mionjs/run-types 0.8.8 → 0.13.0

package/dist/cjs/mocking/mockTypes.d.ts

@@ -0,0 +1,54 @@
+import type { MockData } from '../enrich/mockData.ts';
+import type { MockRandom } from './mockRandom.ts';
+export interface MockOptions {
+    anyValuesList: unknown[];
+    minNumber?: number;
+    maxNumber?: number;
+    minDate?: number | Date;
+    maxDate?: number | Date;
+    enumIndex?: number;
+    objectList: object[];
+    promiseTimeOut: number;
+    promiseReject?: unknown;
+    regexpList: RegExp[];
+    maxRandomStringLength: number;
+    stringLength?: number;
+    stringCharSet: string;
+    symbolLength?: number;
+    symbolCharSet?: string;
+    symbolName?: string;
+    maxRandomItemsLength: number;
+    arrayLength?: number;
+    optionalProbability: number;
+    optionalPropertyProbability?: Record<string | number, number>;
+    parentObj?: Record<string | number | symbol, unknown>;
+    unionIndex?: number;
+    tupleOptions?: MockOptions[];
+    paramsOptions?: MockOptions[];
+    maxStackDepth: number;
+    maxMockRecursion: number;
+    nonDataTypes?: boolean;
+    invalid?: boolean;
+    invalidLeafProbability?: number;
+    testCreditCards?: boolean;
+    seed?: number;
+    random?: MockRandom;
+}
+export interface MockDataNode {
+    pool?: unknown[];
+    min?: number | Date;
+    max?: number | Date;
+    rt$items?: MockDataNode;
+    rt$length?: number | [number, number];
+    rt$optional?: number;
+    [property: string]: unknown;
+}
+export interface RunTypeMockOptions<T = unknown> {
+    mock?: DeepPartial<MockOptions>;
+    data?: MockData<T>;
+    dataNode?: MockDataNode;
+}
+export type MockTypeFn<T = unknown> = (options?: DeepPartial<RunTypeMockOptions>) => T;
+export type DeepPartial<T> = T extends object ? (T extends ReadonlyArray<unknown> ? T : {
+    [K in keyof T]?: DeepPartial<T[K]>;
+}) : T;

package/dist/cjs/mocking/mockTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/mocking/structuralFormat.d.ts

@@ -0,0 +1,5 @@
+import type { FormatAnnotation } from '../runtypes/formatAnnotation.ts';
+export declare function canonicalJson(value: unknown): string;
+export declare function hasDuplicateItems(items: readonly unknown[]): boolean;
+export declare function isStructuralFormat(annotation: FormatAnnotation | undefined): boolean;
+export declare function structuralFormatAccepts(value: unknown, annotation: FormatAnnotation | undefined): boolean;

package/dist/cjs/mocking/structuralFormat.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicalJson = canonicalJson;
+exports.hasDuplicateItems = hasDuplicateItems;
+exports.isStructuralFormat = isStructuralFormat;
+exports.structuralFormatAccepts = structuralFormatAccepts;
+function canonicalJson(value) {
+    if (value === null || typeof value !== 'object') {
+        return typeof value === 'string' ? JSON.stringify(value) : typeof value + ':' + String(value);
+    }
+    if (Array.isArray(value))
+        return '[' + value.map(canonicalJson).join(',') + ']';
+    const record = value;
+    const keys = Object.keys(record).sort();
+    return '{' + keys.map((key) => JSON.stringify(key) + ':' + canonicalJson(record[key])).join(',') + '}';
+}
+function hasDuplicateItems(items) {
+    const seen = new Set();
+    for (const item of items) {
+        const key = canonicalJson(item);
+        if (seen.has(key))
+            return true;
+        seen.add(key);
+    }
+    return false;
+}
+function isStructuralFormat(annotation) {
+    if (annotation === undefined)
+        return false;
+    switch (annotation.name) {
+        case 'formattedArray':
+        case 'formattedObject':
+        case 'formattedSet':
+        case 'formattedMap':
+            return true;
+        default:
+            return false;
+    }
+}
+function itemKeywordsAccept(items, params) {
+    if (typeof params.minItems === 'number' && items.length < params.minItems)
+        return false;
+    if (typeof params.maxItems === 'number' && items.length > params.maxItems)
+        return false;
+    if (params.uniqueItems === true && hasDuplicateItems(items))
+        return false;
+    return true;
+}
+function structuralFormatAccepts(value, annotation) {
+    if (!annotation)
+        return true;
+    const params = (annotation.params ?? {});
+    if (annotation.name === 'formattedArray') {
+        return Array.isArray(value) && itemKeywordsAccept(value, params);
+    }
+    if (annotation.name === 'formattedSet') {
+        return value instanceof Set && itemKeywordsAccept([...value], params);
+    }
+    if (annotation.name === 'formattedMap') {
+        return value instanceof Map && itemKeywordsAccept([...value], params);
+    }
+    if (annotation.name === 'formattedObject') {
+        if (typeof value !== 'object' || value === null)
+            return false;
+        const keys = Object.keys(value);
+        if (typeof params.minProperties === 'number' && keys.length < params.minProperties)
+            return false;
+        if (typeof params.maxProperties === 'number' && keys.length > params.maxProperties)
+            return false;
+        const closed = params.closed;
+        if (Array.isArray(closed)) {
+            const patterns = Array.isArray(params.closedPatterns)
+                ? params.closedPatterns.filter((entry) => typeof entry === 'string')
+                : [];
+            const allowed = (key) => closed.includes(key) || patterns.some((source) => new RegExp(source).test(key));
+            if (!keys.every(allowed))
+                return false;
+        }
+        return true;
+    }
+    return true;
+}

package/dist/cjs/modelTypes.d.ts

@@ -0,0 +1,11 @@
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type SelectModel<T> = Prettify<{
+    [K in keyof T]-?: {} extends Pick<T, K> ? NonNullable<T[K]> | null : T[K];
+}>;
+export type InsertModel<T, Generated extends keyof T = never, Defaulted extends keyof T = never> = Prettify<Omit<T, Generated | Defaulted> & {
+    [K in Defaulted]?: T[K];
+}>;
+export type UpdateModel<T, Generated extends keyof T = never> = Prettify<Partial<Omit<T, Generated>>>;
+export {};

package/dist/cjs/modelTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/overrideRTFunctions.d.ts

@@ -0,0 +1,9 @@
+import type { InjectTypeFnArgs, PureFunction } from './markers.ts';
+import type { DataOnly } from './runtypes/dataOnly.ts';
+import type { ValidateFn, GetValidationErrorsFn, RemoveUnknownKeysFn, FormatTransformFn, JsonEncoderFn, JsonDecoderFn } from './createRTFunctions.ts';
+export declare const overrideValidate: <T>(fn: PureFunction<ValidateFn<T>>, id?: InjectTypeFnArgs<T, "validate">) => void;
+export declare const overrideGetValidationErrors: <T>(fn: PureFunction<GetValidationErrorsFn>, id?: InjectTypeFnArgs<T, "validationErrors">) => void;
+export declare const overrideRemoveUnknownKeys: <T>(fn: PureFunction<RemoveUnknownKeysFn<T>>, id?: InjectTypeFnArgs<T, "removeUnknownKeys">) => void;
+export declare const overrideFormatTransform: <T>(fn: PureFunction<FormatTransformFn<T>>, id?: InjectTypeFnArgs<T, "formatTransform">) => void;
+export declare const overrideJsonEncoder: <T>(fn: PureFunction<JsonEncoderFn>, id?: InjectTypeFnArgs<T, "jsonEncoder">) => void;
+export declare const overrideJsonDecoder: <T>(fn: PureFunction<JsonDecoderFn<DataOnly<T>>>, id?: InjectTypeFnArgs<T, "jsonDecoder">) => void;

package/dist/cjs/overrideRTFunctions.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.overrideJsonDecoder = exports.overrideJsonEncoder = exports.overrideFormatTransform = exports.overrideRemoveUnknownKeys = exports.overrideGetValidationErrors = exports.overrideValidate = void 0;
+const entryTuple_ts_1 = require("./runtypes/entryTuple.js");
+function overrideImpl(_pureFn, id) {
+    if ((0, entryTuple_ts_1.isEntryTuple)(id)) {
+        (0, entryTuple_ts_1.initFromTuple)(id);
+        return;
+    }
+    if (typeof console !== 'undefined') {
+        console.warn('[mion] overrideX(): no entry injected. The @mionjs/devtools plugin ' +
+            'must be active for per-type overrides to take effect.');
+    }
+}
+exports.overrideValidate = overrideImpl;
+exports.overrideGetValidationErrors = overrideImpl;
+exports.overrideRemoveUnknownKeys = overrideImpl;
+exports.overrideFormatTransform = overrideImpl;
+exports.overrideJsonEncoder = overrideImpl;
+exports.overrideJsonDecoder = overrideImpl;

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/runtime/index.d.ts

@@ -0,0 +1,10 @@
+export { getRTUtils, getRTFnCaches, type RTUtils } from '../runtypes/rtUtils.ts';
+export { buildFactoryFromCode, buildPureFnFactoryFromCode, entryCode } from '../runtypes/rtUtils.ts';
+export { getFnHash, type FnHashKey, type FnHashOptions } from '../fnHash.ts';
+export { FAMILY_TAG_TO_FN_KEY } from '../go-generated/fnHashes.generated.ts';
+export { registerPureFnFactory, registerPureFn, type PureFnId } from '../runtypes/pureFn.ts';
+export { RUN_TYPES_PURE_FN_ID_PREFIX } from '../runtypes/pure-fn-ids.generated.ts';
+export { registerClassSerializer, type ClassSerializerHandler, type AnyClass, type SerializableClass, type DeserializeClassFn, } from '../runtypes/classSerializerRegistry.ts';
+export { typeFormats, type FormatName, type TypeFormatMeta } from '../go-generated/typeFormats.generated.ts';
+export { getRTFunction, type RTFunctionByKey, type RTFunctionKey } from '../createRTFunctions.ts';
+export type { FnTypeTuple, PureFnTuple, MissingTuple, RunTypeTuple, RunTypeBundleTuple, RunTypeFacadeTuple, } from '../runtypes/entryTuple.ts';

package/dist/cjs/runtime/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRTFunction = exports.typeFormats = exports.registerClassSerializer = exports.RUN_TYPES_PURE_FN_ID_PREFIX = exports.registerPureFn = exports.registerPureFnFactory = exports.FAMILY_TAG_TO_FN_KEY = exports.getFnHash = exports.entryCode = exports.buildPureFnFactoryFromCode = exports.buildFactoryFromCode = exports.getRTFnCaches = exports.getRTUtils = void 0;
+var rtUtils_ts_1 = require("../runtypes/rtUtils.js");
+Object.defineProperty(exports, "getRTUtils", { enumerable: true, get: function () { return rtUtils_ts_1.getRTUtils; } });
+Object.defineProperty(exports, "getRTFnCaches", { enumerable: true, get: function () { return rtUtils_ts_1.getRTFnCaches; } });
+var rtUtils_ts_2 = require("../runtypes/rtUtils.js");
+Object.defineProperty(exports, "buildFactoryFromCode", { enumerable: true, get: function () { return rtUtils_ts_2.buildFactoryFromCode; } });
+Object.defineProperty(exports, "buildPureFnFactoryFromCode", { enumerable: true, get: function () { return rtUtils_ts_2.buildPureFnFactoryFromCode; } });
+Object.defineProperty(exports, "entryCode", { enumerable: true, get: function () { return rtUtils_ts_2.entryCode; } });
+var fnHash_ts_1 = require("../fnHash.js");
+Object.defineProperty(exports, "getFnHash", { enumerable: true, get: function () { return fnHash_ts_1.getFnHash; } });
+var fnHashes_generated_ts_1 = require("../go-generated/fnHashes.generated.js");
+Object.defineProperty(exports, "FAMILY_TAG_TO_FN_KEY", { enumerable: true, get: function () { return fnHashes_generated_ts_1.FAMILY_TAG_TO_FN_KEY; } });
+var pureFn_ts_1 = require("../runtypes/pureFn.js");
+Object.defineProperty(exports, "registerPureFnFactory", { enumerable: true, get: function () { return pureFn_ts_1.registerPureFnFactory; } });
+Object.defineProperty(exports, "registerPureFn", { enumerable: true, get: function () { return pureFn_ts_1.registerPureFn; } });
+var pure_fn_ids_generated_ts_1 = require("../runtypes/pure-fn-ids.generated.js");
+Object.defineProperty(exports, "RUN_TYPES_PURE_FN_ID_PREFIX", { enumerable: true, get: function () { return pure_fn_ids_generated_ts_1.RUN_TYPES_PURE_FN_ID_PREFIX; } });
+var classSerializerRegistry_ts_1 = require("../runtypes/classSerializerRegistry.js");
+Object.defineProperty(exports, "registerClassSerializer", { enumerable: true, get: function () { return classSerializerRegistry_ts_1.registerClassSerializer; } });
+var typeFormats_generated_ts_1 = require("../go-generated/typeFormats.generated.js");
+Object.defineProperty(exports, "typeFormats", { enumerable: true, get: function () { return typeFormats_generated_ts_1.typeFormats; } });
+var createRTFunctions_ts_1 = require("../createRTFunctions.js");
+Object.defineProperty(exports, "getRTFunction", { enumerable: true, get: function () { return createRTFunctions_ts_1.getRTFunction; } });

package/dist/cjs/runtypes/builderCore.d.ts

@@ -0,0 +1,7 @@
+import type { RunType } from './types.ts';
+import type { InjectRunTypeId } from '../markers.ts';
+import type { BrandArg } from './builderTypes.ts';
+export declare function builderResult<T>(id: InjectRunTypeId<T> | undefined, carrier: unknown): RunType<T>;
+export declare function brand<const B extends string>(name: B): BrandArg<B>;
+export declare function lastInjectedId(...args: unknown[]): string | undefined;
+export declare function presetBuilder<T>(tag: string): (id?: InjectRunTypeId<T>) => RunType<T>;

package/dist/cjs/runtypes/builderCore.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builderResult = builderResult;
+exports.brand = brand;
+exports.lastInjectedId = lastInjectedId;
+exports.presetBuilder = presetBuilder;
+const rtUtils_ts_1 = require("./rtUtils.js");
+const entryTuple_ts_1 = require("./entryTuple.js");
+function builderResult(id, carrier) {
+    let resolvedId = typeof id === 'string' ? id : undefined;
+    if ((0, entryTuple_ts_1.isEntryTuple)(id)) {
+        (0, entryTuple_ts_1.initFromTuple)(id);
+        resolvedId = (0, entryTuple_ts_1.entryTupleKey)(id);
+    }
+    if (resolvedId !== undefined) {
+        const runType = (0, rtUtils_ts_1.getRTUtils)().getRunType(resolvedId);
+        if (runType)
+            return runType;
+    }
+    return carrier;
+}
+function brand(name) {
+    return { __rtBrandName: name };
+}
+function lastInjectedId(...args) {
+    for (let i = args.length - 1; i >= 0; i--) {
+        const arg = args[i];
+        if (typeof arg === 'string')
+            return arg;
+        if ((0, entryTuple_ts_1.isEntryTuple)(arg)) {
+            (0, entryTuple_ts_1.initFromTuple)(arg);
+            return (0, entryTuple_ts_1.entryTupleKey)(arg);
+        }
+    }
+    return undefined;
+}
+function presetBuilder(tag) {
+    return (id) => builderResult(id, { type: tag, formatParams: {} });
+}

package/dist/cjs/runtypes/builderTypes.d.ts

@@ -0,0 +1,51 @@
+import { TypeFormat } from './typeFormat.ts';
+import type { RunType } from './types.ts';
+import type { InjectRunTypeId, CompTimeArgs } from '../markers.ts';
+import type { MinMax } from '../formats/datetime/dateTimeParams.ts';
+import type { UrlObjectFormat } from '../formats/string/stringFormats.ts';
+import type { Instant, ZonedDateTime, PlainDate, PlainTime, PlainDateTime, PlainYearMonth, TemporalBaseByFormatName } from '../formats/datetime/temporalFormats.ts';
+export type InferType<RT> = RT extends RunType ? NonNullable<RT['__rtType']>['t'] : RT;
+export interface LeafTypeByFormatName<P extends object, BrandName extends string = never> {
+    stringFormat: TypeFormat<string, 'stringFormat', P, BrandName>;
+    numberFormat: TypeFormat<number, 'numberFormat', P, BrandName>;
+    bigintFormat: TypeFormat<bigint, 'bigintFormat', P, BrandName>;
+    nativeDate: TypeFormat<Date, 'nativeDate', P, BrandName>;
+    nativeUrl: UrlObjectFormat<P, BrandName>;
+    temporalInstant: P extends MinMax ? Instant<P> : never;
+    temporalZonedDateTime: P extends MinMax ? ZonedDateTime<P> : never;
+    temporalPlainDate: P extends MinMax ? PlainDate<P> : never;
+    temporalPlainTime: P extends MinMax ? PlainTime<P> : never;
+    temporalPlainDateTime: P extends MinMax ? PlainDateTime<P> : never;
+    temporalPlainYearMonth: P extends MinMax ? PlainYearMonth<P> : never;
+}
+export type LeafFormatName = keyof LeafTypeByFormatName<Record<string, never>>;
+export type ExactParams<P, Allowed> = P & Record<Exclude<keyof P, keyof Allowed>, never>;
+export type LeafType<Name extends LeafFormatName, P extends object, BrandName extends string = never> = LeafTypeByFormatName<P, BrandName>[Name];
+export interface BrandArg<B extends string> {
+    readonly __rtBrandName: B;
+}
+export interface TemporalFormatByTag<P extends MinMax> {
+    'temporal.instant': LeafType<'temporalInstant', P>;
+    'temporal.zonedDateTime': LeafType<'temporalZonedDateTime', P>;
+    'temporal.plainDate': LeafType<'temporalPlainDate', P>;
+    'temporal.plainTime': LeafType<'temporalPlainTime', P>;
+    'temporal.plainDateTime': LeafType<'temporalPlainDateTime', P>;
+    'temporal.plainYearMonth': LeafType<'temporalPlainYearMonth', P>;
+}
+export interface TemporalBaseByTag {
+    'temporal.instant': TemporalBaseByFormatName['temporalInstant'];
+    'temporal.zonedDateTime': TemporalBaseByFormatName['temporalZonedDateTime'];
+    'temporal.plainDate': TemporalBaseByFormatName['temporalPlainDate'];
+    'temporal.plainTime': TemporalBaseByFormatName['temporalPlainTime'];
+    'temporal.plainDateTime': TemporalBaseByFormatName['temporalPlainDateTime'];
+    'temporal.plainYearMonth': TemporalBaseByFormatName['temporalPlainYearMonth'];
+    'temporal.plainMonthDay': TemporalBaseByFormatName['temporalPlainMonthDay'];
+    'temporal.duration': TemporalBaseByFormatName['temporalDuration'];
+}
+export interface TemporalBuilderFn<Tag extends keyof TemporalFormatByTag<MinMax>> {
+    (id?: InjectRunTypeId<TemporalBaseByTag[Tag]>): RunType<TemporalBaseByTag[Tag]>;
+    <const P extends MinMax>(formatParams: CompTimeArgs<ExactParams<P, MinMax>>, id?: InjectRunTypeId<TemporalFormatByTag<P>[Tag]>): RunType<TemporalFormatByTag<P>[Tag]>;
+}
+export interface TemporalInstanceBuilderFn<Tag extends 'temporal.plainMonthDay' | 'temporal.duration'> {
+    (id?: InjectRunTypeId<TemporalBaseByTag[Tag]>): RunType<TemporalBaseByTag[Tag]>;
+}

package/dist/cjs/runtypes/builderTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/runtypes/circular-pure-fns.d.ts

@@ -0,0 +1,11 @@
+type CircularPath = (string | number)[];
+type CircularSkeleton = {
+    c: number[];
+    e: {
+        p: unknown[][];
+        t: number;
+    }[][];
+};
+export type FindCycleFn = (value: unknown, skeleton: CircularSkeleton) => CircularPath | null;
+export declare const findCycle: import("./pureFn.ts").PureFnId<"@mionjs/run-types#pf_zXMPEMyjGR4ZRc">;
+export {};

package/dist/cjs/runtypes/circular-pure-fns.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findCycle = void 0;
+const pureFn_ts_1 = require("./pureFn.js");
+const pure_fn_ids_generated_ts_1 = require("./pure-fn-ids.generated.js");
+exports.findCycle = (0, pureFn_ts_1.registerPureFnFactory)(null /** pure_fn_ids_generated_ts_1.findCycleId hollowed — body ships on demand
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+*/);

package/dist/cjs/runtypes/circular.d.ts

@@ -0,0 +1,6 @@
+export type CircularPath = (string | number)[];
+export declare class CircularReferenceError extends Error {
+    readonly path: CircularPath;
+    constructor(path: CircularPath);
+}
+export declare function formatCircularPath(path: CircularPath): string;

package/dist/cjs/runtypes/circular.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircularReferenceError = void 0;
+exports.formatCircularPath = formatCircularPath;
+class CircularReferenceError extends Error {
+    path;
+    constructor(path) {
+        super(`Circular reference detected at ${formatCircularPath(path)}`);
+        this.name = 'CircularReferenceError';
+        this.path = path;
+    }
+}
+exports.CircularReferenceError = CircularReferenceError;
+function formatCircularPath(path) {
+    if (path.length === 0)
+        return '<root>';
+    let out = '';
+    for (const segment of path) {
+        if (typeof segment === 'number')
+            out += `[${segment}]`;
+        else
+            out += out ? `.${segment}` : segment;
+    }
+    return out;
+}

package/dist/cjs/runtypes/classSerializerRegistry.d.ts

@@ -0,0 +1,28 @@
+import type { DataOnly } from './dataOnly.ts';
+import type { InjectTypeFnArgs } from '../markers.ts';
+export interface AnyClass<T = any> {
+    new (...args: any[]): T;
+}
+export interface SerializableClass<T = any> {
+    new (): T;
+}
+export type DeserializeClassFn<C> = (deserialized: DataOnly<C>) => C;
+export interface ClassSerializerHandler<T> {
+    serialize?: (instance: T) => unknown;
+    deserialize?: (data: DataOnly<T>) => T;
+}
+export interface ClassSerializerEntry<T = any> {
+    cls: AnyClass<T>;
+    serialize?: (instance: T) => unknown;
+    deserialize?: (data: DataOnly<T>) => T;
+}
+export declare function classSerializerEpoch(): number;
+export declare function registerClassSerializer<T>(cls: SerializableClass<T>, handler?: ClassSerializerHandler<T>, id?: InjectTypeFnArgs<T, 'classSerializerReg'>): void;
+export declare function registerClassSerializer<T>(cls: AnyClass<T>, handler: ClassSerializerHandler<T> & {
+    deserialize: (data: DataOnly<T>) => T;
+}, id?: InjectTypeFnArgs<T, 'classSerializerReg'>): void;
+export declare function getClassSerializer(typeId: string, className?: string): ClassSerializerEntry | undefined;
+export declare function isClassSerializerRegistered(cls: AnyClass): boolean;
+export declare function deserializeClass<T>(entry: ClassSerializerEntry<T>, data: DataOnly<T>, keys: readonly string[]): T;
+export declare function unregisterClassSerializer(cls: AnyClass): void;
+export declare function clearClassSerializers(): void;