@sinclair/typebox 0.26.0-dev.1 → 0.26.0-dev.3

package/typebox.d.ts

@@ -1,648 +1,648 @@
-export declare const Kind: unique symbol;
-export declare const Hint: unique symbol;
-export declare const Modifier: unique symbol;
-export type TupleToIntersect<T extends any[]> = T extends [infer I] ? I : T extends [infer I, ...infer R] ? I & TupleToIntersect<R> : never;
-export type TupleToUnion<T extends any[]> = {
-    [K in keyof T]: T[K];
-}[number];
-export type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
-export type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
-export type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, L>>, L];
-export type Assert<T, E> = T extends E ? T : never;
-export type Evaluate<T> = T extends infer O ? {
-    [K in keyof O]: O[K];
-} : never;
-export type Ensure<T> = T extends infer U ? U : never;
-export type TModifier = TReadonlyOptional<TSchema> | TOptional<TSchema> | TReadonly<TSchema>;
-export type TReadonly<T extends TSchema> = T & {
-    [Modifier]: 'Readonly';
-};
-export type TOptional<T extends TSchema> = T & {
-    [Modifier]: 'Optional';
-};
-export type TReadonlyOptional<T extends TSchema> = T & {
-    [Modifier]: 'ReadonlyOptional';
-};
-export interface SchemaOptions {
-    $schema?: string;
-    /** Id for this schema */
-    readonly $id?: string;
-    /** Title of this schema */
-    title?: string;
-    /** Description of this schema */
-    description?: string;
-    /** Default value for this schema */
-    default?: any;
-    /** Example values matching this schema */
-    examples?: any;
-    [prop: string]: any;
-}
-export interface TKind {
-    [Kind]: string;
-}
-export interface TSchema extends SchemaOptions, TKind {
-    [Hint]?: string;
-    [Modifier]?: string;
-    params: unknown[];
-    static: unknown;
-}
-export type TAnySchema = TSchema | TAny | TArray | TBigInt | TBoolean | TConstructor | TDate | TEnum | TFunction | TInteger | TIntersect | TLiteral | TNot | TNull | TNumber | TObject | TPromise | TRecord | TRef | TSelf | TString | TSymbol | TTuple | TUndefined | TUnion | TUint8Array | TUnknown | TVoid;
-export type TNumeric = TInteger | TNumber;
-export interface NumericOptions<N extends number | bigint> extends SchemaOptions {
-    exclusiveMaximum?: N;
-    exclusiveMinimum?: N;
-    maximum?: N;
-    minimum?: N;
-    multipleOf?: N;
-}
-export interface TAny extends TSchema {
-    [Kind]: 'Any';
-    static: any;
-}
-export interface ArrayOptions extends SchemaOptions {
-    uniqueItems?: boolean;
-    minItems?: number;
-    maxItems?: number;
-}
-export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptions {
-    [Kind]: 'Array';
-    static: Static<T, this['params']>[];
-    type: 'array';
-    items: T;
-}
-export interface TBigInt extends TSchema, NumericOptions<bigint> {
-    [Kind]: 'BigInt';
-    static: bigint;
-    type: 'null';
-    typeOf: 'BigInt';
-}
-export interface TBoolean extends TSchema {
-    [Kind]: 'Boolean';
-    static: boolean;
-    type: 'boolean';
-}
-export type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = TTuple<T['parameters']>;
-export type TDeref<T> = T extends TRef<infer U> ? TDeref<U> : T;
-export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns'];
-export type TCompositeUnion<Left extends TSchema, Right extends TSchema> = Ensure<TUnion<[Left, Right]>>;
-export type TCompositeMerge<T extends TObject, Output extends Record<any, TSchema>> = Evaluate<{
-    [Key in keyof T['properties']]: Key extends keyof Output ? TCompositeUnion<T['properties'][Key], Output[Key]> : T['properties'][Key];
-} & {
-    [Key in keyof Output]: Key extends keyof T['properties'] ? TCompositeUnion<T['properties'][Key], Output[Key]> : Output[Key];
-}>;
-export type TCompositeReduce<T extends TObject[], Output extends {}> = T extends [infer L, ...infer R] ? TCompositeReduce<[...Assert<R, TObject[]>], TCompositeMerge<Assert<L, TObject>, Output>> : T extends [] ? Output : never;
-export type TComposite<T extends TObject[]> = Ensure<TObject<TCompositeReduce<T, {}>>>;
-export type TConstructorParameterArray<T extends readonly TSchema[], P extends unknown[]> = [...{
-    [K in keyof T]: Static<Assert<T[K], TSchema>, P>;
-}];
-export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
-    [Kind]: 'Constructor';
-    static: new (...param: TConstructorParameterArray<T, this['params']>) => Static<U, this['params']>;
-    type: 'object';
-    instanceOf: 'Constructor';
-    parameters: T;
-    returns: U;
-}
-export interface DateOptions extends SchemaOptions {
-    exclusiveMaximumTimestamp?: number;
-    exclusiveMinimumTimestamp?: number;
-    maximumTimestamp?: number;
-    minimumTimestamp?: number;
-}
-export interface TDate extends TSchema, DateOptions {
-    [Kind]: 'Date';
-    static: Date;
-    type: 'object';
-    instanceOf: 'Date';
-}
-export interface TEnumOption<T> {
-    type: 'number' | 'string';
-    const: T;
-}
-export type TEnumStatic<T extends Record<string, string | number>> = T[keyof T];
-export interface TEnum<T extends Record<string, string | number> = Record<string, string | number>> extends TSchema {
-    [Kind]: 'Union';
-    static: TEnumStatic<T>;
-    anyOf: TLiteral<string | number>[];
-}
-export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = (Static<L> extends Static<R> ? T : U) extends infer O ? UnionToTuple<O> extends [infer X, infer Y] ? TUnion<[Assert<X, TSchema>, Assert<Y, TSchema>]> : Assert<O, TSchema> : never;
-export type TExcludeArray<T extends TSchema[], U extends TSchema> = Assert<UnionToTuple<{
-    [K in keyof T]: Static<Assert<T[K], TSchema>> extends Static<U> ? never : T[K];
-}[number]>, TSchema[]> extends infer R ? TExcludeResult<Assert<R, TSchema[]>> : never;
-export type TExcludeResult<T extends TSchema[]> = T extends [] ? TNever : T extends [infer S] ? S : TUnion<T>;
-export type TExclude<T extends TSchema, U extends TSchema> = T extends TUnion<infer S> ? TExcludeArray<S, U> : T extends U ? TNever : T;
-export type TExtractArray<T extends TSchema[], U extends TSchema> = Assert<UnionToTuple<{
-    [K in keyof T]: Static<Assert<T[K], TSchema>> extends Static<U> ? T[K] : never;
-}[number]>, TSchema[]> extends infer R ? TExtractResult<Assert<R, TSchema[]>> : never;
-export type TExtractResult<T extends TSchema[]> = T extends [] ? TNever : T extends [infer S] ? S : TUnion<T>;
-export type TExtract<T extends TSchema, U extends TSchema> = T extends TUnion<infer S> ? TExtractArray<S, U> : T extends U ? T : TNever;
-export type TFunctionParameters<T extends readonly TSchema[], P extends unknown[]> = [...{
-    [K in keyof T]: Static<Assert<T[K], TSchema>, P>;
-}];
-export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
-    [Kind]: 'Function';
-    static: (...param: TFunctionParameters<T, this['params']>) => Static<U, this['params']>;
-    type: 'object';
-    instanceOf: 'Function';
-    parameters: T;
-    returns: U;
-}
-export interface TInteger extends TSchema, NumericOptions<number> {
-    [Kind]: 'Integer';
-    static: number;
-    type: 'integer';
-}
-export type TUnevaluatedProperties = undefined | TSchema | boolean;
-export interface IntersectOptions extends SchemaOptions {
-    unevaluatedProperties?: TUnevaluatedProperties;
-}
-export type TIntersectStatic<T extends TSchema[], P extends unknown[]> = TupleToIntersect<{
-    [K in keyof T]: Static<Assert<T[K], TSchema>, P>;
-}>;
-export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, IntersectOptions {
-    [Kind]: 'Intersect';
-    type?: 'object';
-    static: TIntersectStatic<T, this['params']>;
-    allOf: [...T];
-}
-export type TKeyOfTuple<T extends TSchema> = {
-    [K in keyof Static<T>]: TLiteral<Assert<K, TLiteralValue>>;
-} extends infer U ? UnionToTuple<Exclude<{
-    [K in keyof U]: U[K];
-}[keyof U], undefined>> : never;
-export type TKeyOf<T extends TSchema = TSchema> = (T extends TIntersect ? TKeyOfTuple<T> : T extends TUnion ? TKeyOfTuple<T> : T extends TObject ? TKeyOfTuple<T> : [
-]) extends infer R ? R extends [] ? TNever : TUnion<Assert<R, TSchema[]>> : never;
-export type TLiteralValue = string | number | boolean | bigint;
-export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSchema {
-    [Kind]: 'Literal';
-    static: T;
-    const: T;
-}
-export interface TNever extends TSchema {
-    [Kind]: 'Never';
-    static: never;
-    allOf: [{
-        type: 'boolean';
-        const: false;
-    }, {
-        type: 'boolean';
-        const: true;
-    }];
-}
-export type TNotStatic<_ extends TSchema = TSchema, T extends TSchema = TSchema> = Static<T>;
-export interface TNot<Not extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
-    [Kind]: 'Not';
-    static: TNotStatic<Not, T>;
-    allOf: [{
-        not: Not;
-    }, T];
-}
-export interface TNull extends TSchema {
-    [Kind]: 'Null';
-    static: null;
-    type: 'null';
-}
-export interface TNumber extends TSchema, NumericOptions<number> {
-    [Kind]: 'Number';
-    static: number;
-    type: 'number';
-}
-export type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TReadonlyOptional<TSchema> ? K : never;
-}[keyof T];
-export type ReadonlyPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TReadonly<TSchema> ? K : never;
-}[keyof T];
-export type OptionalPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TOptional<TSchema> ? K : never;
-}[keyof T];
-export type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
-export type PropertiesReducer<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> & Readonly<Pick<R, ReadonlyPropertyKeys<T>>> & Partial<Pick<R, OptionalPropertyKeys<T>>> & Required<Pick<R, RequiredPropertyKeys<T>>>)>;
-export type PropertiesReduce<T extends TProperties, P extends unknown[]> = PropertiesReducer<T, {
-    [K in keyof T]: Static<T[K], P>;
-}>;
-export type TProperties = Record<keyof any, TSchema>;
-export type ObjectProperties<T> = T extends TObject<infer U> ? U : never;
-export type ObjectPropertyKeys<T> = T extends TObject<infer U> ? keyof U : never;
-export type TAdditionalProperties = undefined | TSchema | boolean;
-export interface ObjectOptions extends SchemaOptions {
-    additionalProperties?: TAdditionalProperties;
-    minProperties?: number;
-    maxProperties?: number;
-}
-export interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
-    [Kind]: 'Object';
-    static: PropertiesReduce<T, this['params']>;
-    additionalProperties?: TAdditionalProperties;
-    type: 'object';
-    properties: T;
-    required?: string[];
-}
-export type TOmitArray<T extends TSchema[], K extends keyof any> = Assert<{
-    [K2 in keyof T]: TOmit<Assert<T[K2], TSchema>, K>;
-}, TSchema[]>;
-export type TOmitProperties<T extends TProperties, K extends keyof any> = Evaluate<Assert<Omit<T, K>, TProperties>>;
-export type TOmit<T extends TSchema, K extends keyof any> = T extends TIntersect<infer S> ? TIntersect<TOmitArray<S, K>> : T extends TUnion<infer S> ? TUnion<TOmitArray<S, K>> : T extends TObject<infer S> ? TObject<TOmitProperties<S, K>> : T;
-export type TParameters<T extends TFunction> = TTuple<T['parameters']>;
-export type TPartialArray<T extends TSchema[]> = Assert<{
-    [K in keyof T]: TPartial<Assert<T[K], TSchema>>;
-}, TSchema[]>;
-export type TPartialProperties<T extends TProperties> = Evaluate<Assert<{
-    [K in keyof T]: T[K] extends TReadonlyOptional<infer U> ? TReadonlyOptional<U> : T[K] extends TReadonly<infer U> ? TReadonlyOptional<U> : T[K] extends TOptional<infer U> ? TOptional<U> : TOptional<T[K]>;
-}, TProperties>>;
-export type TPartial<T extends TSchema> = T extends TIntersect<infer S> ? TIntersect<TPartialArray<S>> : T extends TUnion<infer S> ? TUnion<TPartialArray<S>> : T extends TObject<infer S> ? TObject<TPartialProperties<S>> : T;
-export type TPickArray<T extends TSchema[], K extends keyof any> = {
-    [K2 in keyof T]: TPick<Assert<T[K2], TSchema>, K>;
-};
-export type TPickProperties<T extends TProperties, K extends keyof any> = Pick<T, Assert<Extract<K, keyof T>, keyof T>> extends infer R ? ({
-    [K in keyof R]: Assert<R[K], TSchema> extends TSchema ? R[K] : never;
-}) : never;
-export type TPick<T extends TSchema, K extends keyof any> = T extends TIntersect<infer S> ? TIntersect<TPickArray<S, K>> : T extends TUnion<infer S> ? TUnion<TPickArray<S, K>> : T extends TObject<infer S> ? TObject<TPickProperties<S, K>> : T;
-export type TPromiseStatic<T extends TSchema, P extends unknown[]> = Promise<Static<T, P>>;
-export interface TPromise<T extends TSchema = TSchema> extends TSchema {
-    [Kind]: 'Promise';
-    static: TPromiseStatic<T, this['params']>;
-    type: 'object';
-    instanceOf: 'Promise';
-    item: TSchema;
-}
-export type TRecordKey = TString | TNumeric | TUnion<TLiteral<any>[]>;
-export type TRecordPropertiesFromUnionLiteral<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema> = Static<K> extends string ? {
-    [X in Static<K>]: T;
-} : never;
-export type TRecordPropertiesFromLiteral<K extends TLiteral<string | number>, T extends TSchema> = Evaluate<{
-    [K2 in K['const']]: T;
-}>;
-export type TRecordStatic<K extends TRecordKey, T extends TSchema, P extends unknown[]> = Record<Static<K>, Static<T, P>>;
-export interface TRecord<K extends TRecordKey = TRecordKey, T extends TSchema = TSchema> extends TSchema {
-    [Kind]: 'Record';
-    static: TRecordStatic<K, T, this['params']>;
-    type: 'object';
-    patternProperties: {
-        [pattern: string]: T;
-    };
-    additionalProperties: false;
-}
-export interface TSelf extends TSchema {
-    [Kind]: 'Self';
-    static: this['params'][0];
-    $ref: string;
-}
-export type TRecursiveReduce<T extends TSchema> = Static<T, [TRecursiveReduce<T>]>;
-export interface TRecursive<T extends TSchema> extends TSchema {
-    static: TRecursiveReduce<T>;
-}
-export type TRefStatic<T extends TSchema, P extends unknown[]> = Static<T, P>;
-export interface TRef<T extends TSchema = TSchema> extends TSchema {
-    [Kind]: 'Ref';
-    static: TRefStatic<T, this['params']>;
-    $ref: string;
-}
-export type TReturnType<T extends TFunction> = T['returns'];
-export type TRequiredArray<T extends TSchema[]> = Assert<{
-    [K in keyof T]: TRequired<Assert<T[K], TSchema>>;
-}, TSchema[]>;
-export type TRequiredProperties<T extends TProperties> = Evaluate<Assert<{
-    [K in keyof T]: T[K] extends TReadonlyOptional<infer U> ? TReadonly<U> : T[K] extends TReadonly<infer U> ? TReadonly<U> : T[K] extends TOptional<infer U> ? U : T[K];
-}, TProperties>>;
-export type TRequired<T extends TSchema> = T extends TIntersect<infer S> ? TIntersect<TRequiredArray<S>> : T extends TUnion<infer S> ? TUnion<TRequiredArray<S>> : T extends TObject<infer S> ? TObject<TRequiredProperties<S>> : T;
-export type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex';
-export interface StringOptions<Format extends string> extends SchemaOptions {
-    minLength?: number;
-    maxLength?: number;
-    pattern?: string;
-    format?: Format;
-    contentEncoding?: '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64';
-    contentMediaType?: string;
-}
-export interface TString<Format extends string = string> extends TSchema, StringOptions<Format> {
-    [Kind]: 'String';
-    static: string;
-    type: 'string';
-}
-export type SymbolValue = string | number | undefined;
-export interface TSymbol extends TSchema, SchemaOptions {
-    [Kind]: 'Symbol';
-    static: symbol;
-    type: 'null';
-    typeOf: 'Symbol';
-}
-export type TTupleIntoArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? Assert<R, TSchema[]> : never;
-export type TTupleStatic<T extends TSchema[], P extends unknown[]> = {
-    [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : T[K];
-};
-export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
-    [Kind]: 'Tuple';
-    static: TTupleStatic<T, this['params']>;
-    type: 'array';
-    items?: T;
-    additionalItems?: false;
-    minItems: number;
-    maxItems: number;
-}
-export interface TUndefined extends TSchema {
-    [Kind]: 'Undefined';
-    static: undefined;
-    type: 'null';
-    typeOf: 'Undefined';
-}
-export type TUnionOfLiteralArray<T extends TLiteral<string>[]> = {
-    [K in keyof T]: Assert<T[K], TLiteral>['const'];
-}[number];
-export type TUnionOfLiteral<T extends TUnion<TLiteral<string>[]>> = TUnionOfLiteralArray<T['anyOf']>;
-export interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
-    [Kind]: 'Union';
-    static: {
-        [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : never;
-    }[number];
-    anyOf: T;
-}
-export interface Uint8ArrayOptions extends SchemaOptions {
-    maxByteLength?: number;
-    minByteLength?: number;
-}
-export interface TUint8Array extends TSchema, Uint8ArrayOptions {
-    [Kind]: 'Uint8Array';
-    static: Uint8Array;
-    instanceOf: 'Uint8Array';
-    type: 'object';
-}
-export interface TUnknown extends TSchema {
-    [Kind]: 'Unknown';
-    static: unknown;
-}
-export interface UnsafeOptions extends SchemaOptions {
-    [Kind]?: string;
-}
-export interface TUnsafe<T> extends TSchema {
-    [Kind]: string;
-    static: T;
-}
-export interface TVoid extends TSchema {
-    [Kind]: 'Void';
-    static: void;
-    type: 'null';
-    typeOf: 'Void';
-}
-/** Creates a static type from a TypeBox type */
-export type Static<T extends TSchema, P extends unknown[] = []> = (T & {
-    params: P;
-})['static'];
-export type TypeRegistryValidationFunction<TSchema> = (schema: TSchema, value: unknown) => boolean;
-export declare namespace TypeRegistry {
-    /** Clears all user defined types */
-    function Clear(): void;
-    /** Returns true if this registry contains this kind */
-    function Has(kind: string): boolean;
-    /** Sets a validation function for a user defined type */
-    function Set<TSchema = unknown>(kind: string, func: TypeRegistryValidationFunction<TSchema>): void;
-    /** Gets a custom validation function for a user defined type */
-    function Get(kind: string): TypeRegistryValidationFunction<any> | undefined;
-}
-export declare namespace ReferenceRegistry {
-    /** Clears the reference registry */
-    function Clear(): void;
-    /** Returns true if this registry contains this schema */
-    function Has(schema: TSchema): boolean;
-    /** Sets this schema on this registry if a $id exists */
-    function Set(schema: TSchema): void;
-    /** Dereferences the schema one level deep */
-    function DerefOne(schema: TSchema): TSchema;
-    /** Dereferences the schema recursively */
-    function Deref(schema: TSchema): TSchema;
-}
-export type FormatRegistryValidationFunction = (value: string) => boolean;
-/** Provides functions to create user defined string formats */
-export declare namespace FormatRegistry {
-    /** Clears all user defined string formats */
-    function Clear(): void;
-    /** Returns true if the user defined string format exists */
-    function Has(format: string): boolean;
-    /** Sets a validation function for a user defined string format */
-    function Set(format: string, func: FormatRegistryValidationFunction): void;
-    /** Gets a validation function for a user defined string format */
-    function Get(format: string): FormatRegistryValidationFunction | undefined;
-}
-export declare class TypeGuardUnknownTypeError extends Error {
-    readonly schema: unknown;
-    constructor(schema: unknown);
-}
-export declare namespace TypeGuard {
-    /** Returns true if the given schema is TAny */
-    function TAny(schema: unknown): schema is TAny;
-    /** Returns true if the given schema is TArray */
-    function TArray(schema: unknown): schema is TArray;
-    /** Returns true if the given schema is TSymbol */
-    function TBigInt(schema: unknown): schema is TBigInt;
-    /** Returns true if the given schema is TBoolean */
-    function TBoolean(schema: unknown): schema is TBoolean;
-    /** Returns true if the given schema is TConstructor */
-    function TConstructor(schema: unknown): schema is TConstructor;
-    /** Returns true if the given schema is TDate */
-    function TDate(schema: unknown): schema is TDate;
-    /** Returns true if the given schema is TFunction */
-    function TFunction(schema: unknown): schema is TFunction;
-    /** Returns true if the given schema is TInteger */
-    function TInteger(schema: unknown): schema is TInteger;
-    /** Returns true if the given schema is TIntersect */
-    function TIntersect(schema: unknown): schema is TIntersect;
-    /** Returns true if the given schema is TKind */
-    function TKind(schema: unknown): schema is Record<typeof Kind | string, unknown>;
-    /** Returns true if the given schema is TLiteral */
-    function TLiteral(schema: unknown): schema is TLiteral;
-    /** Returns true if the given schema is TNever */
-    function TNever(schema: unknown): schema is TNever;
-    /** Returns true if the given schema is TNot */
-    function TNot(schema: unknown): schema is TNot;
-    /** Returns true if the given schema is TNull */
-    function TNull(schema: unknown): schema is TNull;
-    /** Returns true if the given schema is TNumber */
-    function TNumber(schema: unknown): schema is TNumber;
-    /** Returns true if the given schema is TObject */
-    function TObject(schema: unknown): schema is TObject;
-    /** Returns true if the given schema is TPromise */
-    function TPromise(schema: unknown): schema is TPromise;
-    /** Returns true if the given schema is TRecord */
-    function TRecord(schema: unknown): schema is TRecord;
-    /** Returns true if the given schema is TSelf */
-    function TSelf(schema: unknown): schema is TSelf;
-    /** Returns true if the given schema is TRef */
-    function TRef(schema: unknown): schema is TRef;
-    /** Returns true if the given schema is TString */
-    function TString(schema: unknown): schema is TString;
-    /** Returns true if the given schema is TSymbol */
-    function TSymbol(schema: unknown): schema is TSymbol;
-    /** Returns true if the given schema is TTuple */
-    function TTuple(schema: unknown): schema is TTuple;
-    /** Returns true if the given schema is TUndefined */
-    function TUndefined(schema: unknown): schema is TUndefined;
-    /** Returns true if the given schema is TUnion */
-    function TUnion(schema: unknown): schema is TUnion;
-    /** Returns true if the given schema is TUnion<Literal<string>[]> */
-    function TUnionLiteral(schema: unknown): schema is TUnion<TLiteral<string>[]>;
-    /** Returns true if the given schema is TUint8Array */
-    function TUint8Array(schema: unknown): schema is TUint8Array;
-    /** Returns true if the given schema is TUnknown */
-    function TUnknown(schema: unknown): schema is TUnknown;
-    /** Returns true if the given schema is TVoid */
-    function TVoid(schema: unknown): schema is TVoid;
-    /** Returns true if this schema has the ReadonlyOptional modifier */
-    function TReadonlyOptional<T extends TSchema>(schema: T): schema is TReadonlyOptional<T>;
-    /** Returns true if this schema has the Readonly modifier */
-    function TReadonly<T extends TSchema>(schema: T): schema is TReadonly<T>;
-    /** Returns true if this schema has the Optional modifier */
-    function TOptional<T extends TSchema>(schema: T): schema is TOptional<T>;
-    /** Returns true if the given schema is TSchema */
-    function TSchema(schema: unknown): schema is TSchema;
-}
-export declare namespace ExtendsUndefined {
-    /** Fast undefined check for properties of type undefined */
-    function Check(schema: TSchema): boolean;
-}
-export declare enum TypeExtendsResult {
-    Union = 0,
-    True = 1,
-    False = 2
-}
-export declare namespace TypeExtends {
-    function Extends(left: TSchema, right: TSchema): TypeExtendsResult;
-}
-/** Specialized Clone for Types. */
-export declare namespace TypeClone {
-    function Clone<T extends TSchema | TProperties>(schema: T, options: SchemaOptions): T;
-}
-export declare namespace ObjectMap {
-    function Map<T = TSchema>(schema: TSchema, callback: (object: TObject) => TObject, options: SchemaOptions): T;
-}
-export declare namespace KeyResolver {
-    function Resolve<T extends TSchema>(schema: T): string[];
-}
-export declare class TypeBuilder {
-    /** `[Utility]` Creates a schema without `static` and `params` types */
-    protected Create<T>(schema: Omit<T, 'static' | 'params'>): T;
-    /** `[Utility]` Clones a schema or properties object */
-    protected Clone<T extends TSchema | TProperties>(schema: T, options?: SchemaOptions): T;
-    /** `[Standard]` Omits compositing symbols from this schema */
-    Strict<T extends TSchema>(schema: T): T;
-}
-export declare class StandardTypeBuilder extends TypeBuilder {
-    /** `[Modifier]` Creates a Optional property */
-    Optional<T extends TSchema>(schema: T): TOptional<T>;
-    /** `[Modifier]` Creates a ReadonlyOptional property */
-    ReadonlyOptional<T extends TSchema>(schema: T): TReadonlyOptional<T>;
-    /** `[Modifier]` Creates a Readonly object or property */
-    Readonly<T extends TSchema>(schema: T): TReadonly<T>;
-    /** `[Standard]` Creates an Any type */
-    Any(options?: SchemaOptions): TAny;
-    /** `[Standard]` Creates an Array type */
-    Array<T extends TSchema>(items: T, options?: ArrayOptions): TArray<T>;
-    /** `[Standard]` Creates a Boolean type */
-    Boolean(options?: SchemaOptions): TBoolean;
-    /** `[Standard]` Creates a Composite object type that will Union any overlapping properties of the given Object array */
-    Composite<T extends TObject[]>(schemas: [...T], options?: ObjectOptions): TComposite<T>;
-    /** `[Standard]` Dereferences the given TRef to its target type */
-    Deref<T extends TRef>(schema: T): TDeref<T>;
-    /** `[Standard]` Creates a Enum type */
-    Enum<T extends Record<string, string | number>>(item: T, options?: SchemaOptions): TEnum<T>;
-    /** `[Standard]` A conditional type expression that will return the true type if the left type extends the right */
-    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>;
-    /** `[Standard]` Excludes from the left type any type that is not assignable to the right */
-    Exclude<L extends TSchema, R extends TSchema>(left: L, right: R, options?: SchemaOptions): TExclude<L, R>;
-    /** `[Standard]` Extracts from left left any type that is assignable to the right */
-    Extract<L extends TSchema, R extends TSchema>(left: L, right: R, options?: SchemaOptions): TExtract<L, R>;
-    /** `[Standard]` Creates an Integer type */
-    Integer(options?: NumericOptions<number>): TInteger;
-    /** `[Standard]` Creates a Intersect type */
-    Intersect(allOf: [], options?: SchemaOptions): TNever;
-    /** `[Standard]` Creates a Intersect type */
-    Intersect<T extends [TSchema]>(allOf: [...T], options?: SchemaOptions): T[0];
-    Intersect<T extends TSchema[]>(allOf: [...T], options?: IntersectOptions): TIntersect<T>;
-    /** `[Standard]` Creates a KeyOf type */
-    KeyOf<T extends TSchema>(schema: T, options?: SchemaOptions): TKeyOf<T>;
-    /** `[Standard]` Creates a Literal type */
-    Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T>;
-    /** `[Standard]` Creates a Never type */
-    Never(options?: SchemaOptions): TNever;
-    /** `[Standard]` Creates a Not type. The first argument is the disallowed type, the second is the allowed. */
-    Not<N extends TSchema, T extends TSchema>(not: N, schema: T, options?: SchemaOptions): TNot<N, T>;
-    /** `[Standard]` Creates a Null type */
-    Null(options?: SchemaOptions): TNull;
-    /** `[Standard]` Creates a Number type */
-    Number(options?: NumericOptions<number>): TNumber;
-    /** `[Standard]` Creates an Object type */
-    Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
-    /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
-    Omit<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TOmit<T, K[number]>;
-    /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
-    Omit<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TOmit<T, TUnionOfLiteral<K>>;
-    /** `[Standard]` Creates a mapped type where all properties are Optional */
-    Partial<T extends TSchema>(schema: T, options?: ObjectOptions): TPartial<T>;
-    /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
-    Pick<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TPick<T, K[number]>;
-    /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
-    Pick<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TPick<T, TUnionOfLiteral<K>>;
-    /** `[Standard]` Creates an Object type from the given Literal Union */
-    Record<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TObject<TRecordPropertiesFromUnionLiteral<K, T>>;
-    /** `[Standard]` Creates an Object type from the given Literal Union */
-    Record<K extends TLiteral<string | number>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TObject<TRecordPropertiesFromLiteral<K, T>>;
-    /** `[Standard]` Creates a Record type */
-    Record<K extends TString | TNumeric, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TRecord<K, T>;
-    /** `[Standard]` Creates a Recursive type */
-    Recursive<T extends TSchema>(callback: (self: TSelf) => T, options?: SchemaOptions): TRecursive<T>;
-    /** `[Standard]` Creates a Ref type. The referenced type must contain a $id */
-    Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>;
-    /** `[Standard]` Creates a mapped type where all properties are Required */
-    Required<T extends TSchema>(schema: T, options?: SchemaOptions): TRequired<T>;
-    /** `[Standard]` Creates a String type */
-    String<Format extends string>(options?: StringOptions<StringFormatOption | Format>): TString<Format>;
-    /** `[Standard]` Creates a Tuple type */
-    Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T>;
-    /** `[Standard]` Creates a Union type */
-    Union(anyOf: [], options?: SchemaOptions): TNever;
-    /** `[Standard]` Creates a Union type */
-    Union<T extends [TSchema]>(anyOf: [...T], options?: SchemaOptions): T[0];
-    /** `[Standard]` Creates a Union type */
-    Union<T extends TSchema[]>(anyOf: [...T], options?: SchemaOptions): TUnion<T>;
-    /** `[Standard]` Creates an Unknown type */
-    Unknown(options?: SchemaOptions): TUnknown;
-    /** `[Standard]` Creates a Unsafe type that infers for the generic argument */
-    Unsafe<T>(options?: UnsafeOptions): TUnsafe<T>;
-}
-export declare class ExtendedTypeBuilder extends StandardTypeBuilder {
-    /** `[Extended]` Creates a BigInt type */
-    BigInt(options?: NumericOptions<bigint>): TBigInt;
-    /** `[Extended]` Extracts the ConstructorParameters from the given Constructor type */
-    ConstructorParameters<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TConstructorParameters<T>;
-    /** `[Extended]` Creates a Constructor type */
-    Constructor<T extends TTuple<TSchema[]>, U extends TSchema>(parameters: T, returns: U, options?: SchemaOptions): TConstructor<TTupleIntoArray<T>, U>;
-    /** `[Extended]` Creates a Constructor type */
-    Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U>;
-    /** `[Extended]` Creates a Date type */
-    Date(options?: DateOptions): TDate;
-    /** `[Extended]` Creates a Function type */
-    Function<T extends TTuple<TSchema[]>, U extends TSchema>(parameters: T, returns: U, options?: SchemaOptions): TFunction<TTupleIntoArray<T>, U>;
-    /** `[Extended]` Creates a Function type */
-    Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U>;
-    /** `[Extended]` Extracts the InstanceType from the given Constructor */
-    InstanceType<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TInstanceType<T>;
-    /** `[Extended]` Extracts the Parameters from the given Function type */
-    Parameters<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TParameters<T>;
-    /** `[Extended]` Creates a Promise type */
-    Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T>;
-    /** `[Extended]` Creates a regular expression type */
-    RegEx(regex: RegExp, options?: SchemaOptions): TString;
-    /** `[Extended]` Extracts the ReturnType from the given Function */
-    ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T>;
-    /** `[Extended]` Creates a Symbol type */
-    Symbol(options?: SchemaOptions): TSymbol;
-    /** `[Extended]` Creates a Undefined type */
-    Undefined(options?: SchemaOptions): TUndefined;
-    /** `[Extended]` Creates a Uint8Array type */
-    Uint8Array(options?: Uint8ArrayOptions): TUint8Array;
-    /** `[Extended]` Creates a Void type */
-    Void(options?: SchemaOptions): TVoid;
-}
-/** JSON Schema TypeBuilder with Static Resolution for TypeScript */
-export declare const StandardType: StandardTypeBuilder;
-/** JSON Schema TypeBuilder with Static Resolution for TypeScript */
-export declare const Type: ExtendedTypeBuilder;
+export declare const Recursive: unique symbol;
+export declare const Modifier: unique symbol;
+export declare const Hint: unique symbol;
+export declare const Kind: unique symbol;
+export type TupleToIntersect<T extends any[]> = T extends [infer I] ? I : T extends [infer I, ...infer R] ? I & TupleToIntersect<R> : never;
+export type TupleToUnion<T extends any[]> = {
+    [K in keyof T]: T[K];
+}[number];
+export type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
+export type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
+export type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, L>>, L];
+export type Assert<T, E> = T extends E ? T : never;
+export type Evaluate<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+export type Ensure<T> = T extends infer U ? U : never;
+export type TModifier = TReadonlyOptional<TSchema> | TOptional<TSchema> | TReadonly<TSchema>;
+export type TReadonly<T extends TSchema> = T & {
+    [Modifier]: 'Readonly';
+};
+export type TOptional<T extends TSchema> = T & {
+    [Modifier]: 'Optional';
+};
+export type TReadonlyOptional<T extends TSchema> = T & {
+    [Modifier]: 'ReadonlyOptional';
+};
+export interface SchemaOptions {
+    $schema?: string;
+    /** Id for this schema */
+    readonly $id?: string;
+    /** Title of this schema */
+    title?: string;
+    /** Description of this schema */
+    description?: string;
+    /** Default value for this schema */
+    default?: any;
+    /** Example values matching this schema */
+    examples?: any;
+    [prop: string]: any;
+}
+export interface TKind {
+    [Kind]: string;
+}
+export interface TSchema extends SchemaOptions, TKind {
+    [Modifier]?: string;
+    [Recursive]?: string;
+    [Hint]?: string;
+    params: unknown[];
+    static: unknown;
+}
+export type TAnySchema = TSchema | TAny | TArray | TBigInt | TBoolean | TConstructor | TDate | TEnum | TFunction | TInteger | TIntersect | TLiteral | TNot | TNull | TNumber | TObject | TPromise | TRecord | TRef | TSelf | TString | TSymbol | TTuple | TUndefined | TUnion | TUint8Array | TUnknown | TVoid;
+export type TNumeric = TInteger | TNumber;
+export interface NumericOptions<N extends number | bigint> extends SchemaOptions {
+    exclusiveMaximum?: N;
+    exclusiveMinimum?: N;
+    maximum?: N;
+    minimum?: N;
+    multipleOf?: N;
+}
+export interface TAny extends TSchema {
+    [Kind]: 'Any';
+    static: any;
+}
+export interface ArrayOptions extends SchemaOptions {
+    uniqueItems?: boolean;
+    minItems?: number;
+    maxItems?: number;
+}
+export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptions {
+    [Kind]: 'Array';
+    static: Static<T, this['params']>[];
+    type: 'array';
+    items: T;
+}
+export interface TBigInt extends TSchema, NumericOptions<bigint> {
+    [Kind]: 'BigInt';
+    static: bigint;
+    type: 'null';
+    typeOf: 'BigInt';
+}
+export interface TBoolean extends TSchema {
+    [Kind]: 'Boolean';
+    static: boolean;
+    type: 'boolean';
+}
+export type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = TTuple<T['parameters']>;
+export type TDeref<T> = T extends TRef<infer U> ? TDeref<U> : T;
+export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns'];
+export type TCompositeUnion<Left extends TSchema, Right extends TSchema> = Ensure<TUnion<[Left, Right]>>;
+export type TCompositeMerge<T extends TObject, Output extends Record<any, TSchema>> = Evaluate<{
+    [Key in keyof T['properties']]: Key extends keyof Output ? TCompositeUnion<T['properties'][Key], Output[Key]> : T['properties'][Key];
+} & {
+    [Key in keyof Output]: Key extends keyof T['properties'] ? TCompositeUnion<T['properties'][Key], Output[Key]> : Output[Key];
+}>;
+export type TCompositeReduce<T extends TObject[], Output extends {}> = T extends [infer L, ...infer R] ? TCompositeReduce<[...Assert<R, TObject[]>], TCompositeMerge<Assert<L, TObject>, Output>> : T extends [] ? Output : never;
+export type TComposite<T extends TObject[]> = Ensure<TObject<TCompositeReduce<T, {}>>>;
+export type TConstructorParameterArray<T extends readonly TSchema[], P extends unknown[]> = [...{
+    [K in keyof T]: Static<Assert<T[K], TSchema>, P>;
+}];
+export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Constructor';
+    static: new (...param: TConstructorParameterArray<T, this['params']>) => Static<U, this['params']>;
+    type: 'object';
+    instanceOf: 'Constructor';
+    parameters: T;
+    returns: U;
+}
+export interface DateOptions extends SchemaOptions {
+    exclusiveMaximumTimestamp?: number;
+    exclusiveMinimumTimestamp?: number;
+    maximumTimestamp?: number;
+    minimumTimestamp?: number;
+}
+export interface TDate extends TSchema, DateOptions {
+    [Kind]: 'Date';
+    static: Date;
+    type: 'object';
+    instanceOf: 'Date';
+}
+export interface TEnumOption<T> {
+    type: 'number' | 'string';
+    const: T;
+}
+export type TEnumStatic<T extends Record<string, string | number>> = T[keyof T];
+export interface TEnum<T extends Record<string, string | number> = Record<string, string | number>> extends TSchema {
+    [Kind]: 'Union';
+    static: TEnumStatic<T>;
+    anyOf: TLiteral<string | number>[];
+}
+export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = (Static<L> extends Static<R> ? T : U) extends infer O ? UnionToTuple<O> extends [infer X, infer Y] ? TUnion<[Assert<X, TSchema>, Assert<Y, TSchema>]> : Assert<O, TSchema> : never;
+export type TExcludeArray<T extends TSchema[], U extends TSchema> = Assert<UnionToTuple<{
+    [K in keyof T]: Static<Assert<T[K], TSchema>> extends Static<U> ? never : T[K];
+}[number]>, TSchema[]> extends infer R ? TUnionResult<Assert<R, TSchema[]>> : never;
+export type TExclude<T extends TSchema, U extends TSchema> = T extends TUnion<infer S> ? TExcludeArray<S, U> : T extends U ? TNever : T;
+export type TExtractArray<T extends TSchema[], U extends TSchema> = Assert<UnionToTuple<{
+    [K in keyof T]: Static<Assert<T[K], TSchema>> extends Static<U> ? T[K] : never;
+}[number]>, TSchema[]> extends infer R ? TUnionResult<Assert<R, TSchema[]>> : never;
+export type TExtract<T extends TSchema, U extends TSchema> = T extends TUnion<infer S> ? TExtractArray<S, U> : T extends U ? T : TNever;
+export type TFunctionParameters<T extends readonly TSchema[], P extends unknown[]> = [...{
+    [K in keyof T]: Static<Assert<T[K], TSchema>, P>;
+}];
+export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Function';
+    static: (...param: TFunctionParameters<T, this['params']>) => Static<U, this['params']>;
+    type: 'object';
+    instanceOf: 'Function';
+    parameters: T;
+    returns: U;
+}
+export interface TInteger extends TSchema, NumericOptions<number> {
+    [Kind]: 'Integer';
+    static: number;
+    type: 'integer';
+}
+export type TUnevaluatedProperties = undefined | TSchema | boolean;
+export interface IntersectOptions extends SchemaOptions {
+    unevaluatedProperties?: TUnevaluatedProperties;
+}
+export type TIntersectStatic<T extends TSchema[], P extends unknown[]> = TupleToIntersect<{
+    [K in keyof T]: Static<Assert<T[K], TSchema>, P>;
+}>;
+export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, IntersectOptions {
+    [Kind]: 'Intersect';
+    type?: 'object';
+    static: TIntersectStatic<T, this['params']>;
+    allOf: [...T];
+}
+export type TKeyOfTuple<T extends TSchema> = {
+    [K in keyof Static<T>]: TLiteral<Assert<K, TLiteralValue>>;
+} extends infer U ? UnionToTuple<Exclude<{
+    [K in keyof U]: U[K];
+}[keyof U], undefined>> : never;
+export type TKeyOf<T extends TSchema = TSchema, D = TDeref<T>> = (D extends TIntersect ? TKeyOfTuple<T> : D extends TUnion ? TKeyOfTuple<T> : D extends TObject ? TKeyOfTuple<T> : [
+]) extends infer R ? TUnionResult<Assert<R, TSchema[]>> : never;
+export type TLiteralValue = string | number | boolean | bigint;
+export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSchema {
+    [Kind]: 'Literal';
+    static: T;
+    const: T;
+}
+export interface TNever extends TSchema {
+    [Kind]: 'Never';
+    static: never;
+    allOf: [{
+        type: 'boolean';
+        const: false;
+    }, {
+        type: 'boolean';
+        const: true;
+    }];
+}
+export type TNotStatic<_ extends TSchema = TSchema, T extends TSchema = TSchema> = Static<T>;
+export interface TNot<Not extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Not';
+    static: TNotStatic<Not, T>;
+    allOf: [{
+        not: Not;
+    }, T];
+}
+export interface TNull extends TSchema {
+    [Kind]: 'Null';
+    static: null;
+    type: 'null';
+}
+export interface TNumber extends TSchema, NumericOptions<number> {
+    [Kind]: 'Number';
+    static: number;
+    type: 'number';
+}
+export type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TReadonlyOptional<TSchema> ? K : never;
+}[keyof T];
+export type ReadonlyPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TReadonly<TSchema> ? K : never;
+}[keyof T];
+export type OptionalPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TOptional<TSchema> ? K : never;
+}[keyof T];
+export type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
+export type PropertiesReducer<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> & Readonly<Pick<R, ReadonlyPropertyKeys<T>>> & Partial<Pick<R, OptionalPropertyKeys<T>>> & Required<Pick<R, RequiredPropertyKeys<T>>>)>;
+export type PropertiesReduce<T extends TProperties, P extends unknown[]> = PropertiesReducer<T, {
+    [K in keyof T]: Static<T[K], P>;
+}>;
+export type TProperties = Record<keyof any, TSchema>;
+export type ObjectProperties<T> = T extends TObject<infer U> ? U : never;
+export type ObjectPropertyKeys<T> = T extends TObject<infer U> ? keyof U : never;
+export type TAdditionalProperties = undefined | TSchema | boolean;
+export interface ObjectOptions extends SchemaOptions {
+    additionalProperties?: TAdditionalProperties;
+    minProperties?: number;
+    maxProperties?: number;
+}
+export interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
+    [Kind]: 'Object';
+    static: PropertiesReduce<T, this['params']>;
+    additionalProperties?: TAdditionalProperties;
+    type: 'object';
+    properties: T;
+    required?: string[];
+}
+export type TOmitArray<T extends TSchema[], K extends keyof any> = Assert<{
+    [K2 in keyof T]: TOmit<Assert<T[K2], TSchema>, K>;
+}, TSchema[]>;
+export type TOmitProperties<T extends TProperties, K extends keyof any> = Evaluate<Assert<Omit<T, K>, TProperties>>;
+export type TOmit<T extends TSchema, K extends keyof any, D = TDeref<T>> = D extends TIntersect<infer S> ? TIntersect<TOmitArray<S, K>> : D extends TUnion<infer S> ? TUnion<TOmitArray<S, K>> : D extends TObject<infer S> ? TObject<TOmitProperties<S, K>> : D;
+export type TParameters<T extends TFunction> = TTuple<T['parameters']>;
+export type TPartialArray<T extends TSchema[]> = Assert<{
+    [K in keyof T]: TPartial<Assert<T[K], TSchema>>;
+}, TSchema[]>;
+export type TPartialProperties<T extends TProperties> = Evaluate<Assert<{
+    [K in keyof T]: T[K] extends TReadonlyOptional<infer U> ? TReadonlyOptional<U> : T[K] extends TReadonly<infer U> ? TReadonlyOptional<U> : T[K] extends TOptional<infer U> ? TOptional<U> : TOptional<T[K]>;
+}, TProperties>>;
+export type TPartial<T extends TSchema, D = TDeref<T>> = D extends TIntersect<infer S> ? TIntersect<TPartialArray<S>> : D extends TUnion<infer S> ? TUnion<TPartialArray<S>> : D extends TObject<infer S> ? TObject<TPartialProperties<S>> : D;
+export type TPickArray<T extends TSchema[], K extends keyof any> = {
+    [K2 in keyof T]: TPick<Assert<T[K2], TSchema>, K>;
+};
+export type TPickProperties<T extends TProperties, K extends keyof any> = Pick<T, Assert<Extract<K, keyof T>, keyof T>> extends infer R ? ({
+    [K in keyof R]: Assert<R[K], TSchema> extends TSchema ? R[K] : never;
+}) : never;
+export type TPick<T extends TSchema, K extends keyof any, D = TDeref<T>> = D extends TIntersect<infer S> ? TIntersect<TPickArray<S, K>> : D extends TUnion<infer S> ? TUnion<TPickArray<S, K>> : D extends TObject<infer S> ? TObject<TPickProperties<S, K>> : D;
+export type TPromiseStatic<T extends TSchema, P extends unknown[]> = Promise<Static<T, P>>;
+export interface TPromise<T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Promise';
+    static: TPromiseStatic<T, this['params']>;
+    type: 'object';
+    instanceOf: 'Promise';
+    item: TSchema;
+}
+export type TRecordKey = TString | TNumeric | TUnion<TLiteral<any>[]>;
+export type TRecordPropertiesFromUnionLiteral<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema> = Static<K> extends string ? {
+    [X in Static<K>]: T;
+} : never;
+export type TRecordPropertiesFromLiteral<K extends TLiteral<string | number>, T extends TSchema> = Evaluate<{
+    [K2 in K['const']]: T;
+}>;
+export type TRecordStatic<K extends TRecordKey, T extends TSchema, P extends unknown[]> = Record<Static<K>, Static<T, P>>;
+export interface TRecord<K extends TRecordKey = TRecordKey, T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Record';
+    static: TRecordStatic<K, T, this['params']>;
+    type: 'object';
+    patternProperties: {
+        [pattern: string]: T;
+    };
+    additionalProperties: false;
+}
+export interface TSelf extends TSchema {
+    [Kind]: 'Self';
+    static: this['params'][0];
+    $ref: string;
+}
+export type TRecursiveReduce<T extends TSchema> = Static<T, [TRecursiveReduce<T>]>;
+export interface TRecursive<T extends TSchema> extends TSchema {
+    static: TRecursiveReduce<T>;
+}
+export type TRefStatic<T extends TSchema, P extends unknown[]> = Static<T, P>;
+export interface TRef<T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Ref';
+    static: TRefStatic<T, this['params']>;
+    $ref: string;
+}
+export type TReturnType<T extends TFunction> = T['returns'];
+export type TRequiredArray<T extends TSchema[]> = Assert<{
+    [K in keyof T]: TRequired<Assert<T[K], TSchema>>;
+}, TSchema[]>;
+export type TRequiredProperties<T extends TProperties> = Evaluate<Assert<{
+    [K in keyof T]: T[K] extends TReadonlyOptional<infer U> ? TReadonly<U> : T[K] extends TReadonly<infer U> ? TReadonly<U> : T[K] extends TOptional<infer U> ? U : T[K];
+}, TProperties>>;
+export type TRequired<T extends TSchema, D = TDeref<T>> = D extends TIntersect<infer S> ? TIntersect<TRequiredArray<S>> : D extends TUnion<infer S> ? TUnion<TRequiredArray<S>> : D extends TObject<infer S> ? TObject<TRequiredProperties<S>> : D;
+export type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex';
+export interface StringOptions<Format extends string> extends SchemaOptions {
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: Format;
+    contentEncoding?: '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64';
+    contentMediaType?: string;
+}
+export interface TString<Format extends string = string> extends TSchema, StringOptions<Format> {
+    [Kind]: 'String';
+    static: string;
+    type: 'string';
+}
+export type SymbolValue = string | number | undefined;
+export interface TSymbol extends TSchema, SchemaOptions {
+    [Kind]: 'Symbol';
+    static: symbol;
+    type: 'null';
+    typeOf: 'Symbol';
+}
+export type TTupleIntoArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? Assert<R, TSchema[]> : never;
+export type TTupleStatic<T extends TSchema[], P extends unknown[]> = {
+    [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : T[K];
+};
+export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
+    [Kind]: 'Tuple';
+    static: TTupleStatic<T, this['params']>;
+    type: 'array';
+    items?: T;
+    additionalItems?: false;
+    minItems: number;
+    maxItems: number;
+}
+export interface TUndefined extends TSchema {
+    [Kind]: 'Undefined';
+    static: undefined;
+    type: 'null';
+    typeOf: 'Undefined';
+}
+export type TUnionOfLiteralArray<T extends TLiteral<string>[]> = {
+    [K in keyof T]: Assert<T[K], TLiteral>['const'];
+}[number];
+export type TUnionOfLiteral<T extends TUnion<TLiteral<string>[]>> = TUnionOfLiteralArray<T['anyOf']>;
+export type TUnionResult<T extends TSchema[]> = T extends [] ? TNever : T extends [infer S] ? S : TUnion<T>;
+export interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
+    [Kind]: 'Union';
+    static: {
+        [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : never;
+    }[number];
+    anyOf: T;
+}
+export interface Uint8ArrayOptions extends SchemaOptions {
+    maxByteLength?: number;
+    minByteLength?: number;
+}
+export interface TUint8Array extends TSchema, Uint8ArrayOptions {
+    [Kind]: 'Uint8Array';
+    static: Uint8Array;
+    instanceOf: 'Uint8Array';
+    type: 'object';
+}
+export interface TUnknown extends TSchema {
+    [Kind]: 'Unknown';
+    static: unknown;
+}
+export interface UnsafeOptions extends SchemaOptions {
+    [Kind]?: string;
+}
+export interface TUnsafe<T> extends TSchema {
+    [Kind]: string;
+    static: T;
+}
+export interface TVoid extends TSchema {
+    [Kind]: 'Void';
+    static: void;
+    type: 'null';
+    typeOf: 'Void';
+}
+/** Creates a static type from a TypeBox type */
+export type Static<T extends TSchema, P extends unknown[] = []> = (T & {
+    params: P;
+})['static'];
+export type TypeRegistryValidationFunction<TSchema> = (schema: TSchema, value: unknown) => boolean;
+export declare namespace TypeRegistry {
+    /** Clears all user defined types */
+    function Clear(): void;
+    /** Returns true if this registry contains this kind */
+    function Has(kind: string): boolean;
+    /** Sets a validation function for a user defined type */
+    function Set<TSchema = unknown>(kind: string, func: TypeRegistryValidationFunction<TSchema>): void;
+    /** Gets a custom validation function for a user defined type */
+    function Get(kind: string): TypeRegistryValidationFunction<any> | undefined;
+}
+export declare namespace ReferenceRegistry {
+    /** Clears the reference registry */
+    function Clear(): void;
+    /** Returns true if this registry contains this schema */
+    function Has(schema: TSchema): boolean;
+    /** Sets this schema on this registry if a $id exists */
+    function Set(schema: TSchema): void;
+    /** Dereferences the schema one level deep */
+    function DerefOne(schema: TSchema): TSchema;
+    /** Dereferences the schema recursively */
+    function Deref(schema: TSchema): TSchema;
+}
+export type FormatRegistryValidationFunction = (value: string) => boolean;
+/** Provides functions to create user defined string formats */
+export declare namespace FormatRegistry {
+    /** Clears all user defined string formats */
+    function Clear(): void;
+    /** Returns true if the user defined string format exists */
+    function Has(format: string): boolean;
+    /** Sets a validation function for a user defined string format */
+    function Set(format: string, func: FormatRegistryValidationFunction): void;
+    /** Gets a validation function for a user defined string format */
+    function Get(format: string): FormatRegistryValidationFunction | undefined;
+}
+export declare class TypeGuardUnknownTypeError extends Error {
+    readonly schema: unknown;
+    constructor(schema: unknown);
+}
+export declare namespace TypeGuard {
+    /** Returns true if the given schema is TAny */
+    function TAny(schema: unknown): schema is TAny;
+    /** Returns true if the given schema is TArray */
+    function TArray(schema: unknown): schema is TArray;
+    /** Returns true if the given schema is TSymbol */
+    function TBigInt(schema: unknown): schema is TBigInt;
+    /** Returns true if the given schema is TBoolean */
+    function TBoolean(schema: unknown): schema is TBoolean;
+    /** Returns true if the given schema is TConstructor */
+    function TConstructor(schema: unknown): schema is TConstructor;
+    /** Returns true if the given schema is TDate */
+    function TDate(schema: unknown): schema is TDate;
+    /** Returns true if the given schema is TFunction */
+    function TFunction(schema: unknown): schema is TFunction;
+    /** Returns true if the given schema is TInteger */
+    function TInteger(schema: unknown): schema is TInteger;
+    /** Returns true if the given schema is TIntersect */
+    function TIntersect(schema: unknown): schema is TIntersect;
+    /** Returns true if the given schema is TKind */
+    function TKind(schema: unknown): schema is Record<typeof Kind | string, unknown>;
+    /** Returns true if the given schema is TLiteral */
+    function TLiteral(schema: unknown): schema is TLiteral;
+    /** Returns true if the given schema is TNever */
+    function TNever(schema: unknown): schema is TNever;
+    /** Returns true if the given schema is TNot */
+    function TNot(schema: unknown): schema is TNot;
+    /** Returns true if the given schema is TNull */
+    function TNull(schema: unknown): schema is TNull;
+    /** Returns true if the given schema is TNumber */
+    function TNumber(schema: unknown): schema is TNumber;
+    /** Returns true if the given schema is TObject */
+    function TObject(schema: unknown): schema is TObject;
+    /** Returns true if the given schema is TPromise */
+    function TPromise(schema: unknown): schema is TPromise;
+    /** Returns true if the given schema is TRecord */
+    function TRecord(schema: unknown): schema is TRecord;
+    /** Returns true if the given schema is TSelf */
+    function TSelf(schema: unknown): schema is TSelf;
+    /** Returns true if the given schema is TRef */
+    function TRef(schema: unknown): schema is TRef;
+    /** Returns true if the given schema is TString */
+    function TString(schema: unknown): schema is TString;
+    /** Returns true if the given schema is TSymbol */
+    function TSymbol(schema: unknown): schema is TSymbol;
+    /** Returns true if the given schema is TTuple */
+    function TTuple(schema: unknown): schema is TTuple;
+    /** Returns true if the given schema is TUndefined */
+    function TUndefined(schema: unknown): schema is TUndefined;
+    /** Returns true if the given schema is TUnion */
+    function TUnion(schema: unknown): schema is TUnion;
+    /** Returns true if the given schema is TUnion<Literal<string>[]> */
+    function TUnionLiteral(schema: unknown): schema is TUnion<TLiteral<string>[]>;
+    /** Returns true if the given schema is TUint8Array */
+    function TUint8Array(schema: unknown): schema is TUint8Array;
+    /** Returns true if the given schema is TUnknown */
+    function TUnknown(schema: unknown): schema is TUnknown;
+    /** Returns true if the given schema is TVoid */
+    function TVoid(schema: unknown): schema is TVoid;
+    /** Returns true if this schema has the ReadonlyOptional modifier */
+    function TReadonlyOptional<T extends TSchema>(schema: T): schema is TReadonlyOptional<T>;
+    /** Returns true if this schema has the Readonly modifier */
+    function TReadonly<T extends TSchema>(schema: T): schema is TReadonly<T>;
+    /** Returns true if this schema has the Optional modifier */
+    function TOptional<T extends TSchema>(schema: T): schema is TOptional<T>;
+    /** Returns true if the given schema is TSchema */
+    function TSchema(schema: unknown): schema is TSchema;
+}
+export declare namespace ExtendsUndefined {
+    /** Fast undefined check for properties of type undefined */
+    function Check(schema: TSchema): boolean;
+}
+export declare enum TypeExtendsResult {
+    Union = 0,
+    True = 1,
+    False = 2
+}
+export declare namespace TypeExtends {
+    function Extends(left: TSchema, right: TSchema): TypeExtendsResult;
+}
+/** Specialized Clone for Types. Clones and removes non self-referential identifiers */
+export declare namespace TypeClone {
+    /** Clones a type. This function will omit non-self referential identifiers on the cloned type. */
+    function Clone<T extends TSchema>(schema: T, options: SchemaOptions): T;
+}
+export declare namespace ObjectMap {
+    function Map<T = TSchema>(schema: TSchema, callback: (object: TObject) => TObject, options: SchemaOptions): T;
+}
+export declare namespace KeyResolver {
+    function Resolve<T extends TSchema>(schema: T): string[];
+}
+export declare class TypeBuilder {
+    /** `[Utility]` Creates a schema without `static` and `params` types */
+    protected Create<T>(schema: Omit<T, 'static' | 'params'>): T;
+    /** `[Standard]` Omits compositing symbols from this schema */
+    Strict<T extends TSchema>(schema: T): T;
+}
+export declare class StandardTypeBuilder extends TypeBuilder {
+    /** `[Modifier]` Creates a Optional property */
+    Optional<T extends TSchema>(schema: T): TOptional<T>;
+    /** `[Modifier]` Creates a ReadonlyOptional property */
+    ReadonlyOptional<T extends TSchema>(schema: T): TReadonlyOptional<T>;
+    /** `[Modifier]` Creates a Readonly object or property */
+    Readonly<T extends TSchema>(schema: T): TReadonly<T>;
+    /** `[Standard]` Creates an Any type */
+    Any(options?: SchemaOptions): TAny;
+    /** `[Standard]` Creates an Array type */
+    Array<T extends TSchema>(items: T, options?: ArrayOptions): TArray<T>;
+    /** `[Standard]` Creates a Boolean type */
+    Boolean(options?: SchemaOptions): TBoolean;
+    /** `[Standard]` Creates a Composite object type that will Union any overlapping properties of the given Object array */
+    Composite<T extends TObject[]>(schemas: [...T], options?: ObjectOptions): TComposite<T>;
+    /** `[Standard]` Dereferences the given TRef to its target type */
+    Deref<T extends TRef>(schema: T): TDeref<T>;
+    /** `[Standard]` Creates a Enum type */
+    Enum<T extends Record<string, string | number>>(item: T, options?: SchemaOptions): TEnum<T>;
+    /** `[Standard]` A conditional type expression that will return the true type if the left type extends the right */
+    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>;
+    /** `[Standard]` Excludes from the left type any type that is not assignable to the right */
+    Exclude<L extends TSchema, R extends TSchema>(left: L, right: R, options?: SchemaOptions): TExclude<L, R>;
+    /** `[Standard]` Extracts from left left any type that is assignable to the right */
+    Extract<L extends TSchema, R extends TSchema>(left: L, right: R, options?: SchemaOptions): TExtract<L, R>;
+    /** `[Standard]` Creates an Integer type */
+    Integer(options?: NumericOptions<number>): TInteger;
+    /** `[Standard]` Creates a Intersect type */
+    Intersect(allOf: [], options?: SchemaOptions): TNever;
+    /** `[Standard]` Creates a Intersect type */
+    Intersect<T extends [TSchema]>(allOf: [...T], options?: SchemaOptions): T[0];
+    Intersect<T extends TSchema[]>(allOf: [...T], options?: IntersectOptions): TIntersect<T>;
+    /** `[Standard]` Creates a KeyOf type */
+    KeyOf<T extends TSchema>(schema: T, options?: SchemaOptions): TKeyOf<T>;
+    /** `[Standard]` Creates a Literal type */
+    Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T>;
+    /** `[Standard]` Creates a Never type */
+    Never(options?: SchemaOptions): TNever;
+    /** `[Standard]` Creates a Not type. The first argument is the disallowed type, the second is the allowed. */
+    Not<N extends TSchema, T extends TSchema>(not: N, schema: T, options?: SchemaOptions): TNot<N, T>;
+    /** `[Standard]` Creates a Null type */
+    Null(options?: SchemaOptions): TNull;
+    /** `[Standard]` Creates a Number type */
+    Number(options?: NumericOptions<number>): TNumber;
+    /** `[Standard]` Creates an Object type */
+    Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
+    /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
+    Omit<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TOmit<T, K[number]>;
+    /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
+    Omit<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TOmit<T, TUnionOfLiteral<K>>;
+    /** `[Standard]` Creates a mapped type where all properties are Optional */
+    Partial<T extends TSchema>(schema: T, options?: ObjectOptions): TPartial<T>;
+    /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
+    Pick<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TPick<T, K[number]>;
+    /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
+    Pick<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TPick<T, TUnionOfLiteral<K>>;
+    /** `[Standard]` Creates an Object type from the given Literal Union */
+    Record<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TObject<TRecordPropertiesFromUnionLiteral<K, T>>;
+    /** `[Standard]` Creates an Object type from the given Literal Union */
+    Record<K extends TLiteral<string | number>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TObject<TRecordPropertiesFromLiteral<K, T>>;
+    /** `[Standard]` Creates a Record type */
+    Record<K extends TString | TNumeric, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TRecord<K, T>;
+    /** `[Standard]` Creates a Recursive type */
+    Recursive<T extends TSchema>(callback: (self: TSelf) => T, options?: SchemaOptions): TRecursive<T>;
+    /** `[Standard]` Creates a Ref type. The referenced type must contain a $id */
+    Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>;
+    /** `[Standard]` Creates a mapped type where all properties are Required */
+    Required<T extends TSchema>(schema: T, options?: SchemaOptions): TRequired<T>;
+    /** `[Standard]` Creates a String type */
+    String<Format extends string>(options?: StringOptions<StringFormatOption | Format>): TString<Format>;
+    /** `[Standard]` Creates a Tuple type */
+    Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T>;
+    /** `[Standard]` Creates a Union type */
+    Union(anyOf: [], options?: SchemaOptions): TNever;
+    /** `[Standard]` Creates a Union type */
+    Union<T extends [TSchema]>(anyOf: [...T], options?: SchemaOptions): T[0];
+    /** `[Standard]` Creates a Union type */
+    Union<T extends TSchema[]>(anyOf: [...T], options?: SchemaOptions): TUnion<T>;
+    /** `[Standard]` Creates an Unknown type */
+    Unknown(options?: SchemaOptions): TUnknown;
+    /** `[Standard]` Creates a Unsafe type that infers for the generic argument */
+    Unsafe<T>(options?: UnsafeOptions): TUnsafe<T>;
+}
+export declare class ExtendedTypeBuilder extends StandardTypeBuilder {
+    /** `[Extended]` Creates a BigInt type */
+    BigInt(options?: NumericOptions<bigint>): TBigInt;
+    /** `[Extended]` Extracts the ConstructorParameters from the given Constructor type */
+    ConstructorParameters<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TConstructorParameters<T>;
+    /** `[Extended]` Creates a Constructor type */
+    Constructor<T extends TTuple<TSchema[]>, U extends TSchema>(parameters: T, returns: U, options?: SchemaOptions): TConstructor<TTupleIntoArray<T>, U>;
+    /** `[Extended]` Creates a Constructor type */
+    Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U>;
+    /** `[Extended]` Creates a Date type */
+    Date(options?: DateOptions): TDate;
+    /** `[Extended]` Creates a Function type */
+    Function<T extends TTuple<TSchema[]>, U extends TSchema>(parameters: T, returns: U, options?: SchemaOptions): TFunction<TTupleIntoArray<T>, U>;
+    /** `[Extended]` Creates a Function type */
+    Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U>;
+    /** `[Extended]` Extracts the InstanceType from the given Constructor */
+    InstanceType<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TInstanceType<T>;
+    /** `[Extended]` Extracts the Parameters from the given Function type */
+    Parameters<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TParameters<T>;
+    /** `[Extended]` Creates a Promise type */
+    Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T>;
+    /** `[Extended]` Creates a regular expression type */
+    RegEx(regex: RegExp, options?: SchemaOptions): TString;
+    /** `[Extended]` Extracts the ReturnType from the given Function */
+    ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T>;
+    /** `[Extended]` Creates a Symbol type */
+    Symbol(options?: SchemaOptions): TSymbol;
+    /** `[Extended]` Creates a Undefined type */
+    Undefined(options?: SchemaOptions): TUndefined;
+    /** `[Extended]` Creates a Uint8Array type */
+    Uint8Array(options?: Uint8ArrayOptions): TUint8Array;
+    /** `[Extended]` Creates a Void type */
+    Void(options?: SchemaOptions): TVoid;
+}
+/** JSON Schema TypeBuilder with Static Resolution for TypeScript */
+export declare const StandardType: StandardTypeBuilder;
+/** JSON Schema TypeBuilder with Static Resolution for TypeScript */
+export declare const Type: ExtendedTypeBuilder;