@sinclair/typebox 0.30.0-dev-5 → 0.30.0-dev-7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.30.0-dev-5",
+  "version": "0.30.0-dev-7",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/typebox.d.ts

@@ -43,7 +43,6 @@ export type IntersectType<T extends TSchema[]> = T extends [] ? TNever : T exten
 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;
 export interface SchemaOptions {
     $schema?: string;
     /** Id for this schema */
@@ -85,12 +84,18 @@ export interface TAny extends TSchema {
     static: any;
 }
 export interface ArrayOptions extends SchemaOptions {
+    /** The minimum number of items in this array */
     minItems?: number;
+    /** The maximum number of items in this array */
     maxItems?: number;
+    /** Should this schema contain unique items */
+    uniqueItems?: boolean;
+    /** A schema for which some elements should match */
     contains?: TSchema;
+    /** A minimum number of contains schema matches */
     minContains?: number;
+    /** A maximum number of contains schema matches */
     maxContains?: number;
-    uniqueItems?: boolean;
 }
 export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptions {
     [Kind]: 'Array';
@@ -135,9 +140,13 @@ export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema
     returns: U;
 }
 export interface DateOptions extends SchemaOptions {
+    /** The exclusive maximum timestamp value */
     exclusiveMaximumTimestamp?: number;
+    /** The exclusive minimum timestamp value */
     exclusiveMinimumTimestamp?: number;
+    /** The maximum timestamp value */
     maximumTimestamp?: number;
+    /** The minimum timestamp value */
     minimumTimestamp?: number;
 }
 export interface TDate extends TSchema, DateOptions {
@@ -181,14 +190,14 @@ export interface TFunction<T extends TSchema[] = TSchema[], U extends TSchema =
     parameters: T;
     returns: U;
 }
-export type TIndexRest<T extends TSchema[], K extends Key> = T extends [infer L, ...infer R] ? [TIndexType<AssertType<L>, K>, ...TIndexRest<AssertRest<R>, K>] : [];
-export type TIndexProperty<T extends TProperties, K extends Key> = K extends keyof T ? [T[K]] : [];
-export type TIndexTuple<T extends TSchema[], K extends Key> = K extends keyof T ? [T[K]] : [];
-export type TIndexType<T extends TSchema, K extends Key> = T extends TRecursive<infer S> ? TIndexType<S, K> : T extends TIntersect<infer S> ? IntersectType<AssertRest<Discard<Flat<TIndexRest<S, K>>, TNever>>> : T extends TUnion<infer S> ? UnionType<AssertRest<Flat<TIndexRest<S, K>>>> : T extends TObject<infer S> ? UnionType<AssertRest<Flat<TIndexProperty<S, K>>>> : T extends TTuple<infer S> ? UnionType<AssertRest<Flat<TIndexTuple<S, K>>>> : [
+export type TIndexRest<T extends TSchema[], K extends TPropertyKey> = T extends [infer L, ...infer R] ? [TIndexType<AssertType<L>, K>, ...TIndexRest<AssertRest<R>, K>] : [];
+export type TIndexProperty<T extends TProperties, K extends TPropertyKey> = K extends keyof T ? [T[K]] : [];
+export type TIndexTuple<T extends TSchema[], K extends TPropertyKey> = K extends keyof T ? [T[K]] : [];
+export type TIndexType<T extends TSchema, K extends TPropertyKey> = T extends TRecursive<infer S> ? TIndexType<S, K> : T extends TIntersect<infer S> ? IntersectType<AssertRest<Discard<Flat<TIndexRest<S, K>>, TNever>>> : T extends TUnion<infer S> ? UnionType<AssertRest<Flat<TIndexRest<S, K>>>> : T extends TObject<infer S> ? UnionType<AssertRest<Flat<TIndexProperty<S, K>>>> : T extends TTuple<infer S> ? UnionType<AssertRest<Flat<TIndexTuple<S, K>>>> : [
 ];
-export type TIndexRestMany<T extends TSchema, K extends Key[]> = K extends [infer L, ...infer R] ? [TIndexType<T, Assert<L, Key>>, ...TIndexRestMany<T, Assert<R, Key[]>>] : [
+export type TIndexRestMany<T extends TSchema, K extends TPropertyKey[]> = K extends [infer L, ...infer R] ? [TIndexType<T, Assert<L, TPropertyKey>>, ...TIndexRestMany<T, Assert<R, TPropertyKey[]>>] : [
 ];
-export type TIndex<T extends TSchema, K extends Key[]> = T extends TRecursive<infer S> ? TIndex<S, K> : T extends TIntersect ? UnionType<Flat<TIndexRestMany<T, K>>> : T extends TUnion ? UnionType<Flat<TIndexRestMany<T, K>>> : T extends TObject ? UnionType<Flat<TIndexRestMany<T, K>>> : T extends TTuple ? UnionType<Flat<TIndexRestMany<T, K>>> : TNever;
+export type TIndex<T extends TSchema, K extends TPropertyKey[]> = T extends TRecursive<infer S> ? TIndex<S, K> : T extends TIntersect ? UnionType<Flat<TIndexRestMany<T, K>>> : T extends TUnion ? UnionType<Flat<TIndexRestMany<T, K>>> : T extends TObject ? UnionType<Flat<TIndexRestMany<T, K>>> : T extends TTuple ? UnionType<Flat<TIndexRestMany<T, K>>> : TNever;
 export interface TInteger extends TSchema, NumericOptions<number> {
     [Kind]: 'Integer';
     static: number;
@@ -261,7 +270,8 @@ export type PropertiesReducer<T extends TProperties, R extends Record<keyof any,
 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 TPropertyKey = string | number;
+export type TProperties = Record<TPropertyKey, 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;
@@ -287,13 +297,13 @@ export type TParameters<T extends TFunction> = Ensure<TTuple<T['parameters']>>;
 export type TPartialObjectArray<T extends TObject[]> = AssertRest<{
     [K in keyof T]: TPartial<AssertType<T[K], TObject>>;
 }, TObject[]>;
-export type TPartialArray<T extends TSchema[]> = AssertRest<{
+export type TPartialRest<T extends TSchema[]> = AssertRest<{
     [K in keyof T]: TPartial<AssertType<T[K]>>;
 }>;
 export type TPartialProperties<T extends TProperties> = Evaluate<AssertProperties<{
     [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 TPartial<T extends TSchema> = T extends TRecursive<infer S> ? TRecursive<TPartial<S>> : T extends TIntersect<infer S> ? TIntersect<TPartialRest<S>> : T extends TUnion<infer S> ? TUnion<TPartialRest<S>> : T extends TObject<infer S> ? TObject<TPartialProperties<S>> : T;
 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]: AssertType<R[K]> extends TSchema ? R[K] : never;
 }) : never;
@@ -346,21 +356,27 @@ export interface TRef<T extends TSchema = TSchema> extends TSchema {
 }
 export type TRest<T extends TSchema> = T extends TTuple<infer R> ? Assert<R, TSchema[]> : Assert<[T], TSchema[]>;
 export type TReturnType<T extends TFunction> = T['returns'];
-export type TRequiredArray<T extends TSchema[]> = AssertRest<{
+export type TRequiredRest<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 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 TRequired<T extends TSchema> = T extends TRecursive<infer S> ? TRecursive<TRequired<S>> : T extends TIntersect<infer S> ? TIntersect<TRequiredRest<S>> : T extends TUnion<infer S> ? TUnion<TRequiredRest<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);
 export type StringContentEncodingOption = '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64' | ({} & string);
 export interface StringOptions extends SchemaOptions {
-    minLength?: number;
+    /** The maximum string length */
     maxLength?: number;
+    /** The minimum string length */
+    minLength?: number;
+    /** A regular expression pattern this string should match */
     pattern?: string;
+    /** A format this string should match */
     format?: StringFormatOption;
+    /** The content encoding for this string */
     contentEncoding?: StringContentEncodingOption;
+    /** The content media type for this string */
     contentMediaType?: string;
 }
 export interface TString extends TSchema, StringOptions {
@@ -389,14 +405,13 @@ export type TTemplateLiteralConst<T, Acc extends string> = T extends TUnion<infe
     [K in keyof U]: TTemplateLiteralUnion<Assert<[U[K]], TTemplateLiteralKind[]>, Acc>;
 }[number] : T extends TTemplateLiteral ? `${Static<T>}` : T extends TLiteral<infer U> ? `${U}` : T extends TString ? `${string}` : T extends TNumber ? `${number}` : T extends TBigInt ? `${bigint}` : T extends TBoolean ? `${boolean}` : never;
 export type TTemplateLiteralUnion<T extends TTemplateLiteralKind[], Acc extends string = ''> = T extends [infer L, ...infer R] ? `${TTemplateLiteralConst<L, Acc>}${TTemplateLiteralUnion<Assert<R, TTemplateLiteralKind[]>, Acc>}` : Acc;
-export type TTemplateLiteralKeyRest<T extends TTemplateLiteral> = Assert<UnionToTuple<Static<T>>, Key[]>;
+export type TTemplateLiteralKeyRest<T extends TTemplateLiteral> = Assert<UnionToTuple<Static<T>>, TPropertyKey[]>;
 export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLiteralKind[]> extends TSchema {
     [Kind]: 'TemplateLiteral';
     static: TTemplateLiteralUnion<T>;
     type: 'string';
     pattern: string;
 }
-export type TTupleIntoArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? AssertRest<R> : never;
 export type TTupleInfer<T extends TSchema[], P extends unknown[]> = T extends [infer L, ...infer R] ? [Static<AssertType<L>, P>, ...TTupleInfer<AssertRest<R>, P>] : [];
 export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
     [Kind]: 'Tuple';
@@ -606,7 +621,7 @@ export declare namespace TypeClone {
     function Clone<T extends TSchema>(schema: T, options?: SchemaOptions): T;
 }
 export declare namespace IndexedAccessor {
-    function Resolve(schema: TSchema, keys: Key[], options?: SchemaOptions): TSchema;
+    function Resolve(schema: TSchema, keys: TPropertyKey[], options?: SchemaOptions): TSchema;
 }
 export declare namespace ObjectMap {
     function Map<T = TSchema>(schema: TSchema, callback: (object: TObject) => TObject, options: SchemaOptions): T;
@@ -684,79 +699,80 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     /** `[Standard]` Creates an Any type */
     Any(options?: SchemaOptions): TAny;
     /** `[Standard]` Creates an Array type */
-    Array<T extends TSchema>(items: T, options?: ArrayOptions): TArray<T>;
+    Array<T extends TSchema>(schema: T, options?: ArrayOptions): TArray<T>;
     /** `[Standard]` Creates a Boolean type */
     Boolean(options?: SchemaOptions): TBoolean;
-    /** `[Standard]` Maps a literal strings first character to uppercase */
+    /** `[Standard]` Capitalize a LiteralString type */
     Capitalize<T extends TLiteral<string>>(schema: T, options?: SchemaOptions): TLiteral<Capitalize<T['const']>>;
-    /** `[Standard]` Creates a Composite object type. */
+    /** `[Standard]` Creates a Composite object type */
     Composite<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TComposite<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 */
+    /** `[Standard]` Creates a Conditional type */
     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 the left type 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]` Returns indexed property types for the given keys */
+    /** `[Standard]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+    Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>;
+    /** `[Standard]` Constructs a type by extracting from type all union members that are assignable to union */
+    Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
+    /** `[Standard]` Returns an Indexed property type for the given keys */
     Index<T extends TTuple, K extends TNumber>(schema: T, keys: K, options?: SchemaOptions): UnionType<Assert<T['items'], TSchema[]>>;
-    /** `[Standard]` Returns indexed property types for the given keys */
+    /** `[Standard]` Returns an Indexed property type for the given keys */
     Index<T extends TArray, K extends TNumber>(schema: T, keys: K, options?: SchemaOptions): AssertType<T['items']>;
-    /** `[Standard]` Returns indexed property types for the given keys */
+    /** `[Standard]` Returns an Indexed property type for the given keys */
     Index<T extends TSchema, K extends TTemplateLiteral>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TTemplateLiteralKeyRest<K>>;
-    /** `[Standard]` Returns indexed property types for the given keys */
-    Index<T extends TSchema, K extends TLiteral<Key>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, [K['const']]>;
-    /** `[Standard]` Returns indexed property types for the given keys */
-    Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndex<T, Assert<K, Key[]>>;
-    /** `[Standard]` Returns indexed property types for the given keys */
-    Index<T extends TSchema, K extends TUnion<TLiteral<Key>[]>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TUnionLiteralKeyRest<K>>;
-    /** `[Standard]` Returns indexed property types for the given keys */
+    /** `[Standard]` Returns an Indexed property type for the given keys */
+    Index<T extends TSchema, K extends TLiteral<TPropertyKey>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, [K['const']]>;
+    /** `[Standard]` Returns an Indexed property type for the given keys */
+    Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndex<T, Assert<K, TPropertyKey[]>>;
+    /** `[Standard]` Returns an Indexed property type for the given keys */
+    Index<T extends TSchema, K extends TUnion<TLiteral<TPropertyKey>[]>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TUnionLiteralKeyRest<K>>;
+    /** `[Standard]` Returns an Indexed property type for the given keys */
     Index<T extends TSchema, K extends TSchema>(schema: T, key: K, options?: SchemaOptions): TSchema;
     /** `[Standard]` Creates an Integer type */
     Integer(options?: NumericOptions<number>): TInteger;
-    /** `[Standard]` Creates a Intersect type */
+    /** `[Standard]` Creates an Intersect type */
     Intersect(allOf: [], options?: SchemaOptions): TNever;
-    /** `[Standard]` Creates a Intersect type */
+    /** `[Standard]` Creates an Intersect type */
     Intersect<T extends [TSchema]>(allOf: [...T], options?: SchemaOptions): T[0];
+    /** `[Standard]` Creates an Intersect type */
     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]` Maps a literal string to lowercase */
+    /** `[Standard]` Lowercase a LiteralString type */
     Lowercase<T extends TLiteral<string>>(schema: T, options?: SchemaOptions): TLiteral<Lowercase<T['const']>>;
     /** `[Standard]` Creates a Never type */
     Never(options?: SchemaOptions): TNever;
     /** `[Standard]` Creates a Not type */
-    Not<T extends TSchema>(not: T, options?: SchemaOptions): TNot<T>;
+    Not<T extends TSchema>(schema: T, options?: SchemaOptions): TNot<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 */
+    /** `[Standard]` Constructs a 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 */
+    /** `[Standard]` Constructs a 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, TUnionLiteralKeyRest<K>[number]>;
-    /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
+    /** `[Standard]` Constructs a type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TOmit<T, K['const']>;
-    /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
+    /** `[Standard]` Constructs a type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TOmit<T, TTemplateLiteralKeyRest<K>[number]>;
-    /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
+    /** `[Standard]` Constructs a type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TOmit<T, never>;
-    /** `[Standard]` Creates a mapped type where all properties are Optional */
+    /** `[Standard]` Constructs a 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 */
+    /** `[Standard]` Constructs a 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 */
+    /** `[Standard]` Constructs a 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, TUnionLiteralKeyRest<K>[number]>;
-    /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
+    /** `[Standard]` Constructs a type whose keys are picked from the given type */
     Pick<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TPick<T, K['const']>;
-    /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
+    /** `[Standard]` Constructs a type whose keys are picked from the given type */
     Pick<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TPick<T, TTemplateLiteralKeyRest<K>[number]>;
-    /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
+    /** `[Standard]` Constructs a type whose keys are picked from the given type */
     Pick<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TPick<T, never>;
     /** `[Standard]` Creates a Record type */
     Record<K extends TUnion, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordUnionLiteralType<K, T>;
@@ -774,19 +790,19 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     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 */
+    /** `[Standard]` Constructs a 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 */
+    /** `[Standard]` Extracts the rest array from a Tuple */
     Rest<T extends TSchema>(schema: T): TRest<T>;
     /** `[Standard]` Creates a String type */
     String(options?: StringOptions): TString;
-    /** `[Standard]` Creates a template literal type from template dsl string */
+    /** `[Standard]` Creates a TemplateLiteral type from template dsl string */
     TemplateLiteral<T extends string>(templateDsl: T, options?: SchemaOptions): TTemplateLiteralDslParser<T>;
-    /** `[Standard]` Creates a template literal type */
+    /** `[Standard]` Creates a TemplateLiteral type */
     TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
     /** `[Standard]` Creates a Tuple type */
     Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T>;
-    /** `[Standard]` Maps a literal strings first character to lowercase */
+    /** `[Standard]` Uncapitalize a LiteralString type */
     Uncapitalize<T extends TLiteral<string>>(schema: T, options?: SchemaOptions): TLiteral<Uncapitalize<T['const']>>;
     /** `[Standard]` Creates a Union type */
     Union(anyOf: [], options?: SchemaOptions): TNever;
@@ -794,19 +810,19 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     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>;
-    /** `[Experimental]` Remaps a TemplateLiteral into a Union representation. This function is known to cause TS compiler crashes for finite templates with large generation counts. Use with caution. */
+    /** `[Experimental]` Converts a TemplateLiteral into a Union */
     Union<T extends TTemplateLiteral>(template: T): TUnionTemplateLiteral<T>;
     /** `[Standard]` Creates an Unknown type */
     Unknown(options?: SchemaOptions): TUnknown;
-    /** `[Standard]` Creates a Unsafe type that infers for the generic argument */
+    /** `[Standard]` Creates a Unsafe type that will infers as the generic argument T */
     Unsafe<T>(options?: UnsafeOptions): TUnsafe<T>;
-    /** `[Standard]` Maps a literal string to uppercase */
+    /** `[Standard]` Uppercase a LiteralString type */
     Uppercase<T extends TLiteral<string>>(schema: T, options?: SchemaOptions): TLiteral<Uppercase<T['const']>>;
 }
 export declare class ExtendedTypeBuilder extends StandardTypeBuilder {
     /** `[Extended]` Creates a AsyncIterator type */
     AsyncIterator<T extends TSchema>(items: T, options?: SchemaOptions): TAsyncIterator<T>;
-    /** `[Extended]` Recursively unwraps Promise from the given type. */
+    /** `[Extended]` Constructs a type by recursively unwrapping Promise types */
     Awaited<T extends TSchema>(schema: T, options?: SchemaOptions): TAwaited<T>;
     /** `[Extended]` Creates a BigInt type */
     BigInt(options?: NumericOptions<bigint>): TBigInt;
@@ -818,7 +834,7 @@ export declare class ExtendedTypeBuilder extends StandardTypeBuilder {
     Date(options?: DateOptions): TDate;
     /** `[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 */
+    /** `[Extended]` Extracts the InstanceType from the given Constructor type */
     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>;
@@ -826,15 +842,15 @@ export declare class ExtendedTypeBuilder extends StandardTypeBuilder {
     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 String pattern type from Regular Expression */
+    /** `[Extended]` Creates a String type from a Regular Expression pattern */
     RegExp(pattern: string, options?: SchemaOptions): TString;
-    /** `[Extended]` Creates a String pattern type from Regular Expression */
+    /** `[Extended]` Creates a String type from a 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 */
+    /** `[Extended]` Extracts the ReturnType from the given Function type */
     ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T>;
     /** `[Extended]` Creates a Symbol type */
     Symbol(options?: SchemaOptions): TSymbol;

package/typebox.js

@@ -1945,19 +1945,19 @@ class StandardTypeBuilder extends TypeBuilder {
         return this.Create({ ...options, [exports.Kind]: 'Any' });
     }
     /** `[Standard]` Creates an Array type */
-    Array(items, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Array', type: 'array', items: TypeClone.Clone(items) });
+    Array(schema, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Array', type: 'array', items: TypeClone.Clone(schema) });
     }
     /** `[Standard]` Creates a Boolean type */
     Boolean(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Boolean', type: 'boolean' });
     }
-    /** `[Standard]` Maps a literal strings first character to uppercase */
+    /** `[Standard]` Capitalize a LiteralString type */
     Capitalize(schema, options = {}) {
         const [first, rest] = [schema.const.slice(0, 1), schema.const.slice(1)];
         return exports.Type.Literal(`${first.toUpperCase()}${rest}`, options);
     }
-    /** `[Standard]` Creates a Composite object type. */
+    /** `[Standard]` Creates a Composite object type */
     Composite(objects, options) {
         const intersect = exports.Type.Intersect(objects, {});
         const keys = KeyResolver.ResolveKeys(intersect, { includePatterns: false });
@@ -1971,7 +1971,7 @@ class StandardTypeBuilder extends TypeBuilder {
         const anyOf = values.map((value) => (ValueGuard.IsString(value) ? { [exports.Kind]: 'Literal', type: 'string', const: value } : { [exports.Kind]: 'Literal', type: 'number', const: value }));
         return this.Create({ ...options, [exports.Kind]: 'Union', anyOf });
     }
-    /** `[Standard]` A conditional type expression that will return the true type if the left type extends the right */
+    /** `[Standard]` Creates a Conditional type */
     Extends(left, right, trueType, falseType, options = {}) {
         switch (TypeExtends.Extends(left, right)) {
             case TypeExtendsResult.Union:
@@ -1982,35 +1982,35 @@ class StandardTypeBuilder extends TypeBuilder {
                 return TypeClone.Clone(falseType, options);
         }
     }
-    /** `[Standard]` Excludes from the left type any type that is not assignable to the right */
-    Exclude(left, right, options = {}) {
-        if (TypeGuard.TTemplateLiteral(left))
-            return this.Exclude(TemplateLiteralResolver.Resolve(left), right, options);
-        if (TypeGuard.TTemplateLiteral(right))
-            return this.Exclude(left, TemplateLiteralResolver.Resolve(right), options);
-        if (TypeGuard.TUnion(left)) {
-            const narrowed = left.anyOf.filter((inner) => TypeExtends.Extends(inner, right) === TypeExtendsResult.False);
+    /** `[Standard]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+    Exclude(unionType, excludedMembers, options = {}) {
+        if (TypeGuard.TTemplateLiteral(unionType))
+            return this.Exclude(TemplateLiteralResolver.Resolve(unionType), excludedMembers, options);
+        if (TypeGuard.TTemplateLiteral(excludedMembers))
+            return this.Exclude(unionType, TemplateLiteralResolver.Resolve(excludedMembers), options);
+        if (TypeGuard.TUnion(unionType)) {
+            const narrowed = unionType.anyOf.filter((inner) => TypeExtends.Extends(inner, excludedMembers) === TypeExtendsResult.False);
             return (narrowed.length === 1 ? TypeClone.Clone(narrowed[0], options) : this.Union(narrowed, options));
         }
         else {
-            return (TypeExtends.Extends(left, right) !== TypeExtendsResult.False ? this.Never(options) : TypeClone.Clone(left, options));
+            return (TypeExtends.Extends(unionType, excludedMembers) !== TypeExtendsResult.False ? this.Never(options) : TypeClone.Clone(unionType, options));
         }
     }
-    /** `[Standard]` Extracts from the left type any type that is assignable to the right */
-    Extract(left, right, options = {}) {
-        if (TypeGuard.TTemplateLiteral(left))
-            return this.Extract(TemplateLiteralResolver.Resolve(left), right, options);
-        if (TypeGuard.TTemplateLiteral(right))
-            return this.Extract(left, TemplateLiteralResolver.Resolve(right), options);
-        if (TypeGuard.TUnion(left)) {
-            const narrowed = left.anyOf.filter((inner) => TypeExtends.Extends(inner, right) !== TypeExtendsResult.False);
+    /** `[Standard]` Constructs a type by extracting from type all union members that are assignable to union */
+    Extract(type, union, options = {}) {
+        if (TypeGuard.TTemplateLiteral(type))
+            return this.Extract(TemplateLiteralResolver.Resolve(type), union, options);
+        if (TypeGuard.TTemplateLiteral(union))
+            return this.Extract(type, TemplateLiteralResolver.Resolve(union), options);
+        if (TypeGuard.TUnion(type)) {
+            const narrowed = type.anyOf.filter((inner) => TypeExtends.Extends(inner, union) !== TypeExtendsResult.False);
             return (narrowed.length === 1 ? TypeClone.Clone(narrowed[0], options) : this.Union(narrowed, options));
         }
         else {
-            return (TypeExtends.Extends(left, right) !== TypeExtendsResult.False ? TypeClone.Clone(left, options) : this.Never(options));
+            return (TypeExtends.Extends(type, union) !== TypeExtendsResult.False ? TypeClone.Clone(type, options) : this.Never(options));
         }
     }
-    /** `[Standard]` Returns indexed property types for the given keys */
+    /** `[Standard]` Returns an Indexed property type for the given keys */
     Index(schema, unresolved, options = {}) {
         if (TypeGuard.TArray(schema) && TypeGuard.TNumber(unresolved)) {
             return TypeClone.Clone(schema.items, options);
@@ -2030,6 +2030,7 @@ class StandardTypeBuilder extends TypeBuilder {
     Integer(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Integer', type: 'integer' });
     }
+    /** `[Standard]` Creates an Intersect type */
     Intersect(allOf, options = {}) {
         if (allOf.length === 0)
             return exports.Type.Never();
@@ -2075,7 +2076,7 @@ class StandardTypeBuilder extends TypeBuilder {
     Literal(value, options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Literal', const: value, type: typeof value });
     }
-    /** `[Standard]` Maps a literal string to lowercase */
+    /** `[Standard]` Lowercase a LiteralString type */
     Lowercase(schema, options = {}) {
         return exports.Type.Literal(schema.const.toLowerCase(), options);
     }
@@ -2084,8 +2085,8 @@ class StandardTypeBuilder extends TypeBuilder {
         return this.Create({ ...options, [exports.Kind]: 'Never', not: {} });
     }
     /** `[Standard]` Creates a Not type */
-    Not(not, options) {
-        return this.Create({ ...options, [exports.Kind]: 'Not', not });
+    Not(schema, options) {
+        return this.Create({ ...options, [exports.Kind]: 'Not', not: TypeClone.Clone(schema) });
     }
     /** `[Standard]` Creates a Null type */
     Null(options = {}) {
@@ -2109,6 +2110,7 @@ class StandardTypeBuilder extends TypeBuilder {
             return this.Create({ ...options, ...clonedAdditionalProperties, [exports.Kind]: 'Object', type: 'object', properties: clonedProperties });
         }
     }
+    /** `[Standard]` Constructs a type whose keys are omitted from the given type */
     Omit(schema, unresolved, options = {}) {
         const keys = KeyArrayResolver.Resolve(unresolved);
         // prettier-ignore
@@ -2125,7 +2127,7 @@ class StandardTypeBuilder extends TypeBuilder {
             return this.Create(object);
         }, options);
     }
-    /** `[Standard]` Creates a mapped type where all properties are Optional */
+    /** `[Standard]` Constructs a type where all properties are optional */
     Partial(schema, options = {}) {
         // prettier-ignore
         return ObjectMap.Map(schema, (object) => {
@@ -2135,6 +2137,7 @@ class StandardTypeBuilder extends TypeBuilder {
             return this.Object(properties, this.Discard(object, 'required') /* object used as options to retain other constraints */);
         }, options);
     }
+    /** `[Standard]` Constructs a type whose keys are picked from the given type */
     Pick(schema, unresolved, options = {}) {
         const keys = KeyArrayResolver.Resolve(unresolved);
         // prettier-ignore
@@ -2203,7 +2206,7 @@ class StandardTypeBuilder extends TypeBuilder {
             throw Error('StandardTypeBuilder.Ref: Target type must specify an $id');
         return this.Create({ ...options, [exports.Kind]: 'Ref', $ref: unresolved.$id });
     }
-    /** `[Standard]` Creates a mapped type where all properties are Required */
+    /** `[Standard]` Constructs a type where all properties are required */
     Required(schema, options = {}) {
         // prettier-ignore
         return ObjectMap.Map(schema, (object) => {
@@ -2213,7 +2216,7 @@ class StandardTypeBuilder extends TypeBuilder {
             return this.Object(properties, object /* object used as options to retain other constraints  */);
         }, options);
     }
-    /** `[Standard]` Returns a schema array which allows types to compose with the JavaScript spread operator */
+    /** `[Standard]` Extracts the rest array from a Tuple */
     Rest(schema) {
         if (TypeGuard.TTuple(schema)) {
             if (ValueGuard.IsUndefined(schema.items))
@@ -2228,7 +2231,7 @@ class StandardTypeBuilder extends TypeBuilder {
     String(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'String', type: 'string' });
     }
-    /** `[Standard]` Creates a template literal type */
+    /** `[Standard]` Creates a TemplateLiteral type */
     TemplateLiteral(unresolved, options = {}) {
         // prettier-ignore
         const pattern = (ValueGuard.IsString(unresolved))
@@ -2246,11 +2249,12 @@ class StandardTypeBuilder extends TypeBuilder {
             { ...options, [exports.Kind]: 'Tuple', type: 'array', minItems, maxItems });
         return this.Create(schema);
     }
-    /** `[Standard]` Maps a literal strings first character to lowercase */
+    /** `[Standard]` Uncapitalize a LiteralString type */
     Uncapitalize(schema, options = {}) {
         const [first, rest] = [schema.const.slice(0, 1), schema.const.slice(1)];
         return exports.Type.Literal(`${first.toLocaleLowerCase()}${rest}`, options);
     }
+    /** `[Standard]` Creates a Union type */
     Union(union, options = {}) {
         if (TypeGuard.TTemplateLiteral(union)) {
             return TemplateLiteralResolver.Resolve(union);
@@ -2269,11 +2273,11 @@ class StandardTypeBuilder extends TypeBuilder {
     Unknown(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Unknown' });
     }
-    /** `[Standard]` Creates a Unsafe type that infers for the generic argument */
+    /** `[Standard]` Creates a Unsafe type that will infers as the generic argument T */
     Unsafe(options = {}) {
         return this.Create({ ...options, [exports.Kind]: options[exports.Kind] || 'Unsafe' });
     }
-    /** `[Standard]` Maps a literal string to uppercase */
+    /** `[Standard]` Uppercase a LiteralString type */
     Uppercase(schema, options = {}) {
         return exports.Type.Literal(schema.const.toUpperCase(), options);
     }
@@ -2287,7 +2291,7 @@ class ExtendedTypeBuilder extends StandardTypeBuilder {
     AsyncIterator(items, options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'AsyncIterator', type: 'AsyncIterator', items: TypeClone.Clone(items) });
     }
-    /** `[Extended]` Recursively unwraps Promise from the given type. */
+    /** `[Extended]` Constructs a type by recursively unwrapping Promise types */
     Awaited(schema, options = {}) {
         const AwaitedRest = (rest) => {
             if (rest.length === 0)
@@ -2325,7 +2329,7 @@ class ExtendedTypeBuilder extends StandardTypeBuilder {
         const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter));
         return this.Create({ ...options, [exports.Kind]: 'Function', type: 'function', parameters: clonedParameters, returns: clonedReturns });
     }
-    /** `[Extended]` Extracts the InstanceType from the given Constructor */
+    /** `[Extended]` Extracts the InstanceType from the given Constructor type */
     InstanceType(schema, options = {}) {
         return TypeClone.Clone(schema.returns, options);
     }
@@ -2341,7 +2345,7 @@ class ExtendedTypeBuilder extends StandardTypeBuilder {
     Promise(item, options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Promise', type: 'Promise', item: TypeClone.Clone(item) });
     }
-    /** `[Extended]` Creates a String pattern type from Regular Expression */
+    /** `[Extended]` Creates a String type */
     RegExp(unresolved, options = {}) {
         const pattern = ValueGuard.IsString(unresolved) ? unresolved : unresolved.source;
         return this.Create({ ...options, [exports.Kind]: 'String', type: 'string', pattern });
@@ -2352,7 +2356,7 @@ class ExtendedTypeBuilder extends StandardTypeBuilder {
     RegEx(regex, options = {}) {
         return this.RegExp(regex, options);
     }
-    /** `[Extended]` Extracts the ReturnType from the given Function */
+    /** `[Extended]` Extracts the ReturnType from the given Function type */
     ReturnType(schema, options = {}) {
         return TypeClone.Clone(schema.returns, options);
     }