@mionjs/run-types 0.8.10 → 0.13.2

package/dist/builders/utility.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utility.js","sourceRoot":"","sources":["../../src/builders/utility.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,aAAa,EAAC,MAAM,4BAA4B,CAAC;AASzD,MAAM,UAAU,OAAO,CAAI,KAA+B,EAAE,EAAgC;IAC1F,OAAO,aAAa,CAAC,EAAE,EAAE,EAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAC,CAAC,CAAC;AAC5D,CAAC;AAED,MAAM,UAAU,QAAQ,CAAI,KAA+B,EAAE,EAAiC;IAC5F,OAAO,aAAa,CAAC,EAAE,EAAE,EAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAC,CAAC,CAAC;AAC7D,CAAC;AAGD,MAAM,UAAU,YAAY,CAAI,KAA+B,EAAE,EAAiC;IAChG,OAAO,aAAa,CAAC,EAAE,EAAE,EAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAC,CAAC,CAAC;AAC7D,CAAC;AAED,MAAM,UAAU,WAAW,CAAI,EAA4B,EAAE,EAAoC;IAC/F,OAAO,aAAa,CAAC,EAAE,EAAE,EAAC,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,EAAE,EAAC,CAAC,CAAC;AAC7D,CAAC;AAED,MAAM,UAAU,UAAU,CACxB,IAA8B,EAC9B,EAAmC;IAEnC,OAAO,aAAa,CAAC,EAAE,EAAE,EAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,IAAI,EAAC,CAAC,CAAC;AAC9D,CAAC;AAGD,MAAM,UAAU,IAAI,CAClB,KAA+B,EAC/B,IAAqB,EACrB,EAAwC;IAExC,OAAO,aAAa,CAAC,EAAE,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAC,CAAC,CAAC;AAC/D,CAAC;AAGD,MAAM,UAAU,IAAI,CAClB,KAA+B,EAC/B,IAAqB,EACrB,EAAwC;IAExC,OAAO,aAAa,CAAC,EAAE,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAC,CAAC,CAAC;AAC/D,CAAC;AAGD,MAAM,UAAU,OAAO,CACrB,KAA+B,EAC/B,OAAiC,EACjC,EAAmC;IAEnC,OAAO,aAAa,CAAC,EAAE,EAAE,EAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAC,CAAC,CAAC;AAC/E,CAAC;AAED,MAAM,UAAU,OAAO,CACrB,KAA+B,EAC/B,SAAmC,EACnC,EAAmC;IAEnC,OAAO,aAAa,CAAC,EAAE,EAAE,EAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAC,CAAC,CAAC;AACvE,CAAC;AAGD,MAAM,UAAU,UAAU,CACxB,IAA8B,EAC9B,EAAmC;IAEnC,OAAO,aAAa,CAAC,EAAE,EAAE,EAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,IAAI,EAAC,CAAC,CAAC;AAC9D,CAAC"}

package/dist/cjs/builders/atomic.d.ts

@@ -0,0 +1,12 @@
+import type { RunType } from '../runtypes/types.ts';
+import type { InjectRunTypeId } from '../markers.ts';
+export declare function boolean(id?: InjectRunTypeId<boolean>): RunType<boolean>;
+export declare function literal<const V extends string | number | bigint | boolean | null | undefined>(value: V, id?: InjectRunTypeId<V>): RunType<V>;
+export declare function regexp(id?: InjectRunTypeId<RegExp>): RunType<RegExp>;
+export declare function symbol(id?: InjectRunTypeId<symbol>): RunType<symbol>;
+export declare function any(id?: InjectRunTypeId<any>): RunType<any>;
+export declare function unknown(id?: InjectRunTypeId<unknown>): RunType<unknown>;
+export declare function never(id?: InjectRunTypeId<never>): RunType<never>;
+export declare function voidType(id?: InjectRunTypeId<void>): RunType<void>;
+export declare function classType<Instance>(ctor: abstract new (...args: any[]) => Instance, id?: InjectRunTypeId<Instance>): RunType<Instance>;
+export declare function enumType<const E extends Record<string, string | number>>(enumObject: E, id?: InjectRunTypeId<E[keyof E]>): RunType<E[keyof E]>;

package/dist/cjs/builders/atomic.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boolean = boolean;
+exports.literal = literal;
+exports.regexp = regexp;
+exports.symbol = symbol;
+exports.any = any;
+exports.unknown = unknown;
+exports.never = never;
+exports.voidType = voidType;
+exports.classType = classType;
+exports.enumType = enumType;
+const builderCore_ts_1 = require("../runtypes/builderCore.js");
+function boolean(id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'boolean', formatParams: {} });
+}
+function literal(value, id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'literal', literal: value });
+}
+function regexp(id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'regexp', formatParams: {} });
+}
+function symbol(id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'symbol', formatParams: {} });
+}
+function any(id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'any', formatParams: {} });
+}
+function unknown(id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'unknown', formatParams: {} });
+}
+function never(id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'never', formatParams: {} });
+}
+function voidType(id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'void', formatParams: {} });
+}
+function classType(ctor, id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'class', ctor });
+}
+function enumType(enumObject, id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'enum', members: enumObject });
+}

package/dist/cjs/builders/compose.d.ts

