@sinclair/typebox 0.32.0-dev-2 → 0.32.0-dev-4

package/type/template-literal/syntax.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateLiteralSyntax = void 0;
+const index_1 = require("../literal/index");
+const index_2 = require("../boolean/index");
+const index_3 = require("../bigint/index");
+const index_4 = require("../number/index");
+const index_5 = require("../string/index");
+const index_6 = require("../union/index");
+const index_7 = require("../never/index");
+function* FromUnion(syntax) {
+    const trim = syntax.trim().replace(/"|'/g, '');
+    return (trim === 'boolean' ? yield (0, index_2.Boolean)() :
+        trim === 'number' ? yield (0, index_4.Number)() :
+            trim === 'bigint' ? yield (0, index_3.BigInt)() :
+                trim === 'string' ? yield (0, index_5.String)() :
+                    yield (() => {
+                        const literals = trim.split('|').map((literal) => (0, index_1.Literal)(literal.trim()));
+                        return (literals.length === 0 ? (0, index_7.Never)() :
+                            literals.length === 1 ? literals[0] :
+                                (0, index_6.Union)(literals));
+                    })());
+}
+function* FromTerminal(syntax) {
+    if (syntax[1] !== '{') {
+        const L = (0, index_1.Literal)('$');
+        const R = FromSyntax(syntax.slice(1));
+        return yield* [L, ...R];
+    }
+    for (let i = 2; i < syntax.length; i++) {
+        if (syntax[i] === '}') {
+            const L = FromUnion(syntax.slice(2, i));
+            const R = FromSyntax(syntax.slice(i + 1));
+            return yield* [...L, ...R];
+        }
+    }
+    yield (0, index_1.Literal)(syntax);
+}
+function* FromSyntax(syntax) {
+    for (let i = 0; i < syntax.length; i++) {
+        if (syntax[i] === '$') {
+            const L = (0, index_1.Literal)(syntax.slice(0, i));
+            const R = FromTerminal(syntax.slice(i));
+            return yield* [L, ...R];
+        }
+    }
+    yield (0, index_1.Literal)(syntax);
+}
+function TemplateLiteralSyntax(syntax) {
+    return [...FromSyntax(syntax)];
+}
+exports.TemplateLiteralSyntax = TemplateLiteralSyntax;

package/type/template-literal/template-literal.d.ts

@@ -0,0 +1,28 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Assert } from '../helpers/index';
+import type { TUnion } from '../union/index';
+import type { TLiteral } from '../literal/index';
+import type { TInteger } from '../integer/index';
+import type { TNumber } from '../number/index';
+import type { TBigInt } from '../bigint/index';
+import type { TString } from '../string/index';
+import type { TBoolean } from '../boolean/index';
+import type { TNever } from '../never/index';
+import type { Static } from '../static/index';
+import { TemplateLiteralSyntax } from './syntax';
+import { EmptyString } from '../helpers/index';
+import { Kind } from '../symbols/index';
+type TemplateLiteralResolveConst<T, Acc extends string> = T extends TUnion<infer U> ? {
+    [K in keyof U]: TemplateLiteralResolve<Assert<[U[K]], TTemplateLiteralKind[]>, Acc>;
+}[number] : T extends TTemplateLiteral ? `${Static<T>}` : T extends TLiteral<infer U> ? `${U}` : T extends TString ? `${string}` : T extends TNumber ? `${number}` : T extends TBigInt ? `${bigint}` : T extends TBoolean ? `${boolean}` : never;
+export type TemplateLiteralResolve<T extends TTemplateLiteralKind[], Acc extends string> = T extends [infer L, ...infer R] ? `${TemplateLiteralResolveConst<L, Acc>}${TemplateLiteralResolve<Assert<R, TTemplateLiteralKind[]>, Acc>}` : Acc;
+export type TTemplateLiteralKind = TTemplateLiteral | TUnion | TLiteral | TInteger | TNumber | TBigInt | TString | TBoolean | TNever;
+export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLiteralKind[]> extends TSchema {
+    [Kind]: 'TemplateLiteral';
+    static: TemplateLiteralResolve<T, EmptyString>;
+    type: 'string';
+    pattern: string;
+}
+export declare function TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TemplateLiteralSyntax<T>;
+export declare function TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
+export {};

