@sinclair/typebox 0.29.5 → 0.30.0-dev-1

package/typebox.d.ts

@@ -1,4 +1,5 @@
-export declare const Modifier: unique symbol;
+export declare const Readonly: unique symbol;
+export declare const Optional: unique symbol;
 export declare const Hint: unique symbol;
 export declare const Kind: unique symbol;
 export declare const PatternBoolean = "(true|false)";
@@ -25,22 +26,21 @@ export type Ensure<T> = T extends infer U ? U : never;
 export type AssertProperties<T> = T extends TProperties ? T : TProperties;
 export type AssertRest<T, E extends TSchema[] = TSchema[]> = T extends E ? T : [];
 export type AssertType<T, E extends TSchema = TSchema> = T extends E ? T : TNever;
-export type TModifier = TReadonlyOptional<TSchema> | TOptional<TSchema> | TReadonly<TSchema>;
+export type TModifier = TOptional<TSchema> | TReadonly<TSchema>;
 export type TReadonly<T extends TSchema> = T & {
-    [Modifier]: 'Readonly';
+    [Readonly]: 'Readonly';
 };
 export type TOptional<T extends TSchema> = T & {
-    [Modifier]: 'Optional';
+    [Optional]: 'Optional';
 };
-export type TReadonlyOptional<T extends TSchema> = T & {
-    [Modifier]: 'ReadonlyOptional';
-};
-export type OptionalUnwrapType<T extends TSchema> = T extends (TOptional<infer S> | TReadonlyOptional<infer S>) ? OptionalUnwrapType<S> : T;
-export type OptionalUnwrapRest<T extends TSchema[]> = T extends [infer L, ...infer R] ? L extends (TOptional<infer S> | TReadonlyOptional<infer S>) ? [OptionalUnwrapType<AssertType<S>>, ...OptionalUnwrapRest<AssertRest<R>>] : [L, ...OptionalUnwrapRest<AssertRest<R>>] : [];
-export type IntersectOptional<T extends TSchema[]> = T extends [infer L, ...infer R] ? L extends TOptional<AssertType<L>> | TReadonlyOptional<AssertType<L>> ? IntersectOptional<AssertRest<R>> : false : true;
+export type ReadonlyUnwrapType<T extends TSchema> = T extends TReadonly<infer S> ? ReadonlyUnwrapType<S> : T extends TOptional<infer S> ? TOptional<ReadonlyUnwrapType<S>> : T;
+export type ReadonlyUnwrapRest<T extends TSchema[]> = T extends [infer L, ...infer R] ? L extends TReadonly<infer S> ? [ReadonlyUnwrapType<AssertType<S>>, ...ReadonlyUnwrapRest<AssertRest<R>>] : [L, ...ReadonlyUnwrapRest<AssertRest<R>>] : [];
+export type OptionalUnwrapType<T extends TSchema> = T extends TReadonly<infer S> ? TReadonly<OptionalUnwrapType<S>> : T extends TOptional<infer S> ? OptionalUnwrapType<S> : T;
+export type OptionalUnwrapRest<T extends TSchema[]> = T extends [infer L, ...infer R] ? L extends TOptional<infer S> ? [OptionalUnwrapType<AssertType<S>>, ...OptionalUnwrapRest<AssertRest<R>>] : [L, ...OptionalUnwrapRest<AssertRest<R>>] : [];
+export type IntersectOptional<T extends TSchema[]> = T extends [infer L, ...infer R] ? L extends TOptional<AssertType<L>> ? IntersectOptional<AssertRest<R>> : false : true;
 export type IntersectResolve<T extends TSchema[], U = OptionalUnwrapRest<AssertRest<T>>> = IntersectOptional<AssertRest<T>> extends true ? TOptional<TIntersect<AssertRest<U>>> : TIntersect<AssertRest<U>>;
 export type IntersectType<T extends TSchema[]> = T extends [] ? TNever : T extends [TSchema] ? AssertType<T[0]> : IntersectResolve<T>;