@@ -0,0 +1,60 @@
+import type { RunType } from '../runtypes/types.ts';
+import type { ExactParams } from '../runtypes/builderTypes.ts';
+import type { InjectRunTypeId, CompTimeArgs } from '../markers.ts';
+import type { FormattedCollectionParamsValueFirst, FormattedMapParamsValueFirst, FormattedObjectParamsValueFirst, FormattedArrayFrom, FormattedObjectFrom, FormattedSetFrom, FormattedMapFrom } from '../formats/structural.ts';
+import type { InferType, UnionOf, IntersectionOf, TemplatePart, AssembleTemplate, ObjectType, PropModifiers, PropModCarrier, Self, Recursive, LabeledTuple, SlotCarrier, TupleFromGroups, LabeledTupleFromGroups, FuncFromParams } from './static.ts';
+export declare function array<T>(item: CompTimeArgs<RunType<T>>, id?: InjectRunTypeId<T[]>): RunType<T[]>;
+export declare function array<T, const P extends FormattedCollectionParamsValueFirst>(item: CompTimeArgs<RunType<T>>, params: CompTimeArgs<ExactParams<P, FormattedCollectionParamsValueFirst>>, id?: InjectRunTypeId<FormattedArrayFrom<T[], P>>): RunType<FormattedArrayFrom<T[], P>>;
+export declare function slot<const Label extends string, Value>(label: CompTimeArgs<Label>, value: CompTimeArgs<RunType<Value>>): SlotCarrier<Label, Value>;
+export declare function tuple<const T extends readonly RunType[] = [], const O extends readonly RunType[] = [], RestValue = never>(parts: CompTimeArgs<{
+    readonly required?: T;
+    readonly optional?: O;
+    readonly rest?: RunType<RestValue>;
+}>, id?: InjectRunTypeId<TupleFromGroups<T, O, RestValue>>): RunType<TupleFromGroups<T, O, RestValue>>;
+export declare function tuple<const T extends readonly SlotCarrier<string, unknown>[] = [], const O extends readonly SlotCarrier<string, unknown>[] = [], const RestLabel extends string = never, RestValue = never>(parts: CompTimeArgs<{
+    readonly required?: T;
+    readonly optional?: O;
+    readonly rest?: SlotCarrier<RestLabel, RestValue>;
+}>, id?: InjectRunTypeId<LabeledTupleFromGroups<T, O, RestLabel, RestValue>>): RunType<LabeledTupleFromGroups<T, O, RestLabel, RestValue>>;
+export declare function union<A, B>(members: CompTimeArgs<readonly [RunType<A>, RunType<B>]>, id?: InjectRunTypeId<A | B>): RunType<A | B>;
+export declare function union<A, B, C>(members: CompTimeArgs<readonly [RunType<A>, RunType<B>, RunType<C>]>, id?: InjectRunTypeId<A | B | C>): RunType<A | B | C>;
+export declare function union<A, B, C, D>(members: CompTimeArgs<readonly [RunType<A>, RunType<B>, RunType<C>, RunType<D>]>, id?: InjectRunTypeId<A | B | C | D>): RunType<A | B | C | D>;
+export declare function union<A, B, C, D, E>(members: CompTimeArgs<readonly [RunType<A>, RunType<B>, RunType<C>, RunType<D>, RunType<E>]>, id?: InjectRunTypeId<A | B | C | D | E>): RunType<A | B | C | D | E>;
+export declare function union<A, B, C, D, E, F>(members: CompTimeArgs<readonly [RunType<A>, RunType<B>, RunType<C>, RunType<D>, RunType<E>, RunType<F>]>, id?: InjectRunTypeId<A | B | C | D | E | F>): RunType<A | B | C | D | E | F>;
+export declare function union<A, B, C, D, E, F, G>(members: CompTimeArgs<readonly [RunType<A>, RunType<B>, RunType<C>, RunType<D>, RunType<E>, RunType<F>, RunType<G>]>, id?: InjectRunTypeId<A | B | C | D | E | F | G>): RunType<A | B | C | D | E | F | G>;
+export declare function union<A, B, C, D, E, F, G, H>(members: CompTimeArgs<readonly [RunType<A>, RunType<B>, RunType<C>, RunType<D>, RunType<E>, RunType<F>, RunType<G>, RunType<H>]>, id?: InjectRunTypeId<A | B | C | D | E | F | G | H>): RunType<A | B | C | D | E | F | G | H>;
+export declare function union<const T extends readonly RunType[]>(members: CompTimeArgs<T>, id?: InjectRunTypeId<UnionOf<T>>): RunType<UnionOf<T>>;
+export declare const anyOf: typeof union;
+export declare function intersection<A, B = unknown, C = unknown, D = unknown>(a: CompTimeArgs<RunType<A>>, b?: CompTimeArgs<RunType<B>>, c?: CompTimeArgs<RunType<C>>, d?: CompTimeArgs<RunType<D>>, id?: InjectRunTypeId<A & B & C & D>): RunType<A & B & C & D>;
+export declare function intersection<const T extends readonly RunType[]>(members: CompTimeArgs<T>, id?: InjectRunTypeId<IntersectionOf<T>>): RunType<IntersectionOf<T>>;
+export declare function record<V>(valueSchema: CompTimeArgs<RunType<V>>, id?: InjectRunTypeId<Record<string, V>>): RunType<Record<string, V>>;
+export declare function record<V, const P extends FormattedObjectParamsValueFirst>(valueSchema: CompTimeArgs<RunType<V>>, params: CompTimeArgs<ExactParams<P, FormattedObjectParamsValueFirst>>, id?: InjectRunTypeId<FormattedObjectFrom<Record<string, V>, P>>): RunType<FormattedObjectFrom<Record<string, V>, P>>;
+export declare function record<K extends string | number, V>(keySchema: CompTimeArgs<RunType<K>>, valueSchema: CompTimeArgs<RunType<V>>, id?: InjectRunTypeId<Record<K, V>>): RunType<Record<K, V>>;
+export declare function record<K extends string | number, V, const P extends FormattedObjectParamsValueFirst>(keySchema: CompTimeArgs<RunType<K>>, valueSchema: CompTimeArgs<RunType<V>>, params: CompTimeArgs<ExactParams<P, FormattedObjectParamsValueFirst>>, id?: InjectRunTypeId<FormattedObjectFrom<Record<K, V>, P>>): RunType<FormattedObjectFrom<Record<K, V>, P>>;
+export declare function map<K, V>(keySchema: CompTimeArgs<RunType<K>>, valueSchema: CompTimeArgs<RunType<V>>, id?: InjectRunTypeId<Map<K, V>>): RunType<Map<K, V>>;
+export declare function map<K, V, const P extends FormattedMapParamsValueFirst>(keySchema: CompTimeArgs<RunType<K>>, valueSchema: CompTimeArgs<RunType<V>>, params: CompTimeArgs<ExactParams<P, FormattedMapParamsValueFirst>>, id?: InjectRunTypeId<FormattedMapFrom<Map<K, V>, P>>): RunType<FormattedMapFrom<Map<K, V>, P>>;
+export declare function set<V>(valueSchema: CompTimeArgs<RunType<V>>, id?: InjectRunTypeId<Set<V>>): RunType<Set<V>>;
+export declare function set<V, const P extends FormattedCollectionParamsValueFirst>(valueSchema: CompTimeArgs<RunType<V>>, params: CompTimeArgs<ExactParams<P, FormattedCollectionParamsValueFirst>>, id?: InjectRunTypeId<FormattedSetFrom<Set<V>, P>>): RunType<FormattedSetFrom<Set<V>, P>>;
+export declare function self(id?: InjectRunTypeId<Self>): RunType<Self>;
+export declare function circular<Body>(body: CompTimeArgs<RunType<Body>>, id?: InjectRunTypeId<Recursive<Body>>): RunType<Recursive<Body>>;
+export declare function promise<V>(valueSchema: CompTimeArgs<RunType<V>>, id?: InjectRunTypeId<Promise<V>>): RunType<Promise<V>>;
+export declare function func<const P extends readonly RunType[] = [], R extends RunType = RunType<void>>(parts?: CompTimeArgs<{
+    readonly params?: P;
+    readonly ret?: R;
+}>, id?: InjectRunTypeId<FuncFromParams<P, InferType<R>>>): RunType<FuncFromParams<P, InferType<R>>>;
+export declare function func<const P extends readonly SlotCarrier<string, unknown>[], R extends RunType = RunType<void>>(parts: CompTimeArgs<{
+    readonly params: P;
+    readonly ret?: R;
+}>, id?: InjectRunTypeId<(...args: LabeledTuple<P>) => InferType<R>>): RunType<(...args: LabeledTuple<P>) => InferType<R>>;
+export declare function func<T extends readonly unknown[], R extends RunType = RunType<void>>(parts: CompTimeArgs<{
+    readonly params: RunType<T>;
+    readonly ret?: R;
+}>, id?: InjectRunTypeId<(...args: T) => InferType<R>>): RunType<(...args: T) => InferType<R>>;
+export declare function callable<Fn, Props>(fn: CompTimeArgs<RunType<Fn>>, iface: CompTimeArgs<RunType<Props>>, id?: InjectRunTypeId<Fn & Props>): RunType<Fn & Props>;
+export declare function templateLiteral<const P extends readonly TemplatePart[]>(parts: CompTimeArgs<P>, id?: InjectRunTypeId<AssembleTemplate<P>>): RunType<AssembleTemplate<P>>;
+export declare function propMod<const M extends PropModifiers, const F>(modifiers: CompTimeArgs<ExactParams<M, PropModifiers>>, field: CompTimeArgs<F>): PropModCarrier<M, F>;
+export declare function optional<const F>(field: CompTimeArgs<F>): PropModCarrier<{
+    optional: true;
+}, F>;
+export declare function object<const C extends Record<string, unknown>>(config: CompTimeArgs<C>, id?: InjectRunTypeId<ObjectType<C>>): RunType<ObjectType<C>>;
+export declare function object<const C extends Record<string, unknown>, const P extends FormattedObjectParamsValueFirst>(config: CompTimeArgs<C>, params: CompTimeArgs<ExactParams<P, FormattedObjectParamsValueFirst>>, id?: InjectRunTypeId<FormattedObjectFrom<ObjectType<C>, P>>): RunType<FormattedObjectFrom<ObjectType<C>, P>>;