package/type/template-literal/template-literal.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateLiteral = void 0;
+const pattern_1 = require("./pattern");
+const syntax_1 = require("./syntax");
+const value_1 = require("../guard/value");
+const index_1 = require("../symbols/index");
+function TemplateLiteral(unresolved, options = {}) {
+    const pattern = (0, value_1.IsString)(unresolved)
+        ? (0, pattern_1.TemplateLiteralPattern)((0, syntax_1.TemplateLiteralSyntax)(unresolved))
+        : (0, pattern_1.TemplateLiteralPattern)(unresolved);
+    return { ...options, [index_1.Kind]: 'TemplateLiteral', type: 'string', pattern };
+}
+exports.TemplateLiteral = TemplateLiteral;

package/type/template-literal/union.d.ts

@@ -0,0 +1,6 @@
+import type { TTemplateLiteral } from './template-literal';
+import { type TUnion } from '../union/index';
+import { type TLiteral } from '../literal/index';
+import { type TString } from '../string/index';
+import { type TNever } from '../never/index';
+export declare function TemplateLiteralToUnion(template: TTemplateLiteral): TNever | TString | TUnion<TLiteral[]>;

package/type/template-literal/union.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateLiteralToUnion = void 0;
+const index_1 = require("../union/index");
+const index_2 = require("../literal/index");
+const index_3 = require("../string/index");
+const generate_1 = require("./generate");
+const parser_1 = require("./parser");
+const finite_1 = require("./finite");
+function TemplateLiteralToUnion(template) {
+    const expression = (0, parser_1.TemplateLiteralParseExact)(template.pattern);
+    if (!(0, finite_1.IsTemplateLiteralFinite)(expression))
+        return (0, index_3.String)();
+    const literals = [...(0, generate_1.TemplateLiteralGenerate)(expression)].map((value) => (0, index_2.Literal)(value));
+    return (0, index_1.Union)(literals);
+}
+exports.TemplateLiteralToUnion = TemplateLiteralToUnion;

package/type/transform/index.d.ts

@@ -0,0 +1 @@
+export * from './transform';

package/type/transform/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./transform"), exports);

package/type/transform/transform.d.ts

@@ -0,0 +1,28 @@
+import type { TSchema } from '../schema/index';
+import type { Static, StaticDecode } from '../static/index';
+import { TransformKind } from '../symbols/index';
+export declare class TransformDecodeBuilder<T extends TSchema> {
+    private readonly schema;
+    constructor(schema: T);
+    Decode<U extends unknown, D extends TransformFunction<StaticDecode<T>, U>>(decode: D): TransformEncodeBuilder<T, D>;
+}
+export declare class TransformEncodeBuilder<T extends TSchema, D extends TransformFunction> {
+    private readonly schema;
+    private readonly decode;
+    constructor(schema: T, decode: D);
+    private EncodeTransform;
+    private EncodeSchema;
+    Encode<E extends TransformFunction<ReturnType<D>, StaticDecode<T>>>(encode: E): TTransform<T, ReturnType<D>>;
+}
+export type TransformFunction<T = any, U = any> = (value: T) => U;
+export interface TransformOptions<I extends TSchema = TSchema, O extends unknown = unknown> {
+    Decode: TransformFunction<StaticDecode<I>, O>;
+    Encode: TransformFunction<O, StaticDecode<I>>;
+}
+export type TTransformResolve<T extends TSchema, P extends unknown[] = []> = T extends TTransform<infer _, infer S> ? S : Static<T, P>;
+export interface TTransform<I extends TSchema = TSchema, O extends unknown = unknown> extends TSchema {
+    static: TTransformResolve<I, this['params']>;
+    [TransformKind]: TransformOptions<I, O>;
+    [key: string]: any;
+}
+export declare function Transform<I extends TSchema>(schema: I): TransformDecodeBuilder<I>;

