@buckeyestudio/omptype 18.4.13

package/src/typebox.ts

@@ -0,0 +1,545 @@
+import { OmpTypeError } from "./errors";
+import type { Def, EmbeddableSchema } from "./ir";
+import { type NarrowContext, type Type as OmpType, type ToJsonSchemaOptions, type } from "./type";
+
+export interface Meta {
+	title?: string;
+	description?: string;
+	default?: unknown;
+	examples?: unknown[];
+	[key: string]: unknown;
+}
+
+export interface StringOpts extends Meta {
+	minLength?: number;
+	maxLength?: number;
+	pattern?: string;
+	format?: string;
+}
+
+export interface NumberOpts extends Meta {
+	minimum?: number;
+	maximum?: number;
+	exclusiveMinimum?: number;
+	exclusiveMaximum?: number;
+	multipleOf?: number;
+}
+
+export interface ArrayOpts extends Meta {
+	minItems?: number;
+	maxItems?: number;
+	uniqueItems?: boolean;
+}
+
+export interface ObjectOpts extends Meta {
+	additionalProperties?: boolean | AnySchema;
+}
+const OPTIONAL_INNER = Symbol("omptype.typebox.optionalInner");
+const OBJECT_INFO = Symbol("omptype.typebox.objectInfo");
+
+export interface TypeBoxValidationFailure {
+	message: string;
+}
+
+export type TypeBoxSafeParseResult<T> =
+	| { success: true; data: T }
+	| { success: false; error: TypeBoxValidationFailure };
+
+interface LegacyTypeBoxCompat<T> {
+	/** TypeBox compatibility validator used by legacy extension loaders. */
+	__validator(data: unknown): T | TypeBoxValidationFailure;
+	/** Zod-style compatibility parser used by legacy extensions. */
+	safeParse(input: unknown): TypeBoxSafeParseResult<T>;
+}
+
+/**
+ * Erased schema surface accepted anywhere this facade takes a schema, native
+ * omptype schemas included (those carry no legacy compat members).
+ *
+ * Members use method syntax so parameter positions stay bivariant: the typed
+ * {@link TTyped} form is invariant in its static type (its `in`/`out`
+ * validators are), so a concrete `TString` is not assignable to
+ * `TTyped<unknown>`. Erasing here is what keeps `TString`, `TObject<…>` and
+ * friends assignable to a plain schema annotation.
+ */
+export interface AnySchema extends EmbeddableSchema {
+	(data: unknown): unknown;
+	readonly infer: unknown;
+	readonly hasSteps: boolean;
+	toJsonSchema(options?: ToJsonSchemaOptions): Record<string, unknown>;
+}
+
+/**
+ * Every schema this facade returns: the TypeBox `TSchema` analog. Erased like
+ * {@link AnySchema}, plus the legacy compat members builder results carry.
+ */
+export interface TSchema extends AnySchema {
+	/** TypeBox compatibility validator used by legacy extension loaders. */
+	__validator(data: unknown): unknown;
+	/** Zod-style compatibility parser used by legacy extensions. */
+	safeParse(input: unknown): TypeBoxSafeParseResult<unknown>;
+}
+
+/** Schema carrying a statically known type; every `TXxx` alias resolves here. */
+export type TTyped<T> = OmpType<T> & LegacyTypeBoxCompat<T>;
+export type Static<T extends AnySchema> = T["infer"];
+export type TAny = TTyped<unknown>;
+export type TUnknown = TTyped<unknown>;
+export type TNever = TTyped<never>;
+export type TNull = TTyped<null>;
+export type TString = TTyped<string>;
+export type TNumber = TTyped<number>;
+export type TInteger = TTyped<number>;
+export type TBoolean = TTyped<boolean>;
+export type TLiteral<V extends string | number | boolean | null> = TTyped<V>;
+export type TArray<E extends AnySchema> = TTyped<Static<E>[]>;
+export type TTuple<E extends readonly AnySchema[] = readonly AnySchema[]> = TTyped<{
+	-readonly [K in keyof E]: Static<E[K]>;
+}>;
+export type TOptional<E extends AnySchema> = TTyped<Static<E> | undefined> & { readonly [OPTIONAL_INNER]: E };
+export type TUnion<E extends readonly AnySchema[] = readonly AnySchema[]> = TTyped<Static<E[number]>>;
+export type TIntersect<E extends readonly AnySchema[] = readonly AnySchema[]> = TTyped<
+	UnionToIntersection<Static<E[number]>>
+>;
+export type TEnum<E extends readonly (string | number)[] = readonly (string | number)[]> = TTyped<E[number]>;
+export type TRecord<K extends AnySchema, V extends AnySchema> = TTyped<
+	Record<Extract<Static<K>, PropertyKey>, Static<V>>
+>;
+export type TNullable<E extends AnySchema> = TTyped<Static<E> | null>;
+export type TReadonly<E extends AnySchema> = TTyped<Readonly<Static<E>>>;
+export type TUnsafe<T = unknown> = TTyped<T>;
+
+type OptionalKeys<P extends Record<string, AnySchema>> = {
+	[K in keyof P]-?: P[K] extends { readonly [OPTIONAL_INNER]: AnySchema } ? K : never;
+}[keyof P];
+type RequiredKeys<P extends Record<string, AnySchema>> = Exclude<keyof P, OptionalKeys<P>>;
+type ObjectStatic<P extends Record<string, AnySchema>> = {
+	[K in RequiredKeys<P>]: Static<P[K]>;
+} & {
+	[K in OptionalKeys<P>]?: Exclude<Static<P[K]>, undefined>;
+};
+export type TObject<P extends Record<string, AnySchema> = Record<string, AnySchema>> = TTyped<ObjectStatic<P>>;
+type RequiredProps<P extends Record<string, AnySchema>> = {
+	[K in keyof P]: P[K] extends TOptional<infer E> ? E : P[K];
+};
+
+interface RuntimeType<T> extends OmpType<T> {
+	[OPTIONAL_INNER]?: AnySchema;
+	[OBJECT_INFO]?: ObjectInfo;
+	describe(description: string): RuntimeType<T>;
+	default(value: T | (() => T)): RuntimeType<T>;
+	or<schema extends AnySchema>(schema: schema): RuntimeType<T | Static<schema>>;
+	and<schema extends AnySchema>(schema: schema): RuntimeType<T & Static<schema>>;
+	array(): RuntimeType<T[]>;
+	atLeastLength(bound: number): RuntimeType<T>;
+	atMostLength(bound: number): RuntimeType<T>;
+	atLeast(bound: number): RuntimeType<T>;
+	atMost(bound: number): RuntimeType<T>;
+	narrow<N extends T>(predicate: (value: T, ctx: NarrowContext) => value is N): RuntimeType<N>;
+	narrow(predicate: (value: T, ctx: NarrowContext) => boolean): RuntimeType<T>;
+}
+type CompatRuntime<T> = RuntimeType<T> & LegacyTypeBoxCompat<T>;
+
+type ObjectInfo = {
+	props: Record<string, AnySchema>;
+	additionalProperties?: boolean | AnySchema;
+};
+
+function asRuntime<T>(schema: AnySchema): RuntimeType<T> {
+	return schema as unknown as RuntimeType<T>;
+}
+
+function asSchema<T>(schema: AnySchema): TTyped<T> {
+	return schema as unknown as TTyped<T>;
+}
+
+function validationFailure(message: string): TypeBoxValidationFailure {
+	return { message };
+}
+
+function withLegacyCompat<T>(schema: OmpType<T>): CompatRuntime<T> {
+	const compatSchema = schema as unknown as CompatRuntime<T>;
+	if (!Object.hasOwn(compatSchema, "__validator")) {
+		Object.defineProperty(compatSchema, "__validator", {
+			value: (data: unknown): T | TypeBoxValidationFailure => {
+				const result = schema(data);
+				return result instanceof type.errors ? validationFailure(result.summary) : result;
+			},
+			configurable: true,
+		});
+	}
+	if (!Object.hasOwn(compatSchema, "safeParse")) {
+		Object.defineProperty(compatSchema, "safeParse", {
+			value: (input: unknown): TypeBoxSafeParseResult<T> => {
+				const result = schema(input);
+				return result instanceof type.errors
+					? { success: false, error: validationFailure(result.summary) }
+					: { success: true, data: result };
+			},
+			configurable: true,
+		});
+	}
+	return compatSchema;
+}
+
+function applyMeta<T>(schema: RuntimeType<T>, opts?: Meta): CompatRuntime<T> {
+	let result = schema;
+	const description = opts?.description ?? opts?.title;
+	if (description !== undefined) result = result.describe(description);
+	if (opts && Object.hasOwn(opts, "default")) result = result.default(opts.default as T);
+	return withLegacyCompat(result);
+}
+
+function withJsonSchemaKeywords<T>(schema: CompatRuntime<T>, keywords: Record<string, unknown>): CompatRuntime<T> {
+	const emitBase = schema.toJsonSchema.bind(schema);
+	schema.toJsonSchema = options => ({ ...emitBase(options), ...keywords });
+	return schema;
+}
+
+function checkFiniteOption(name: string, value: number | undefined): void {
+	if (value !== undefined && !Number.isFinite(value)) throw new OmpTypeError(`${name} must be finite`);
+}
+
+function tString(opts?: StringOpts): TString {
+	checkFiniteOption("minLength", opts?.minLength);
+	checkFiniteOption("maxLength", opts?.maxLength);
+	let schema = asRuntime<string>(type.raw(opts?.format === "url" || opts?.format === "uri" ? "string.url" : "string"));
+	if (opts?.minLength !== undefined) schema = schema.atLeastLength(opts.minLength);
+	if (opts?.maxLength !== undefined) schema = schema.atMostLength(opts.maxLength);
+	if (opts?.pattern !== undefined) {
+		let regex: RegExp;
+		try {
+			regex = new RegExp(opts.pattern);
+		} catch {
+			throw new OmpTypeError(`invalid regular expression pattern ${JSON.stringify(opts.pattern)}`);
+		}
+		schema = schema.narrow((value, ctx) => regex.test(value) || ctx.mustBe(`a string matching ${opts.pattern}`));
+	}
+	if (opts?.format !== undefined && opts.format !== "url" && opts.format !== "uri") {
+		const format = opts.format;
+		const valid = formatPredicate(format);
+		schema = schema.narrow((value, ctx) => valid(value) || ctx.mustBe(`a string in ${format} format`));
+	}
+	const result = applyMeta(schema, opts);
+	const keywords: Record<string, unknown> = {};
+	if (opts?.pattern !== undefined) keywords.pattern = opts.pattern;
+	if (opts?.format !== undefined) keywords.format = opts.format === "url" ? "uri" : opts.format;
+	return opts?.pattern !== undefined || opts?.format !== undefined ? withJsonSchemaKeywords(result, keywords) : result;
+}
+
+function formatPredicate(format: string): (value: string) => boolean {
+	switch (format) {
+		case "url":
+		case "uri":
+			return value => {
+				try {
+					new URL(value);
+					return true;
+				} catch {
+					return false;
+				}
+			};
+		case "email":
+			return value => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
+		case "uuid":
+			return value => /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+		case "date-time":
+			return value =>
+				/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.\d+)?(?:Z|[+-]\d\d:\d\d)$/.test(value) &&
+				!Number.isNaN(Date.parse(value));
+		case "date":
+			return value => /^\d{4}-\d\d-\d\d$/.test(value) && !Number.isNaN(Date.parse(`${value}T00:00:00Z`));
+		default:
+			return () => true;
+	}
+}
+
+function tNumber(opts?: NumberOpts, integer = false): TNumber {
+	for (const key of ["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf"] as const) {
+		checkFiniteOption(key, opts?.[key]);
+	}
+	if (opts?.multipleOf !== undefined && opts.multipleOf <= 0)
+		throw new OmpTypeError("multipleOf must be greater than zero");
+	let lower: { value: number; exclusive: boolean } | undefined;
+	if (opts?.minimum !== undefined) lower = { value: opts.minimum, exclusive: false };
+	if (opts?.exclusiveMinimum !== undefined && (!lower || opts.exclusiveMinimum >= lower.value)) {
+		lower = { value: opts.exclusiveMinimum, exclusive: true };
+	}
+	let upper: { value: number; exclusive: boolean } | undefined;
+	if (opts?.maximum !== undefined) upper = { value: opts.maximum, exclusive: false };
+	if (opts?.exclusiveMaximum !== undefined && (!upper || opts.exclusiveMaximum <= upper.value)) {
+		upper = { value: opts.exclusiveMaximum, exclusive: true };
+	}
+	const keyword = integer ? "number.integer" : "number";
+	// The `LO <= TYPE <= HI` range spelling requires both bounds; a min-only
+	// bound must use the postfix `TYPE >= LO` form (see parseBounded in ir.ts).
+	let src: string;
+	if (lower && upper) {
+		src = `${lower.value} ${lower.exclusive ? "<" : "<="} ${keyword} ${upper.exclusive ? "<" : "<="} ${upper.value}`;
+	} else if (lower) {
+		src = `${keyword} ${lower.exclusive ? ">" : ">="} ${lower.value}`;
+	} else if (upper) {
+		src = `${keyword} ${upper.exclusive ? "<" : "<="} ${upper.value}`;
+	} else {
+		src = keyword;
+	}
+	let schema = asRuntime<number>(type.raw(src));
+	if (opts?.multipleOf !== undefined) {
+		const divisor = opts.multipleOf;
+		schema = schema.narrow((value, ctx) => {
+			const quotient = value / divisor;
+			return (
+				Math.abs(quotient - Math.round(quotient)) <= Number.EPSILON * Math.max(1, Math.abs(quotient)) ||
+				ctx.mustBe(`a multiple of ${divisor}`)
+			);
+		});
+	}
+	const result = applyMeta(schema, opts);
+	return opts?.multipleOf !== undefined ? withJsonSchemaKeywords(result, { multipleOf: opts.multipleOf }) : result;
+}
+
+function tLiteral<const V extends string | number | boolean | null>(value: V, opts?: Meta): TLiteral<V> {
+	return applyMeta(asRuntime<V>(type.enumerated(value)), opts);
+}
+
+function tNever(opts?: Meta): TNever {
+	return applyMeta(
+		asRuntime<unknown>(type.raw("unknown")).narrow((_value, ctx): _value is never => ctx.mustBe("never")),
+		opts,
+	);
+}
+
+function tUnion<const E extends readonly AnySchema[]>(schemas: E, opts?: Meta): TUnion<E> {
+	if (schemas.length === 0) return asSchema<Static<E[number]>>(tNever(opts));
+	let result = asRuntime<unknown>(schemas[0]);
+	for (let i = 1; i < schemas.length; i++) result = result.or(schemas[i]);
+	return asSchema<Static<E[number]>>(applyMeta(result, opts));
+}
+
+function tIntersect<const E extends readonly AnySchema[]>(
+	schemas: E,
+	opts?: Meta,
+): TTyped<UnionToIntersection<Static<E[number]>>> {
+	if (schemas.length === 0) {
+		return applyMeta(asRuntime<UnionToIntersection<Static<E[number]>>>(type.raw("unknown")), opts);
+	}
+	const validateAll = (): RuntimeType<UnionToIntersection<Static<E[number]>>> => {
+		const base = asRuntime<unknown>(type.raw("unknown"));
+		return base.narrow((value, ctx): value is UnionToIntersection<Static<E[number]>> => {
+			for (const schema of schemas) {
+				if (schema(value) instanceof type.errors) return ctx.mustBe("a value satisfying every intersection member");
+			}
+			return true;
+		});
+	};
+	if (schemas.some(schema => schema.hasSteps)) return applyMeta(validateAll(), opts);
+	let result = asRuntime<unknown>(schemas[0]);
+	try {
+		for (let i = 1; i < schemas.length; i++) result = result.and(schemas[i]);
+	} catch (error) {
+		if (error instanceof OmpTypeError) return applyMeta(validateAll(), opts);
+		throw error;
+	}
+	return asSchema<UnionToIntersection<Static<E[number]>>>(applyMeta(result, opts));
+}
+type UnionToIntersection<U> = (U extends unknown ? (value: U) => void : never) extends (value: infer I) => void
+	? I
+	: never;
+
+function enumValues(values: Record<string, string | number> | readonly (string | number)[]): (string | number)[] {
+	if (Array.isArray(values)) return [...values];
+	const result: (string | number)[] = [];
+	const record = values as Record<string, string | number>;
+	for (const key in record) {
+		const value = record[key];
+		if (!(/^\d+$/.test(key) && typeof value === "string") && !result.includes(value)) result.push(value);
+	}
+	return result;
+}
+
+function tEnum<const E extends Record<string, string | number> | readonly (string | number)[]>(
+	values: E,
+	opts?: Meta,
+): TTyped<E extends readonly (infer V)[] ? V : E[keyof E]> {
+	return applyMeta(
+		asRuntime<E extends readonly (infer V)[] ? V : E[keyof E]>(type.enumerated(...enumValues(values))),
+		opts,
+	);
+}
+
+function tArray<E extends AnySchema>(item: E, opts?: ArrayOpts): TArray<E> {
+	checkFiniteOption("minItems", opts?.minItems);
+	checkFiniteOption("maxItems", opts?.maxItems);
+	let schema = asRuntime<Static<E>>(item).array();
+	if (opts?.minItems !== undefined) schema = schema.atLeastLength(opts.minItems);
+	if (opts?.maxItems !== undefined) schema = schema.atMostLength(opts.maxItems);
+	if (opts?.uniqueItems) {
+		schema = schema.narrow((values, ctx) => {
+			for (let i = 0; i < values.length; i++) {
+				for (let j = i + 1; j < values.length; j++) {
+					if (jsonEqual(values[i], values[j])) return ctx.mustBe("an array with unique items");
+				}
+			}
+			return true;
+		});
+	}
+	const result = applyMeta(schema, opts);
+	return opts?.uniqueItems ? withJsonSchemaKeywords(result, { uniqueItems: true }) : result;
+}
+
+function jsonEqual(left: unknown, right: unknown): boolean {
+	if (Object.is(left, right)) return true;
+	if (typeof left !== "object" || left === null || typeof right !== "object" || right === null) return false;
+	try {
+		return JSON.stringify(left) === JSON.stringify(right);
+	} catch {
+		return false;
+	}
+}
+
+function tTuple<const E extends readonly AnySchema[]>(items: E, opts?: Meta): TTuple<E> {
+	const schema = asRuntime<unknown>(type.raw("unknown")).narrow(
+		(value, ctx): value is { -readonly [K in keyof E]: Static<E[K]> } => {
+			if (!Array.isArray(value) || value.length !== items.length)
+				return ctx.mustBe(`a tuple of length ${items.length}`);
+			for (let i = 0; i < items.length; i++)
+				if (items[i](value[i]) instanceof type.errors) return ctx.mustBe(`a valid item at index ${i}`);
+			return true;
+		},
+	);
+	return applyMeta(schema, opts);
+}
+
+function tObject<const P extends Record<string, AnySchema>>(properties: P, opts?: ObjectOpts): TObject<P> {
+	const def: Record<string, Def> = {};
+	const props: Record<string, AnySchema> = {};
+	for (const key in properties) {
+		const schema = properties[key];
+		const inner = asRuntime<unknown>(schema)[OPTIONAL_INNER];
+		// A defaulted `Type.Optional(...)` maps to a plain defaulted key:
+		// omptype (like ArkType) rejects `key?` with a default, and a default
+		// already makes the key omittable on input.
+		const optionalKey = inner !== undefined && !asRuntime<unknown>(inner).hasDefault;
+		def[optionalKey ? `${key}?` : key] = inner ?? schema;
+		props[key] = schema;
+	}
+	if (opts?.additionalProperties === false) def["+"] = "reject";
+	else if (opts?.additionalProperties && opts.additionalProperties !== true)
+		def["[string]"] = opts.additionalProperties;
+	const schema = applyMeta(asRuntime<ObjectStatic<P>>(type.raw(def)), opts);
+	schema[OBJECT_INFO] = { props, additionalProperties: opts?.additionalProperties };
+	return schema;
+}
+
+function tRecord<K extends AnySchema, V extends AnySchema>(key: K, value: V, opts?: Meta): TRecord<K, V> {
+	const base = asRuntime<Record<string, Static<V>>>(type.raw({ "[string]": value })).narrow((record, ctx) => {
+		for (const name in record)
+			if (key(name) instanceof type.errors) return ctx.mustBe("an object with valid record keys");
+		return true;
+	});
+	return applyMeta(base, opts) as TRecord<K, V>;
+}
+
+function tOptional<E extends AnySchema>(schema: E, opts?: Meta): TOptional<E> {
+	const marker = applyMeta(
+		asRuntime<Static<E>>(schema).or(asRuntime<undefined>(type.raw("undefined"))),
+		opts,
+	) as RuntimeType<Static<E> | undefined>;
+	marker[OPTIONAL_INNER] = schema;
+	return marker as unknown as TOptional<E>;
+}
+
+function tNullable<E extends AnySchema>(schema: E, opts?: Meta): TTyped<Static<E> | null> {
+	return applyMeta(asRuntime<Static<E>>(schema).or(asRuntime<null>(type.raw("null"))), opts);
+}
+
+function requireObject(schema: AnySchema, operation: string): ObjectInfo {
+	const info = asRuntime<unknown>(schema)[OBJECT_INFO];
+	if (!info) throw new OmpTypeError(`Type.${operation} requires a schema created by Type.Object`);
+	return info;
+}
+
+function tPartial<P extends Record<string, AnySchema>>(schema: TObject<P>): TTyped<Partial<ObjectStatic<P>>> {
+	const info = requireObject(schema, "Partial");
+	const props: Record<string, AnySchema> = {};
+	for (const key in info.props)
+		props[key] = asRuntime<unknown>(info.props[key])[OPTIONAL_INNER] ? info.props[key] : tOptional(info.props[key]);
+	return tObject(props, { additionalProperties: info.additionalProperties }) as TTyped<Partial<ObjectStatic<P>>>;
+}
+
+function tRequired<P extends Record<string, AnySchema>>(schema: TObject<P>): TObject<RequiredProps<P>> {
+	const info = requireObject(schema, "Required");
+	const props: Record<string, AnySchema> = {};
+	for (const key in info.props) {
+		props[key] = asRuntime<unknown>(info.props[key])[OPTIONAL_INNER] ?? info.props[key];
+	}
+	return tObject(props, { additionalProperties: info.additionalProperties }) as TObject<RequiredProps<P>>;
+}
+
+function tPick<P extends Record<string, AnySchema>, const K extends readonly (keyof P)[]>(
+	schema: TObject<P>,
+	keys: K,
+): TObject<Pick<P, K[number]>> {
+	const info = requireObject(schema, "Pick");
+	const props: Record<string, AnySchema> = {};
+	for (const key of keys) if (typeof key === "string" && info.props[key]) props[key] = info.props[key];
+	return tObject(props, { additionalProperties: info.additionalProperties }) as TObject<Pick<P, K[number]>>;
+}
+
+function tOmit<P extends Record<string, AnySchema>, const K extends readonly (keyof P)[]>(
+	schema: TObject<P>,
+	keys: K,
+): TObject<Omit<P, K[number]>> {
+	const info = requireObject(schema, "Omit");
+	const omitted = new Set<PropertyKey>(keys);
+	const props: Record<string, AnySchema> = {};
+	for (const key in info.props) if (!omitted.has(key)) props[key] = info.props[key];
+	return tObject(props, { additionalProperties: info.additionalProperties }) as TObject<Omit<P, K[number]>>;
+}
+
+function tComposite<const E extends readonly TObject<Record<string, AnySchema>>[]>(
+	schemas: E,
+	opts?: ObjectOpts,
+): TTyped<UnionToIntersection<Static<E[number]>>> {
+	const props: Record<string, AnySchema> = {};
+	for (const schema of schemas) Object.assign(props, requireObject(schema, "Composite").props);
+	return asSchema<UnionToIntersection<Static<E[number]>>>(tObject(props, opts));
+}
+
+function tUnsafe<T = unknown>(_jsonSchema: Record<string, unknown> = {}): TUnsafe<T> {
+	// Raw JSON Schema is accepted for source compatibility but is not retained or validated:
+	// omptype cannot honestly implement that contract without importing a second validator.
+	return withLegacyCompat(type.unknown as OmpType<T>);
+}
+
+export const Type = {
+	String: tString,
+	Number: (opts?: NumberOpts) => tNumber(opts),
+	Integer: (opts?: NumberOpts) => tNumber(opts, true),
+	Boolean: (opts?: Meta) => applyMeta(asRuntime<boolean>(type.raw("boolean")), opts),
+	Null: (opts?: Meta) => applyMeta(asRuntime<null>(type.raw("null")), opts),
+	Any: (opts?: Meta) => applyMeta(asRuntime<unknown>(type.raw("unknown")), opts),
+	Unknown: (opts?: Meta) => applyMeta(asRuntime<unknown>(type.raw("unknown")), opts),
+	Never: tNever,
+	Literal: tLiteral,
+	Union: tUnion,
+	Intersect: tIntersect,
+	Enum: tEnum,
+	Array: tArray,
+	Tuple: tTuple,
+	Object: tObject,
+	Record: tRecord,
+	Optional: tOptional,
+	Nullable: tNullable,
+	Readonly: <E extends AnySchema>(schema: E): TReadonly<E> =>
+		asSchema<Readonly<Static<E>>>(withLegacyCompat(asRuntime<Readonly<Static<E>>>(schema))),
+	Partial: tPartial,
+	Required: tRequired,
+	Pick: tPick,
+	Omit: tOmit,
+	Composite: tComposite,
+	Unsafe: tUnsafe,
+} as const;
+
+export type TypeBuilder = typeof Type;
+export default { Type };