package/dist/cjs/builders/compose.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anyOf = void 0;
+exports.array = array;
+exports.slot = slot;
+exports.tuple = tuple;
+exports.union = union;
+exports.intersection = intersection;
+exports.record = record;
+exports.map = map;
+exports.set = set;
+exports.self = self;
+exports.circular = circular;
+exports.promise = promise;
+exports.func = func;
+exports.callable = callable;
+exports.templateLiteral = templateLiteral;
+exports.propMod = propMod;
+exports.optional = optional;
+exports.object = object;
+const builderCore_ts_1 = require("../runtypes/builderCore.js");
+function isRunTypeLike(arg) {
+    return typeof arg === 'object' && arg !== null && !Array.isArray(arg) && ('kind' in arg || 'type' in arg || '__rtType' in arg);
+}
+function isFormatParams(arg) {
+    return typeof arg === 'object' && arg !== null && !Array.isArray(arg) && !isRunTypeLike(arg);
+}
+function isSlotCarrier(arg) {
+    return typeof arg === 'object' && arg !== null && typeof arg.__slotLabel === 'string';
+}
+function slotChild(arg) {
+    return isSlotCarrier(arg) ? arg.__slotValue : arg;
+}
+function array(item, arg2, arg3) {
+    const base = { type: 'array', child: item };
+    if (isFormatParams(arg2)) {
+        return (0, builderCore_ts_1.builderResult)(arg3, base);
+    }
+    return (0, builderCore_ts_1.builderResult)(arg2, base);
+}
+function slot(label, value) {
+    return { __slotLabel: label, __slotValue: value };
+}
+function tuple(parts, id) {
+    return (0, builderCore_ts_1.builderResult)(id, {
+        type: 'tuple',
+        children: (parts.required ?? []).map(slotChild),
+        optionalChildren: parts.optional?.map(slotChild),
+        rest: parts.rest === undefined ? undefined : slotChild(parts.rest),
+    });
+}
+function union(members, id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'union', children: members });
+}
+exports.anyOf = union;
+function intersection(arg1, arg2, arg3, arg4, arg5) {
+    if (Array.isArray(arg1)) {
+        return (0, builderCore_ts_1.builderResult)(arg2, { type: 'intersection', children: arg1 });
+    }
+    return (0, builderCore_ts_1.builderResult)(arg5, {
+        type: 'intersection',
+        children: [arg1, arg2, arg3, arg4],
+    });
+}
+function record(arg1, arg2, arg3, arg4) {
+    if (isRunTypeLike(arg2)) {
+        const base = { type: 'record', index: arg1, child: arg2 };
+        if (isFormatParams(arg3)) {
+            return (0, builderCore_ts_1.builderResult)(arg4, base);
+        }
+        return (0, builderCore_ts_1.builderResult)(arg3, base);
+    }
+    const base = { type: 'record', child: arg1 };
+    if (isFormatParams(arg2)) {
+        return (0, builderCore_ts_1.builderResult)(arg3, base);
+    }
+    return (0, builderCore_ts_1.builderResult)(arg2, base);
+}
+function map(keySchema, valueSchema, arg3, arg4) {
+    const base = { type: 'map', index: keySchema, child: valueSchema };
+    if (isFormatParams(arg3))
+        return (0, builderCore_ts_1.builderResult)(arg4, base);
+    return (0, builderCore_ts_1.builderResult)(arg3, base);
+}
+function set(valueSchema, arg2, arg3) {
+    const base = { type: 'set', child: valueSchema };
+    if (isFormatParams(arg2))
+        return (0, builderCore_ts_1.builderResult)(arg3, base);
+    return (0, builderCore_ts_1.builderResult)(arg2, base);
+}
+function self(id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'self' });
+}
+function circular(body, id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'circular', child: body });
+}
+function promise(valueSchema, id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'promise', child: valueSchema });
+}
+function func(parts, id) {
+    const params = parts?.params;
+    const parameters = Array.isArray(params) ? params.map(slotChild) : (params ?? []);
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'function', parameters, return: parts?.ret });
+}
+function callable(fn, iface, id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'intersection', children: [fn, iface] });
+}
+function templateLiteral(parts, id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'templateLiteral', children: parts });
+}
+function propMod(modifiers, field) {
+    return { __propMod: modifiers, __field: field };
+}
+function optional(field) {
+    return propMod({ optional: true }, field);
+}
+function object(config, arg2, arg3) {
+    if (isFormatParams(arg2)) {
+        return (0, builderCore_ts_1.builderResult)(arg3, config);
+    }
+    return (0, builderCore_ts_1.builderResult)(arg2, config);
+}

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