-export type UnionOptional<T extends TSchema[]> = T extends [infer L, ...infer R] ? L extends (TOptional<AssertType<L>> | TReadonlyOptional<AssertType<L>>) ? true : UnionOptional<AssertRest<R>> : false;
+export type UnionOptional<T extends TSchema[]> = T extends [infer L, ...infer R] ? L extends (TOptional<AssertType<L>>) ? true : UnionOptional<AssertRest<R>> : false;
 export type UnionResolve<T extends TSchema[], U = OptionalUnwrapRest<AssertRest<T>>> = UnionOptional<AssertRest<T>> extends true ? TOptional<TUnion<AssertRest<U>>> : TUnion<AssertRest<U>>;
 export type UnionType<T extends TSchema[]> = T extends [] ? TNever : T extends [TSchema] ? AssertType<T[0]> : UnionResolve<T>;
 export type Key = string | number;
@@ -56,18 +56,23 @@ export interface SchemaOptions {
     default?: any;
     /** Example values matching this schema */
     examples?: any;
+    /** Optional annotation for readOnly */
+    readOnly?: boolean;
+    /** Optional annotation for writeOnly */
+    writeOnly?: boolean;
     [prop: string]: any;
 }
 export interface TKind {
     [Kind]: string;
 }
 export interface TSchema extends SchemaOptions, TKind {
-    [Modifier]?: string;
+    [Readonly]?: string;
+    [Optional]?: 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 | TString | TSymbol | TTemplateLiteral | TThis | TTuple | TUndefined | TUnion | TUint8Array | TUnknown | TVoid;
+export type TAnySchema = TSchema | TAny | TArray | TAsyncIterator | TBigInt | TBoolean | TConstructor | TDate | TEnum | TFunction | TInteger | TIntersect | TIterator | TLiteral | TNot | TNull | TNumber | TObject | TPromise | TRecord | TRef | TString | TSymbol | TTemplateLiteral | TThis | TTuple | TUndefined | TUnion | TUint8Array | TUnknown | TVoid;
 export interface NumericOptions<N extends number | bigint> extends SchemaOptions {
     exclusiveMaximum?: N;
     exclusiveMinimum?: N;
@@ -80,9 +85,12 @@ export interface TAny extends TSchema {
     static: any;
 }
 export interface ArrayOptions extends SchemaOptions {
-    uniqueItems?: boolean;
     minItems?: number;
     maxItems?: number;
+    contains?: TSchema;
+    minContains?: number;
+    maxContains?: number;
+    uniqueItems?: boolean;
 }
 export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptions {
     [Kind]: 'Array';
@@ -90,11 +98,16 @@ export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptio
     type: 'array';
     items: T;
 }
+export interface TAsyncIterator<T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'AsyncIterator';
+    static: AsyncIterableIterator<Static<T, this['params']>>;
+    type: 'AsyncIterator';
+    items: T;
+}
 export interface TBigInt extends TSchema, NumericOptions<bigint> {
     [Kind]: 'BigInt';
     static: bigint;
-    type: 'null';
-    typeOf: 'BigInt';
+    type: 'bigint';
 }
 export interface TBoolean extends TSchema {
     [Kind]: 'Boolean';
@@ -115,8 +128,7 @@ export type TConstructorParameterArray<T extends readonly TSchema[], P extends u
 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';
+    type: 'constructor';
     parameters: T;
     returns: U;
 }
@@ -129,8 +141,7 @@ export interface DateOptions extends SchemaOptions {
 export interface TDate extends TSchema, DateOptions {
     [Kind]: 'Date';
     static: Date;
-    type: 'object';
-    instanceOf: 'Date';
+    type: 'date';
 }
 export interface TEnumOption<T> {
     type: 'number' | 'string';
@@ -158,14 +169,13 @@ export type TExtractArray<T extends TSchema[], U extends TSchema> = AssertRest<U
     [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? T[K] : never;
 }[number]>> extends infer R ? UnionType<AssertRest<R>> : never;
 export type TExtract<T extends TSchema, U extends TSchema> = T extends TTemplateLiteral ? TExtractTemplateLiteral<T, U> : T extends TUnion<infer S> ? TExtractArray<S, U> : T extends U ? T : T;
-export type TFunctionParameters<T extends readonly TSchema[], P extends unknown[]> = [...{
+export type TFunctionParameters<T extends TSchema[], P extends unknown[]> = [...{
     [K in keyof T]: Static<AssertType<T[K]>, P>;
 }];
-export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
+export interface TFunction<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Function';
     static: (...param: TFunctionParameters<T, this['params']>) => Static<U, this['params']>;
-    type: 'object';
-    instanceOf: 'Function';
+    type: 'function';
     parameters: T;
     returns: U;
 }
@@ -194,6 +204,12 @@ export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, In
     type?: 'object';
     allOf: [...T];
 }
+export interface TIterator<T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Iterator';
+    static: IterableIterator<Static<T, this['params']>>;
+    type: 'Iterator';
+    items: T;
+}
 export type TKeyOfProperties<T extends TSchema> = Discard<Static<T> extends infer S ? UnionToTuple<{
     [K in keyof S]: TLiteral<Assert<K, TLiteralValue>>;
 }[keyof S]> : [], undefined>;
@@ -230,13 +246,13 @@ export interface TNumber extends TSchema, NumericOptions<number> {
     type: 'number';
 }
 export type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TReadonlyOptional<TSchema> ? K : never;
+    [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? K : never) : never;
 }[keyof T];
 export type ReadonlyPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TReadonly<TSchema> ? K : never;
+    [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? never : K) : never;
 }[keyof T];
 export type OptionalPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TOptional<TSchema> ? K : never;