package/type/transform/transform.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transform = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = void 0;
+const type_1 = require("../guard/type");
+const type_2 = require("../clone/type");
+const index_1 = require("../symbols/index");
+class TransformDecodeBuilder {
+    constructor(schema) {
+        this.schema = schema;
+    }
+    Decode(decode) {
+        return new TransformEncodeBuilder(this.schema, decode);
+    }
+}
+exports.TransformDecodeBuilder = TransformDecodeBuilder;
+class TransformEncodeBuilder {
+    constructor(schema, decode) {
+        this.schema = schema;
+        this.decode = decode;
+    }
+    EncodeTransform(encode, schema) {
+        const Encode = (value) => schema[index_1.TransformKind].Encode(encode(value));
+        const Decode = (value) => this.decode(schema[index_1.TransformKind].Decode(value));
+        const Codec = { Encode: Encode, Decode: Decode };
+        return { ...schema, [index_1.TransformKind]: Codec };
+    }
+    EncodeSchema(encode, schema) {
+        const Codec = { Decode: this.decode, Encode: encode };
+        return { ...schema, [index_1.TransformKind]: Codec };
+    }
+    Encode(encode) {
+        const schema = (0, type_2.CloneType)(this.schema);
+        return ((0, type_1.TTransform)(schema) ? this.EncodeTransform(encode, schema) : this.EncodeSchema(encode, schema));
+    }
+}
+exports.TransformEncodeBuilder = TransformEncodeBuilder;
+function Transform(schema) {
+    return new TransformDecodeBuilder(schema);
+}
+exports.Transform = Transform;

package/type/tuple/index.d.ts

@@ -0,0 +1 @@
+export * from './tuple';

package/type/tuple/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./tuple"), exports);

package/type/tuple/tuple.d.ts

@@ -0,0 +1,14 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Static } from '../static/index';
+import { Kind } from '../symbols/index';
+export type TupleResolve<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...TupleResolve<R, P>] : [];
+export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
+    [Kind]: 'Tuple';
+    static: TupleResolve<T, this['params']>;
+    type: 'array';
+    items?: T;
+    additionalItems?: false;
+    minItems: number;
+    maxItems: number;
+}
+export declare function Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T>;

package/type/tuple/tuple.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tuple = void 0;
+const type_1 = require("../clone/type");
+const index_1 = require("../symbols/index");
+function Tuple(items, options = {}) {
+    const [additionalItems, minItems, maxItems] = [false, items.length, items.length];
+    return (items.length > 0 ?
+        { ...options, [index_1.Kind]: 'Tuple', type: 'array', items: (0, type_1.CloneRest)(items), additionalItems, minItems, maxItems } :
+        { ...options, [index_1.Kind]: 'Tuple', type: 'array', minItems, maxItems });
+}
+exports.Tuple = Tuple;

package/type/type/index.d.ts

@@ -0,0 +1,5 @@
+export { JsonTypeBuilder } from './json';
+import { JavaScriptTypeBuilder } from './javascript';
+declare const Type: JavaScriptTypeBuilder;
+export { JavaScriptTypeBuilder };
+export { Type };

package/type/type/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Type = exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = void 0;
+var json_1 = require("./json");
+Object.defineProperty(exports, "JsonTypeBuilder", { enumerable: true, get: function () { return json_1.JsonTypeBuilder; } });
+const TypeBuilder = require("./type");
+const javascript_1 = require("./javascript");
+Object.defineProperty(exports, "JavaScriptTypeBuilder", { enumerable: true, get: function () { return javascript_1.JavaScriptTypeBuilder; } });
+const Type = TypeBuilder;
+exports.Type = Type;

package/type/type/javascript.d.ts

@@ -0,0 +1,39 @@
+import { JsonTypeBuilder } from './json';
+import { type TAsyncIterator } from '../async-iterator/index';
+import { type TAwaited } from '../awaited/index';
+import { type TBigInt, type BigIntOptions } from '../bigint/index';
+import { type TConstructor } from '../constructor/index';
+import { type TConstructorParameters } from '../constructor-parameters/index';
+import { type TDate, type DateOptions } from '../date/index';
+import { type TFunction } from '../function/index';
+import { type TInstanceType } from '../instance-type/index';
+import { type TIterator } from '../iterator/index';
+import { type TParameters } from '../parameters/index';
+import { type TPromise } from '../promise/index';
+import { type TRegExp } from '../regexp/index';
+import { type TReturnType } from '../return-type/index';
+import { type TSchema, type SchemaOptions } from '../schema/index';
+import { type TSymbol } from '../symbol/index';
+import { type TUint8Array, type Uint8ArrayOptions } from '../uint8array/index';
+import { type TUndefined } from '../undefined/index';
+import { type TVoid } from '../void/index';
+export declare class JavaScriptTypeBuilder extends JsonTypeBuilder {
+    AsyncIterator<T extends TSchema>(items: T, options?: SchemaOptions): TAsyncIterator<T>;
+    Awaited<T extends TSchema>(schema: T, options?: SchemaOptions): TAwaited<T>;
+    BigInt(options?: BigIntOptions): TBigInt;
+    ConstructorParameters<T extends TConstructor<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TConstructorParameters<T>;
+    Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U>;
+    Date(options?: DateOptions): TDate;
+    Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U>;
+    InstanceType<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TInstanceType<T>;
+    Iterator<T extends TSchema>(items: T, options?: SchemaOptions): TIterator<T>;
+    Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TParameters<T>;
+    Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T>;
+    RegExp(pattern: string, options?: SchemaOptions): TRegExp;
+    RegExp(regex: RegExp, options?: SchemaOptions): TRegExp;
+    ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T>;
+    Symbol(options?: SchemaOptions): TSymbol;
+    Undefined(options?: SchemaOptions): TUndefined;
+    Uint8Array(options?: Uint8ArrayOptions): TUint8Array;
+    Void(options?: SchemaOptions): TVoid;
+}