@@ -0,0 +1,5 @@
+export { boolean, literal, regexp, symbol, any, unknown, never, voidType, voidType as void, classType, enumType, enumType as enum, } from './atomic.ts';
+export { object, array, tuple, slot, union, anyOf, intersection, record, map, set, promise, circular, self, func, callable, templateLiteral, propMod, optional, } from './compose.ts';
+export { partial, required, pick, omit, exclude, extract, nonNullable, readonlyType, readonlyType as readonly, returnType, parameters, } from './utility.ts';
+export type { PropModifiers, MapTuple, TemplatePart, AssembleTemplate, AnyOf } from './static.ts';
+import '../runtypes/pure-fns-utils.ts';

package/dist/cjs/builders/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parameters = exports.returnType = exports.readonly = exports.readonlyType = exports.nonNullable = exports.extract = exports.exclude = exports.omit = exports.pick = exports.required = exports.partial = exports.optional = exports.propMod = exports.templateLiteral = exports.callable = exports.func = exports.self = exports.circular = exports.promise = exports.set = exports.map = exports.record = exports.intersection = exports.anyOf = exports.union = exports.slot = exports.tuple = exports.array = exports.object = exports.enum = exports.enumType = exports.classType = exports.void = exports.voidType = exports.never = exports.unknown = exports.any = exports.symbol = exports.regexp = exports.literal = exports.boolean = void 0;
+var atomic_ts_1 = require("./atomic.js");
+Object.defineProperty(exports, "boolean", { enumerable: true, get: function () { return atomic_ts_1.boolean; } });
+Object.defineProperty(exports, "literal", { enumerable: true, get: function () { return atomic_ts_1.literal; } });
+Object.defineProperty(exports, "regexp", { enumerable: true, get: function () { return atomic_ts_1.regexp; } });
+Object.defineProperty(exports, "symbol", { enumerable: true, get: function () { return atomic_ts_1.symbol; } });
+Object.defineProperty(exports, "any", { enumerable: true, get: function () { return atomic_ts_1.any; } });
+Object.defineProperty(exports, "unknown", { enumerable: true, get: function () { return atomic_ts_1.unknown; } });
+Object.defineProperty(exports, "never", { enumerable: true, get: function () { return atomic_ts_1.never; } });
+Object.defineProperty(exports, "voidType", { enumerable: true, get: function () { return atomic_ts_1.voidType; } });
+Object.defineProperty(exports, "void", { enumerable: true, get: function () { return atomic_ts_1.voidType; } });
+Object.defineProperty(exports, "classType", { enumerable: true, get: function () { return atomic_ts_1.classType; } });
+Object.defineProperty(exports, "enumType", { enumerable: true, get: function () { return atomic_ts_1.enumType; } });
+Object.defineProperty(exports, "enum", { enumerable: true, get: function () { return atomic_ts_1.enumType; } });
+var compose_ts_1 = require("./compose.js");
+Object.defineProperty(exports, "object", { enumerable: true, get: function () { return compose_ts_1.object; } });
+Object.defineProperty(exports, "array", { enumerable: true, get: function () { return compose_ts_1.array; } });
+Object.defineProperty(exports, "tuple", { enumerable: true, get: function () { return compose_ts_1.tuple; } });
+Object.defineProperty(exports, "slot", { enumerable: true, get: function () { return compose_ts_1.slot; } });
+Object.defineProperty(exports, "union", { enumerable: true, get: function () { return compose_ts_1.union; } });
+Object.defineProperty(exports, "anyOf", { enumerable: true, get: function () { return compose_ts_1.anyOf; } });
+Object.defineProperty(exports, "intersection", { enumerable: true, get: function () { return compose_ts_1.intersection; } });
+Object.defineProperty(exports, "record", { enumerable: true, get: function () { return compose_ts_1.record; } });
+Object.defineProperty(exports, "map", { enumerable: true, get: function () { return compose_ts_1.map; } });
+Object.defineProperty(exports, "set", { enumerable: true, get: function () { return compose_ts_1.set; } });
+Object.defineProperty(exports, "promise", { enumerable: true, get: function () { return compose_ts_1.promise; } });
+Object.defineProperty(exports, "circular", { enumerable: true, get: function () { return compose_ts_1.circular; } });
+Object.defineProperty(exports, "self", { enumerable: true, get: function () { return compose_ts_1.self; } });
+Object.defineProperty(exports, "func", { enumerable: true, get: function () { return compose_ts_1.func; } });
+Object.defineProperty(exports, "callable", { enumerable: true, get: function () { return compose_ts_1.callable; } });
+Object.defineProperty(exports, "templateLiteral", { enumerable: true, get: function () { return compose_ts_1.templateLiteral; } });
+Object.defineProperty(exports, "propMod", { enumerable: true, get: function () { return compose_ts_1.propMod; } });
+Object.defineProperty(exports, "optional", { enumerable: true, get: function () { return compose_ts_1.optional; } });
+var utility_ts_1 = require("./utility.js");
+Object.defineProperty(exports, "partial", { enumerable: true, get: function () { return utility_ts_1.partial; } });
+Object.defineProperty(exports, "required", { enumerable: true, get: function () { return utility_ts_1.required; } });
+Object.defineProperty(exports, "pick", { enumerable: true, get: function () { return utility_ts_1.pick; } });
+Object.defineProperty(exports, "omit", { enumerable: true, get: function () { return utility_ts_1.omit; } });
+Object.defineProperty(exports, "exclude", { enumerable: true, get: function () { return utility_ts_1.exclude; } });
+Object.defineProperty(exports, "extract", { enumerable: true, get: function () { return utility_ts_1.extract; } });
+Object.defineProperty(exports, "nonNullable", { enumerable: true, get: function () { return utility_ts_1.nonNullable; } });
+Object.defineProperty(exports, "readonlyType", { enumerable: true, get: function () { return utility_ts_1.readonlyType; } });
+Object.defineProperty(exports, "readonly", { enumerable: true, get: function () { return utility_ts_1.readonlyType; } });
+Object.defineProperty(exports, "returnType", { enumerable: true, get: function () { return utility_ts_1.returnType; } });
+Object.defineProperty(exports, "parameters", { enumerable: true, get: function () { return utility_ts_1.parameters; } });
+require("../runtypes/pure-fns-utils.js");