+    [K in keyof T]: T[K] extends TOptional<TSchema> ? (T[K] extends TReadonly<T[K]> ? never : 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>>>)>;
@@ -273,7 +289,7 @@ export type TPartialArray<T extends TSchema[]> = AssertRest<{
     [K in keyof T]: TPartial<AssertType<T[K]>>;
 }>;
 export type TPartialProperties<T extends TProperties> = Evaluate<AssertProperties<{
-    [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]>;
+    [K in keyof T]: TOptional<T[K]>;
 }>>;
 export type TPartial<T extends TSchema> = T extends TRecursive<infer S> ? TRecursive<TPartial<S>> : 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> = {
@@ -286,8 +302,7 @@ export type TPick<T extends TSchema = TSchema, K extends keyof any = keyof any>
 export interface TPromise<T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Promise';
     static: Promise<Static<T, this['params']>>;
-    type: 'object';
-    instanceOf: 'Promise';
+    type: 'promise';
     item: TSchema;
 }
 export type RecordTemplateLiteralObjectType<K extends TTemplateLiteral, T extends TSchema> = Ensure<TObject<Evaluate<{
@@ -333,7 +348,7 @@ export type TRequiredArray<T extends TSchema[]> = AssertRest<{
     [K in keyof T]: TRequired<AssertType<T[K]>>;
 }>;
 export type TRequiredProperties<T extends TProperties> = Evaluate<AssertProperties<{
-    [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];
+    [K in keyof T]: T[K] extends TOptional<infer S> ? S : T[K];
 }>>;
 export type TRequired<T extends TSchema> = T extends TRecursive<infer S> ? TRecursive<TRequired<S>> : 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' | ({} & string);
@@ -355,8 +370,7 @@ export type SymbolValue = string | number | undefined;
 export interface TSymbol extends TSchema, SchemaOptions {
     [Kind]: 'Symbol';
     static: symbol;
-    type: 'null';
-    typeOf: 'Symbol';
+    type: 'symbol';
 }
 export type TTemplateLiteralDslParserUnionLiteral<T extends string> = T extends `${infer L}|${infer R}` ? [TLiteral<Trim<L>>, ...TTemplateLiteralDslParserUnionLiteral<R>] : T extends `${infer L}` ? [TLiteral<Trim<L>>] : [
 ];
@@ -394,8 +408,7 @@ export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
 export interface TUndefined extends TSchema {
     [Kind]: 'Undefined';
     static: undefined;
-    type: 'null';
-    typeOf: 'Undefined';
+    type: 'undefined';
 }
 export type TLiteralUnionReduce<T extends TLiteral<string | number>[]> = T extends [infer L, ...infer R] ? [Assert<L, TLiteral<string | number>>['const'], ...TLiteralUnionReduce<Assert<R, TLiteral<string | number>[]>>] : [
 ];
@@ -418,8 +431,7 @@ export interface Uint8ArrayOptions extends SchemaOptions {
 export interface TUint8Array extends TSchema, Uint8ArrayOptions {
     [Kind]: 'Uint8Array';
     static: Uint8Array;
-    instanceOf: 'Uint8Array';
-    type: 'object';
+    type: 'uint8array';
 }
 export interface TUnknown extends TSchema {
     [Kind]: 'Unknown';
@@ -435,8 +447,7 @@ export interface TUnsafe<T> extends TSchema {
 export interface TVoid extends TSchema {
     [Kind]: 'Void';
     static: void;
-    type: 'null';
-    typeOf: 'Void';
+    type: 'void';
 }
 /** Infers a static type from a TypeBox type */
 export type Static<T extends TSchema, P extends unknown[] = []> = (T & {
@@ -449,6 +460,8 @@ export declare namespace TypeRegistry {
     function Entries(): Map<string, TypeRegistryValidationFunction<any>>;
     /** Clears all user defined types */
     function Clear(): void;
+    /** Deletes a registered type */
+    function Delete(kind: string): boolean;
     /** Returns true if this registry contains this kind */
     function Has(kind: string): boolean;
     /** Sets a validation function for a user defined type */
@@ -463,6 +476,8 @@ export declare namespace FormatRegistry {
     function Entries(): Map<string, FormatRegistryValidationFunction>;
     /** Clears all user defined string formats */
     function Clear(): void;
+    /** Deletes a registered format */
+    function Delete(format: string): boolean;
     /** Returns true if the user defined string format exists */
     function Has(format: string): boolean;
     /** Sets a validation function for a user defined string format */
@@ -470,6 +485,16 @@ export declare namespace FormatRegistry {
     /** Gets a validation function for a user defined string format */
     function Get(format: string): FormatRegistryValidationFunction | undefined;
 }
+export declare namespace ValueGuard {
+    function IsObject(value: unknown): value is Record<PropertyKey, unknown>;
+    function IsArray(value: unknown): value is unknown[];
+    function IsBoolean(value: unknown): value is boolean;
+    function IsNull(value: unknown): value is null;
+    function IsUndefined(value: unknown): value is undefined;
+    function IsBigInt(value: unknown): value is bigint;
+    function IsNumber(value: unknown): value is number;
+    function IsString(value: unknown): value is string;
+}
 export declare class TypeGuardUnknownTypeError extends Error {
     readonly schema: unknown;
     constructor(schema: unknown);
@@ -480,6 +505,8 @@ export declare namespace TypeGuard {
     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 TAsyncIterator */
+    function TAsyncIterator(schema: unknown): schema is TAsyncIterator;
     /** Returns true if the given schema is TBigInt */
     function TBigInt(schema: unknown): schema is TBigInt;
     /** Returns true if the given schema is TBoolean */
@@ -494,8 +521,16 @@ export declare namespace TypeGuard {
     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 TIterator */
+    function TIterator(schema: unknown): schema is TIterator;
+    /** Returns true if the given schema is a TKind with the given name. */
+    function TKindOf<T extends string>(schema: unknown, kind: T): schema is Record<PropertyKey, unknown> & {
+        [Kind]: T;
+    };
     /** Returns true if the given schema is TKind */
-    function TKind(schema: unknown): schema is Record<typeof Kind | string, unknown>;
+    function TKind(schema: unknown): schema is Record<PropertyKey, unknown> & {
+        [Kind]: string;
+    };
     /** Returns true if the given schema is TLiteral<string> */
     function TLiteralString(schema: unknown): schema is TLiteral<string>;
     /** Returns true if the given schema is TLiteral<number> */
@@ -544,8 +579,6 @@ export declare namespace TypeGuard {
     function TUnsafe(schema: unknown): schema is TUnsafe<unknown>;
     /** 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 */
@@ -634,16 +667,18 @@ export declare namespace TemplateLiteralDslParser {
 export declare class TypeBuilder {
     /** `[Utility]` Creates a schema without `static` and `params` types */
     protected Create<T>(schema: Omit<T, 'static' | 'params'>): T;
+    /** `[Utility]` Discards a property key from the given schema */
+    protected Discard(schema: TSchema, key: PropertyKey): TSchema;
     /** `[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 */
+    /** `[Standard]` Creates a Readonly and Optional property */
+    ReadonlyOptional<T extends TSchema>(schema: T): TReadonly<TOptional<T>>;
+    /** `[Standard]` Creates a Readonly property */
     Readonly<T extends TSchema>(schema: T): TReadonly<T>;
+    /** `[Standard]` Creates an Optional property */
+    Optional<T extends TSchema>(schema: T): TOptional<T>;
     /** `[Standard]` Creates an Any type */
     Any(options?: SchemaOptions): TAny;
     /** `[Standard]` Creates an Array type */
@@ -731,14 +766,16 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     Recursive<T extends TSchema>(callback: (thisType: TThis) => 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 Ref type. */
+    Ref<T extends TSchema>($ref: string, 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]` Returns a schema array which allows types to compose with the JavaScript spread operator */
     Rest<T extends TSchema>(schema: T): TRest<T>;
     /** `[Standard]` Creates a String type */
     String(options?: StringOptions): TString;
-    /** `[Experimental]` Creates a template literal type from dsl string */
-    TemplateLiteral<T extends string>(dsl: T, options?: SchemaOptions): TTemplateLiteralDslParser<T>;
+    /** `[Standard]` Creates a template literal type from template dsl string */
+    TemplateLiteral<T extends string>(templateDsl: T, options?: SchemaOptions): TTemplateLiteralDslParser<T>;
     /** `[Standard]` Creates a template literal type */
     TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
     /** `[Standard]` Creates a Tuple type */
@@ -757,6 +794,8 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     Unsafe<T>(options?: UnsafeOptions): TUnsafe<T>;
 }
 export declare class ExtendedTypeBuilder extends StandardTypeBuilder {
+    /** `[Extended]` Creates a AsyncIterator type */
+    AsyncIterator<T extends TSchema>(items: T, options?: SchemaOptions): TAsyncIterator<T>;
     /** `[Extended]` Creates a BigInt type */
     BigInt(options?: NumericOptions<bigint>): TBigInt;
     /** `[Extended]` Extracts the ConstructorParameters from the given Constructor type */
@@ -769,11 +808,19 @@ export declare class ExtendedTypeBuilder extends StandardTypeBuilder {
     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]` Creates an Iterator type */
+    Iterator<T extends TSchema>(items: T, options?: SchemaOptions): TIterator<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 */
+    /** `[Extended]` Creates a String pattern type from Regular Expression */
+    RegExp(pattern: string, options?: SchemaOptions): TString;
+    /** `[Extended]` Creates a String pattern type from Regular Expression */
+    RegExp(regex: RegExp, options?: SchemaOptions): TString;
+    /**
+     * @deprecated Use `Type.RegExp`
+     */
     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>;
@@ -786,7 +833,7 @@ export declare class ExtendedTypeBuilder extends StandardTypeBuilder {
     /** `[Extended]` Creates a Void type */
     Void(options?: SchemaOptions): TVoid;
 }
-/** JSON Schema TypeBuilder with Static Resolution for TypeScript */
+/** JSON Schema Type Builder with Static Resolution for TypeScript */
 export declare const StandardType: StandardTypeBuilder;
-/** JSON Schema TypeBuilder with Static Resolution for TypeScript */
+/** JSON Schema Type Builder with Static Resolution for TypeScript */
 export declare const Type: ExtendedTypeBuilder;