package/type/type/javascript.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JavaScriptTypeBuilder = void 0;
+const json_1 = require("./json");
+const index_1 = require("../async-iterator/index");
+const index_2 = require("../awaited/index");
+const index_3 = require("../bigint/index");
+const index_4 = require("../constructor/index");
+const index_5 = require("../constructor-parameters/index");
+const index_6 = require("../date/index");
+const index_7 = require("../function/index");
+const index_8 = require("../instance-type/index");
+const index_9 = require("../iterator/index");
+const index_10 = require("../parameters/index");
+const index_11 = require("../promise/index");
+const index_12 = require("../regexp/index");
+const index_13 = require("../return-type/index");
+const index_14 = require("../symbol/index");
+const index_15 = require("../uint8array/index");
+const index_16 = require("../undefined/index");
+const index_17 = require("../void/index");
+class JavaScriptTypeBuilder extends json_1.JsonTypeBuilder {
+    AsyncIterator(items, options = {}) {
+        return (0, index_1.AsyncIterator)(items, options);
+    }
+    Awaited(schema, options = {}) {
+        return (0, index_2.Awaited)(schema, options);
+    }
+    BigInt(options = {}) {
+        return (0, index_3.BigInt)(options);
+    }
+    ConstructorParameters(schema, options = {}) {
+        return (0, index_5.ConstructorParameters)(schema, options);
+    }
+    Constructor(parameters, returns, options) {
+        return (0, index_4.Constructor)(parameters, returns, options);
+    }
+    Date(options = {}) {
+        return (0, index_6.Date)(options);
+    }
+    Function(parameters, returns, options) {
+        return (0, index_7.Function)(parameters, returns, options);
+    }
+    InstanceType(schema, options = {}) {
+        return (0, index_8.InstanceType)(schema, options);
+    }
+    Iterator(items, options = {}) {
+        return (0, index_9.Iterator)(items, options);
+    }
+    Parameters(schema, options = {}) {
+        return (0, index_10.Parameters)(schema, options);
+    }
+    Promise(item, options = {}) {
+        return (0, index_11.Promise)(item, options);
+    }
+    RegExp(unresolved, options = {}) {
+        return (0, index_12.RegExp)(unresolved, options);
+    }
+    ReturnType(schema, options = {}) {
+        return (0, index_13.ReturnType)(schema, options);
+    }
+    Symbol(options) {
+        return (0, index_14.Symbol)(options);
+    }
+    Undefined(options = {}) {
+        return (0, index_16.Undefined)(options);
+    }
+    Uint8Array(options = {}) {
+        return (0, index_15.Uint8Array)(options);
+    }
+    Void(options = {}) {
+        return (0, index_17.Void)(options);
+    }
+}
+exports.JavaScriptTypeBuilder = JavaScriptTypeBuilder;

package/type/type/json.d.ts