package/dist/cjs/builders/static.d.ts

@@ -0,0 +1,137 @@
+import type { __rtFormatName, __rtFormatParams, __rtFormatBrand, __rtContains, __rtPatternProps, __rtPropNames, __rtLabels } from '../runtypes/sentinelKeys.ts';
+import type { RunType } from '../runtypes/types.ts';
+import type { InferType } from '../runtypes/builderTypes.ts';
+export type { InferType, LeafType, LeafTypeByFormatName, LeafFormatName, BrandArg, TemporalFormatByTag, TemporalBaseByTag, TemporalBuilderFn, } from '../runtypes/builderTypes.ts';
+export interface PropModifiers {
+    optional?: true;
+    readonly?: true;
+}
+export interface PropModCarrier<M extends PropModifiers, F> {
+    readonly __propMod: M;
+    readonly __field: F;
+}
+export type FieldOf<V> = V extends {
+    __propMod: PropModifiers;
+    __field: unknown;
+} ? InferType<V['__field']> : InferType<V>;
+export type IsOptional<V> = V extends {
+    __propMod: {
+        optional: true;
+    };
+} ? true : false;
+export type IsReadonly<V> = V extends {
+    __propMod: {
+        readonly: true;
+    };
+} ? true : false;
+type Flatten<T> = {
+    [K in keyof T]: T[K];
+};
+type AnyOptional<C> = true extends {
+    [K in keyof C]: IsOptional<C[K]>;
+}[keyof C] ? true : false;
+type AnyReadonly<C> = true extends {
+    [K in keyof C]: IsReadonly<C[K]>;
+}[keyof C] ? true : false;
+type ObjectOptionalOnly<C> = Flatten<{
+    -readonly [K in keyof C as IsOptional<C[K]> extends true ? never : K]: FieldOf<C[K]>;
+} & {
+    -readonly [K in keyof C as IsOptional<C[K]> extends true ? K : never]?: FieldOf<C[K]>;
+}>;
+type ObjectReadonlyOnly<C> = Flatten<{
+    -readonly [K in keyof C as IsReadonly<C[K]> extends true ? never : K]: FieldOf<C[K]>;
+} & {
+    readonly [K in keyof C as IsReadonly<C[K]> extends true ? K : never]: FieldOf<C[K]>;
+}>;
+type ObjectMixed<C> = Flatten<{
+    -readonly [K in keyof C as IsOptional<C[K]> extends true ? never : IsReadonly<C[K]> extends true ? never : K]: FieldOf<C[K]>;
+} & {
+    readonly [K in keyof C as IsOptional<C[K]> extends true ? never : IsReadonly<C[K]> extends true ? K : never]: FieldOf<C[K]>;
+} & {
+    -readonly [K in keyof C as IsOptional<C[K]> extends true ? (IsReadonly<C[K]> extends true ? never : K) : never]?: FieldOf<C[K]>;
+} & {
+    readonly [K in keyof C as IsOptional<C[K]> extends true ? (IsReadonly<C[K]> extends true ? K : never) : never]?: FieldOf<C[K]>;
+}>;
+export type ObjectType<C> = AnyOptional<C> extends false ? AnyReadonly<C> extends false ? {
+    -readonly [K in keyof C]: FieldOf<C[K]>;
+} : ObjectReadonlyOnly<C> : AnyReadonly<C> extends false ? ObjectOptionalOnly<C> : ObjectMixed<C>;
+export type MapTuple<T extends readonly RunType[]> = {
+    -readonly [K in keyof T]: InferType<T[K]>;
+};
+export interface SlotCarrier<Label extends string, Value> {
+    readonly __slotLabel: Label;
+    readonly __slotValue: RunType<Value>;
+}
+export type SlotValues<Slots extends readonly SlotCarrier<string, unknown>[]> = {
+    -readonly [K in keyof Slots]: InferType<Slots[K]['__slotValue']>;
+};
+export type SlotLabels<Slots extends readonly SlotCarrier<string, unknown>[]> = {
+    -readonly [K in keyof Slots]: Slots[K]['__slotLabel'];
+};
+export type LabeledTuple<Slots extends readonly SlotCarrier<string, unknown>[], OptionalSlots extends readonly SlotCarrier<string, unknown>[] = []> = [...SlotValues<Slots>, ...Partial<SlotValues<OptionalSlots>>] & {
+    readonly [__rtLabels]?: readonly [...SlotLabels<Slots>, ...SlotLabels<OptionalSlots>];
+};
+export type LabeledRestTuple<Slots extends readonly SlotCarrier<string, unknown>[], OptionalSlots extends readonly SlotCarrier<string, unknown>[], RestLabel extends string, Rest> = [...SlotValues<Slots>, ...Partial<SlotValues<OptionalSlots>>, ...Rest[]] & {
+    readonly [__rtLabels]?: readonly [...SlotLabels<Slots>, ...SlotLabels<OptionalSlots>, RestLabel];
+};
+export type TupleFromGroups<Items extends readonly RunType[], OptionalItems extends readonly RunType[], Rest> = [Rest] extends [
+    never
+] ? [...MapTuple<Items>, ...Partial<MapTuple<OptionalItems>>] : [...MapTuple<Items>, ...Partial<MapTuple<OptionalItems>>, ...Rest[]];
+export type LabeledTupleFromGroups<Slots extends readonly SlotCarrier<string, unknown>[], OptionalSlots extends readonly SlotCarrier<string, unknown>[], RestLabel extends string, Rest> = [RestLabel] extends [never] ? LabeledTuple<Slots, OptionalSlots> : LabeledRestTuple<Slots, OptionalSlots, RestLabel, Rest>;
+export type FuncFromParams<Params extends readonly RunType[], Return> = Params extends readonly [] ? () => Return : (...args: MapTuple<Params>) => Return;
+export type UnionOf<T extends readonly RunType[]> = InferType<T[number]>;
+export type AnyOf<Branches extends readonly [unknown, ...unknown[]]> = Branches[number];
+export type IntersectionOf<T extends readonly RunType[]> = T extends readonly [
+    infer Head extends RunType,
+    ...infer Tail extends readonly RunType[]
+] ? InferType<Head> & IntersectionOf<Tail> : unknown;
+export type TemplatePart = string | RunType;
+type Interpolatable = string | number | bigint | boolean | null | undefined;
+type Unbrand<X> = typeof __rtFormatName extends keyof X ? X extends string ? string : X extends number ? number : X extends bigint ? bigint : X & Interpolatable : X & Interpolatable;
+type PartText<Part extends TemplatePart> = Part extends RunType ? Unbrand<InferType<Part>> : Part & Interpolatable;
+export type AssembleTemplate<P extends readonly TemplatePart[]> = P extends readonly [
+    infer Head extends TemplatePart,
+    ...infer Tail extends readonly TemplatePart[]
+] ? `${PartText<Head>}${AssembleTemplate<Tail>}` : '';
+declare const SelfBrand: unique symbol;
+export type Self = {
+    readonly [SelfBrand]: true;
+};
+export type CarriedKey = typeof __rtFormatName | typeof __rtFormatParams | typeof __rtFormatBrand | typeof __rtContains | typeof __rtPatternProps | typeof __rtPropNames | typeof __rtLabels;
+type HasCarried<T> = [Extract<keyof T, CarriedKey>] extends [never] ? false : true;
+type CarrySlots<T, P extends [unknown]> = {
+    readonly [K in Extract<keyof T, CarriedKey>]?: SubstituteSelf<NonNullable<T[K]>, P>;
+};
+type ContainsSelf<T, Depth extends unknown[] = []> = AnyTrue<ContainsSelfIn<T, Depth>>;
+type AnyTrue<B> = [B] extends [never] ? false : [B] extends [false] ? false : true;
+type ContainsSelfIn<T, Depth extends unknown[]> = Depth['length'] extends 24 ? false : 0 extends 1 & T ? false : T extends Self ? true : T extends string | number | boolean | bigint | symbol | null | undefined ? false : T extends Date | RegExp ? false : T extends Map<any, any> ? T extends Map<infer K, infer V> ? AnyTrue<ContainsSelfIn<K, Next<Depth>> | ContainsSelfIn<V, Next<Depth>>> : false : T extends Set<any> ? T extends Set<infer E> ? ContainsSelf<E, Next<Depth>> : false : T extends Promise<infer E> ? ContainsSelf<E, Next<Depth>> : T extends (...args: infer A extends readonly unknown[]) => infer R ? AnyTrue<ContainsSelfIn<A[number], Next<Depth>> | ContainsSelfIn<R, Next<Depth>>> : T extends readonly unknown[] ? number extends T['length'] ? ContainsSelf<T[number], Next<Depth>> : AnyTrue<MembersContainSelf<MemberBoxes<T>[number], Depth>> : T extends object ? AnyTrue<MembersContainSelf<MemberBoxes<T>[keyof T], Depth>> : false;
+type Next<Depth extends unknown[]> = [...Depth, unknown];
+type MemberBoxes<T> = {
+    [K in keyof T]: [T[K]];
+};
+type MembersContainSelf<Boxed, Depth extends unknown[]> = Boxed extends [infer Member] ? ContainsSelf<Member, Next<Depth>> : false;
+type SubstituteSelf<T, P extends [unknown]> = T extends Self ? P[0] : T extends string | number | boolean | bigint | symbol | null | undefined ? T : T extends Date | RegExp ? T : ContainsSelf<T> extends false ? T : SubstituteInto<T, P>;
+type SubstituteInto<T, P extends [unknown]> = T extends Map<any, any> ? T extends Map<infer K, infer V> ? CarryOnto<Map<SubstituteSelf<K, P>, SubstituteSelf<V, P>>, T, P> : never : T extends Set<any> ? T extends Set<infer E> ? CarryOnto<Set<SubstituteSelf<E, P>>, T, P> : never : T extends Promise<infer E> ? Promise<SubstituteSelf<E, P>> : T extends (...args: infer A extends readonly unknown[]) => infer R ? (...args: SubstituteTuple<A, P>) => SubstituteSelf<R, P> : T extends readonly unknown[] ? number extends T['length'] ? T extends readonly (infer E)[] ? CarryOnto<T extends unknown[] ? SubstituteSelf<E, P>[] : readonly SubstituteSelf<E, P>[], T, P> : never : T extends unknown[] ? SubstituteTuple<T, P> : Readonly<SubstituteTuple<T, P>> : T extends object ? HasCarried<T> extends true ? {
+    [K in keyof T as K extends CarriedKey ? never : K]: SubstituteSelf<T[K], P>;
+} & CarrySlots<T, P> : {
+    [K in keyof T]: SubstituteSelf<T[K], P>;
+} : T;
+type CarryOnto<Base, Source, P extends [unknown]> = HasCarried<Source> extends true ? Base & CarrySlots<Source, P> : Base;
+type SubstituteTuple<T extends readonly unknown[], P extends [unknown]> = HasCarried<T> extends true ? IsFixedArity<T> extends true ? TupleFromIndexes<T, P, RequiredArity<T>> & CarrySlots<T, P> : [
+    ...TupleFromIndexes<T, P, RequiredArity<T>>,
+    ...Partial<OptionalSlots<T, P> extends infer Slots extends unknown[] ? Slots : []>
+] & CarrySlots<T, P> : {
+    -readonly [K in keyof T]: SubstituteSelf<T[K], P>;
+};
+type IsFixedArity<T extends readonly unknown[]> = IsUnion<T['length']> extends true ? false : true;
+type IsUnion<X, All = X> = X extends unknown ? ([All] extends [X] ? false : true) : never;
+type RequiredArity<T extends readonly unknown[], Acc extends unknown[] = []> = Acc['length'] extends T['length'] ? Acc : RequiredArity<T, [...Acc, unknown]>;
+type TotalArity<T extends readonly unknown[], Acc extends unknown[] = RequiredArity<T>> = [
+    ...Acc,
+    unknown
+]['length'] extends T['length'] ? TotalArity<T, [...Acc, unknown]> : Acc;
+type TupleFromIndexes<T, P extends [unknown], Stop extends unknown[], Acc extends unknown[] = []> = Acc['length'] extends Stop['length'] ? Acc : TupleFromIndexes<T, P, Stop, [...Acc, SubstituteSelf<T[Acc['length'] & keyof T], P>]>;
+type OptionalSlots<T extends readonly unknown[], P extends [unknown]> = DropRequired<OptionalCandidates<T, P, TotalArity<T>>, RequiredArity<T>>;
+type OptionalCandidates<T, P extends [unknown], Stop extends unknown[], Acc extends unknown[] = []> = Acc['length'] extends Stop['length'] ? Acc : OptionalCandidates<T, P, Stop, [...Acc, SubstituteSelf<NonNullable<T[Acc['length'] & keyof T]>, P>]>;
+type DropRequired<All extends unknown[], Skip extends unknown[]> = Skip['length'] extends 0 ? All : All extends [unknown, ...infer Rest] ? Skip extends [unknown, ...infer SkipRest] ? DropRequired<Rest, SkipRest extends unknown[] ? SkipRest : []> : All : [];
+export type Recursive<Body> = SubstituteSelf<Body, [Recursive<Body>]>;

package/dist/cjs/builders/static.js

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

package/dist/cjs/builders/utility.d.ts

@@ -0,0 +1,12 @@
+import type { RunType } from '../runtypes/types.ts';
+import type { InjectRunTypeId, CompTimeArgs } from '../markers.ts';
+export declare function partial<T>(model: CompTimeArgs<RunType<T>>, id?: InjectRunTypeId<Partial<T>>): RunType<Partial<T>>;
+export declare function required<T>(model: CompTimeArgs<RunType<T>>, id?: InjectRunTypeId<Required<T>>): RunType<Required<T>>;
+export declare function readonlyType<T>(model: CompTimeArgs<RunType<T>>, id?: InjectRunTypeId<Readonly<T>>): RunType<Readonly<T>>;
+export declare function nonNullable<T>(rt: CompTimeArgs<RunType<T>>, id?: InjectRunTypeId<NonNullable<T>>): RunType<NonNullable<T>>;
+export declare function returnType<F extends (...args: any[]) => any>(fnRt: CompTimeArgs<RunType<F>>, id?: InjectRunTypeId<ReturnType<F>>): RunType<ReturnType<F>>;
+export declare function pick<T, const K extends readonly (keyof T)[]>(model: CompTimeArgs<RunType<T>>, keys: CompTimeArgs<K>, id?: InjectRunTypeId<Pick<T, K[number]>>): RunType<Pick<T, K[number]>>;
+export declare function omit<T, const K extends readonly (keyof T)[]>(model: CompTimeArgs<RunType<T>>, keys: CompTimeArgs<K>, id?: InjectRunTypeId<Omit<T, K[number]>>): RunType<Omit<T, K[number]>>;
+export declare function exclude<U, X>(union: CompTimeArgs<RunType<U>>, removed: CompTimeArgs<RunType<X>>, id?: InjectRunTypeId<Exclude<U, X>>): RunType<Exclude<U, X>>;
+export declare function extract<U, X>(union: CompTimeArgs<RunType<U>>, extracted: CompTimeArgs<RunType<X>>, id?: InjectRunTypeId<Extract<U, X>>): RunType<Extract<U, X>>;
+export declare function parameters<F extends (...args: any[]) => any>(fnRt: CompTimeArgs<RunType<F>>, id?: InjectRunTypeId<Parameters<F>>): RunType<Parameters<F>>;