@@ -0,0 +1,90 @@
+import { type TAny } from '../any/index';
+import { type TArray, type ArrayOptions } from '../array/index';
+import { type TBoolean } from '../boolean/index';
+import { type TComposite } from '../composite/index';
+import { type TConst } from '../const/index';
+import { type TDeref } from '../deref/index';
+import { type TEnum, type TEnumKey, type TEnumValue } from '../enum/index';
+import { type TExclude } from '../exclude/index';
+import { type TExtends } from '../extends/index';
+import { type TExtract } from '../extract/index';
+import { TIndex, type IndexedKeyResolve } from '../indexed/index';
+import { type IntegerOptions, type TInteger } from '../integer/index';
+import { type IntersectOptions, type IntersectResolve } from '../intersect/index';
+import { type TCapitalize, type TUncapitalize, type TLowercase, type TUppercase } from '../intrinsic/index';
+import { type TKeyOf } from '../keyof/index';
+import { type TLiteral, type TLiteralValue } from '../literal/index';
+import { type TNever } from '../never/index';
+import { type TNot } from '../not/index';
+import { type TNull } from '../null/index';
+import { type TNumber, type NumberOptions } from '../number/index';
+import { type TObject, type TProperties, type ObjectOptions } from '../object/index';
+import { type TOmit } from '../omit/index';
+import { type TOptional } from '../optional/index';
+import { type TPartial } from '../partial/index';
+import { type TPick } from '../pick/index';
+import { type TReadonly } from '../readonly/index';
+import { type TReadonlyOptional } from '../readonly-optional/index';
+import { type RecordResolve } from '../record/index';
+import { type TRecursive, type TThis } from '../recursive/index';
+import { type TRef } from '../ref/index';
+import { type TRequired } from '../required/index';
+import { type TRest } from '../rest/index';
+import { type TSchema, type SchemaOptions } from '../schema/index';
+import { type TString, type StringOptions } from '../string/index';
+import { type TTemplateLiteral, type TTemplateLiteralKind, type TemplateLiteralSyntax } from '../template-literal/index';
+import { TransformDecodeBuilder } from '../transform/index';
+import { type TTuple } from '../tuple/index';
+import { type UnionResolve } from '../union/index';
+import { type TUnknown } from '../unknown/index';
+import { type TUnsafe, type UnsafeOptions } from '../unsafe/index';
+export declare class JsonTypeBuilder {
+    Strict<T extends TSchema>(schema: T): T;
+    ReadonlyOptional<T extends TSchema>(schema: T): TReadonlyOptional<T>;
+    Readonly<T extends TSchema>(schema: T): TReadonly<T>;
+    Optional<T extends TSchema>(schema: T): TOptional<T>;
+    Any(options?: SchemaOptions): TAny;
+    Array<T extends TSchema>(schema: T, options?: ArrayOptions): TArray<T>;
+    Boolean(options?: SchemaOptions): TBoolean;
+    Capitalize<T extends TSchema>(schema: T, options?: SchemaOptions): TCapitalize<T>;
+    Composite<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TComposite<T>;
+    Const<T>(value: T, options?: SchemaOptions): TConst<T>;
+    Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
+    Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T>;
+    Extends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U, options?: SchemaOptions): TExtends<L, R, T, U>;
+    Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>;
+    Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
+    Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedKeyResolve<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>;
+    Index<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TIndex<T, K>;
+    Integer(options?: IntegerOptions): TInteger;
+    Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): IntersectResolve<T>;
+    KeyOf<T extends TSchema>(schema: T, options?: SchemaOptions): TKeyOf<T>;
+    Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T>;
+    Lowercase<T extends TSchema>(schema: T, options?: SchemaOptions): TLowercase<T>;
+    Never(options?: SchemaOptions): TNever;
+    Not<T extends TSchema>(schema: T, options?: SchemaOptions): TNot<T>;
+    Null(options?: SchemaOptions): TNull;
+    Number(options?: NumberOptions): TNumber;
+    Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
+    Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedKeyResolve<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
+    Omit<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TOmit<T, K>;
+    Partial<T extends TSchema>(schema: T, options?: ObjectOptions): TPartial<T>;
+    Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedKeyResolve<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
+    Pick<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>;
+    Record<K extends TSchema, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordResolve<K, T>;
+    Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T>;
+    Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>;
+    Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>;
+    Required<T extends TSchema>(schema: T, options?: SchemaOptions): TRequired<T>;
+    Rest<T extends TSchema>(schema: T): TRest<T>;
+    String(options?: StringOptions): TString;
+    TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TemplateLiteralSyntax<T>;
+    TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
+    Transform<I extends TSchema>(schema: I): TransformDecodeBuilder<I>;
+    Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T>;
+    Uncapitalize<T extends TSchema>(schema: T, options?: SchemaOptions): TUncapitalize<T>;
+    Union<T extends TSchema[]>(schemas: [...T], options?: SchemaOptions): UnionResolve<T>;
+    Unknown(options?: SchemaOptions): TUnknown;
+    Unsafe<T>(options?: UnsafeOptions): TUnsafe<T>;
+    Uppercase<T extends TSchema>(schema: T, options?: SchemaOptions): TUppercase<T>;
+}