package/dist/cjs/builders/utility.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.partial = partial;
+exports.required = required;
+exports.readonlyType = readonlyType;
+exports.nonNullable = nonNullable;
+exports.returnType = returnType;
+exports.pick = pick;
+exports.omit = omit;
+exports.exclude = exclude;
+exports.extract = extract;
+exports.parameters = parameters;
+const builderCore_ts_1 = require("../runtypes/builderCore.js");
+function partial(model, id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'partial', child: model });
+}
+function required(model, id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'required', child: model });
+}
+function readonlyType(model, id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'readonly', child: model });
+}
+function nonNullable(rt, id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'nonNullable', child: rt });
+}
+function returnType(fnRt, id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'returnType', child: fnRt });
+}
+function pick(model, keys, id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'pick', child: model, keys });
+}
+function omit(model, keys, id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'omit', child: model, keys });
+}
+function exclude(union, removed, id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'exclude', child: union, excluded: removed });
+}
+function extract(union, extracted, id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'extract', child: union, extracted });
+}
+function parameters(fnRt, id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'parameters', child: fnRt });
+}

package/dist/cjs/createRTFunctions.d.ts

@@ -0,0 +1,90 @@
+import type { RunType } from './runtypes/types.ts';
+import type { DataOnly } from './runtypes/dataOnly.ts';
+import type { JSONShape } from './runtypes/jsonShape.ts';
+import type { FormatErrorsOf } from './runtypes/formatErrors.ts';
+import type { CompTimeFnArgs, InjectTypeFnArgs } from './index.ts';
+export interface ValidateOptions {
+    rejectCircularRefs?: boolean;
+    checkUnknowns?: boolean;
+    checkUnionUnknowns?: boolean;
+    numberMode?: 'isFinite' | 'typeof' | 'notNaN';
+}
+export type ValidateFn<T = unknown> = (value: unknown) => value is DataOnly<T>;
+export interface RTPathSegment {
+    key: number;
+    failed?: 'mapKey' | 'mapValue' | 'setKey';
+}
+export type RTValidationErrorPathSegment = string | number | RTPathSegment;
+export interface TypeFormatError<Name extends string = string, Mode extends string = string> {
+    name: Name;
+    val: RTValidationErrorPathSegment | boolean | bigint | (RTValidationErrorPathSegment | boolean | bigint)[];
+    formatPath: (string | number)[];
+    errorType?: Mode;
+    isCurrency?: boolean;
+}
+export interface RTValidationError<Format extends TypeFormatError = TypeFormatError> {
+    path: RTValidationErrorPathSegment[];
+    expected: string;
+    format?: Format;
+}
+export type GetValidationErrorsFn<Format extends TypeFormatError = TypeFormatError> = (value: unknown, path?: RTValidationErrorPathSegment[], errors?: RTValidationError[]) => RTValidationError<Format>[];
+export type RemoveUnknownKeysFn<T = unknown> = (value: T) => T;
+export interface RemoveUnknownKeysOptions {
+    sharedValues?: 'share' | 'refuse';
+}
+export type FormatTransformValue<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends readonly (infer E)[] ? FormatTransformValue<E>[] : T extends object ? {
+    [K in keyof T]: FormatTransformValue<T[K]>;
+} : T;
+export type FormatTransformFn<T> = (value: FormatTransformValue<T>) => FormatTransformValue<T>;
+export type PrepareForJsonFn<T = unknown> = (value: T) => JSONShape<T>;
+export type RestoreFromJsonFn<T = unknown> = (value: unknown) => DataOnly<T>;
+export type JsonEncoderFn = (value: unknown) => string | undefined;
+export type JsonDecoderFn<T = unknown> = (serialized: string) => T;
+export type JsonValueStrategy = 'clone' | 'mutate' | 'compact';
+export type PrepareForJsonOptions = {
+    strategy?: JsonValueStrategy;
+};
+export type RestoreFromJsonOptions = {
+    strategy?: JsonValueStrategy;
+};
+export type JsonEncoderStrategy = JsonValueStrategy;
+export type JsonEncoderOptions = {
+    strategy?: JsonEncoderStrategy;
+    rejectCircularRefs?: boolean;
+};
+export type JsonDecoderStrategy = JsonValueStrategy;
+export type JsonDecoderOptions = {
+    strategy?: JsonDecoderStrategy;
+};
+export declare const createValidateFn: (<T>(runType: RunType<T>, options?: CompTimeFnArgs<ValidateOptions>, id?: InjectTypeFnArgs<T, "validate">) => ValidateFn<T>) & (<T>(val?: T, options?: CompTimeFnArgs<ValidateOptions>, id?: InjectTypeFnArgs<T, "validate">) => ValidateFn<T>);
+export declare const createGetValidationErrorsFn: (<T>(runType: RunType<T>, options?: CompTimeFnArgs<ValidateOptions>, id?: InjectTypeFnArgs<T, "validationErrors">) => GetValidationErrorsFn<FormatErrorsOf<T>>) & (<T>(val?: T, options?: CompTimeFnArgs<ValidateOptions>, id?: InjectTypeFnArgs<T, "validationErrors">) => GetValidationErrorsFn<FormatErrorsOf<T>>);
+export declare const createRemoveUnknownKeysFn: (<T>(runType: RunType<T>, options?: CompTimeFnArgs<RemoveUnknownKeysOptions>, id?: InjectTypeFnArgs<T, "removeUnknownKeys">) => RemoveUnknownKeysFn<T>) & (<T>(val?: T, options?: CompTimeFnArgs<RemoveUnknownKeysOptions>, id?: InjectTypeFnArgs<T, "removeUnknownKeys">) => RemoveUnknownKeysFn<T>);
+export declare const createPrepareForJsonFn: (<T>(runType: RunType<T>, options?: CompTimeFnArgs<PrepareForJsonOptions>, id?: InjectTypeFnArgs<T, "prepareForJsonClone">) => PrepareForJsonFn<T>) & (<T>(val?: T, options?: CompTimeFnArgs<PrepareForJsonOptions>, id?: InjectTypeFnArgs<T, "prepareForJsonClone">) => PrepareForJsonFn<T>);
+export declare const createRestoreFromJsonFn: (<T>(runType: RunType<T>, options?: CompTimeFnArgs<RestoreFromJsonOptions>, id?: InjectTypeFnArgs<T, "restoreFromJsonClone">) => RestoreFromJsonFn<T>) & (<T>(val?: T, options?: CompTimeFnArgs<RestoreFromJsonOptions>, id?: InjectTypeFnArgs<T, "restoreFromJsonClone">) => RestoreFromJsonFn<T>);
+export declare const createFormatTransformFn: (<T>(runType: RunType<T>, id?: InjectTypeFnArgs<T, "formatTransform">) => FormatTransformFn<T>) & (<T>(val?: T, id?: InjectTypeFnArgs<T, "formatTransform">) => FormatTransformFn<T>);
+export declare function createJsonEncoderFn<T>(runType: RunType<T>, options?: CompTimeFnArgs<JsonEncoderOptions>, id?: InjectTypeFnArgs<T, 'jsonEncoder'>): JsonEncoderFn;
+export declare function createJsonEncoderFn<T>(val?: T, options?: CompTimeFnArgs<JsonEncoderOptions>, id?: InjectTypeFnArgs<T, 'jsonEncoder'>): JsonEncoderFn;
+export declare function createJsonDecoderFn<T>(runType: RunType<T>, options?: CompTimeFnArgs<JsonDecoderOptions>, id?: InjectTypeFnArgs<T, 'jsonDecoder'>): JsonDecoderFn<DataOnly<T>>;
+export declare function createJsonDecoderFn<T>(val?: T, options?: CompTimeFnArgs<JsonDecoderOptions>, id?: InjectTypeFnArgs<T, 'jsonDecoder'>): JsonDecoderFn<DataOnly<T>>;
+export interface RTFunctionByKey {
+    validate: ValidateFn;
+    validationErrors: GetValidationErrorsFn;
+    validateStrict: ValidateFn;
+    validationErrorsStrict: GetValidationErrorsFn;
+    validateUnionKeys: ValidateFn;
+    validationErrorsUnionKeys: GetValidationErrorsFn;
+    removeUnknownKeys: RemoveUnknownKeysFn;
+    removeUnknownKeysShared: RemoveUnknownKeysFn;
+    removeUnknownKeysRefuse: RemoveUnknownKeysFn;
+    formatTransform: FormatTransformFn<unknown>;
+    jsonEncoder: JsonEncoderFn;
+    jsonDecoder: JsonDecoderFn;
+    prepareForJsonMutate: PrepareForJsonFn;
+    prepareForJsonClone: PrepareForJsonFn;
+    restoreFromJsonMutate: RestoreFromJsonFn;
+    restoreFromJsonClone: RestoreFromJsonFn;
+    compactForJson: PrepareForJsonFn;
+    compactFromJson: RestoreFromJsonFn;
+}
+export type RTFunctionKey = keyof RTFunctionByKey;
+export declare function getRTFunction<K extends RTFunctionKey>(injected: unknown, fallback?: RTFunctionByKey[K]): RTFunctionByKey[K];