@sinclair/typebox 0.30.0-dev-4 → 0.30.0-dev-6

package/package.json

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

package/readme.md

@@ -63,7 +63,7 @@ type T = Static<typeof T>                            // type T = {
 
 ## Overview
 
-TypeBox is a runtime type builder that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type assertion rules of the TypeScript compiler. TypeBox enables one to create a unified type that can be statically checked by TypeScript and runtime asserted using standard JSON Schema validation.
+TypeBox is a runtime type builder that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type assertion rules of the TypeScript language. TypeBox allows one to create a unified type that can be statically checked by TypeScript and runtime asserted using standard JSON Schema validation.
 
 This library is designed to enable JSON schema to compose with the same flexibility as TypeScript's type system. It can be used as a simple tool to build up complex schemas or integrated into REST or RPC services to help validate data received over the wire.
 
@@ -72,6 +72,7 @@ License MIT
 ## Contents
 - [Install](#install)
 - [Overview](#overview)
+- [Features](#features)
 - [Usage](#usage)
 - [Types](#types)
   - [Standard](#types-standard)
@@ -102,7 +103,6 @@ License MIT
   - [Errors](#values-errors)
   - [Mutate](#values-mutate)
   - [Pointer](#values-pointer)
-  - [Transform](#values-transform)
 - [TypeCheck](#typecheck)
   - [Ajv](#typecheck-ajv)
   - [TypeCompiler](#typecheck-typecompiler)
@@ -110,7 +110,7 @@ License MIT
   - [Types](#typesystem-types)
   - [Formats](#typesystem-formats)
   - [Policies](#typesystem-policies)
-- [Workbench](#workbench)
+- [Transform](#Transform)
 - [Ecosystem](#ecosystem)
 - [Benchmark](#benchmark)
   - [Compile](#benchmark-compile)
@@ -1457,13 +1457,13 @@ TypeSystem.AllowArrayObjects = true
 TypeSystem.AllowNaN = true
 ```
 
-<a name='workbench'></a>
+<a name='transform'></a>
 
-## Workbench
+## TypeBox Transform
 
-TypeBox offers a web based code generation tool that can be used to convert TypeScript types into TypeBox types as well as a variety of other runtime type representations.
+TypeBox offers a small web based code generation tool that can be used to convert TypeScript types into TypeBox types as well as a variety of other runtime type representations.
 
-[Workbench Link Here](https://sinclairzx81.github.io/typebox-workbench/)
+[TypeBox Transform Link Here](https://sinclairzx81.github.io/typebox-transform/)
 
 <a name='ecosystem'></a>
 
@@ -1586,11 +1586,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '128.3 kb' │ ' 58.0 kb' │  '2.21 x'   │
-│ typebox/errors       │ '110.5 kb' │ ' 49.5 kb' │  '2.23 x'   │
-│ typebox/system       │ ' 75.4 kb' │ ' 31.2 kb' │  '2.42 x'   │
-│ typebox/value        │ '179.7 kb' │ ' 78.7 kb' │  '2.28 x'   │
-│ typebox              │ ' 74.3 kb' │ ' 30.7 kb' │  '2.42 x'   │
+│ typebox/compiler     │ '129.4 kb' │ ' 58.6 kb' │  '2.21 x'   │
+│ typebox/errors       │ '111.6 kb' │ ' 50.1 kb' │  '2.23 x'   │
+│ typebox/system       │ ' 76.5 kb' │ ' 31.7 kb' │  '2.41 x'   │
+│ typebox/value        │ '180.7 kb' │ ' 79.3 kb' │  '2.28 x'   │
+│ typebox              │ ' 75.4 kb' │ ' 31.3 kb' │  '2.41 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 

package/typebox.d.ts

@@ -85,12 +85,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';
@@ -104,6 +110,8 @@ export interface TAsyncIterator<T extends TSchema = TSchema> extends TSchema {
     type: 'AsyncIterator';
     items: T;
 }
+export type TAwaitedRest<T extends TSchema[]> = T extends [infer L, ...infer R] ? [TAwaited<AssertType<L>>, ...TAwaitedRest<AssertRest<R>>] : [];
+export type TAwaited<T extends TSchema> = T extends TIntersect<infer S> ? TIntersect<TAwaitedRest<S>> : T extends TUnion<infer S> ? TUnion<TAwaitedRest<S>> : T extends TPromise<infer S> ? TAwaited<S> : T;
 export interface TBigInt extends TSchema, NumericOptions<bigint> {
     [Kind]: 'BigInt';
     static: bigint;
@@ -133,9 +141,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 {
@@ -276,29 +288,29 @@ export interface TObject<T extends TProperties = TProperties> extends TSchema, O
     properties: T;
     required?: string[];
 }
-export type TOmitArray<T extends TSchema[], K extends keyof any> = AssertRest<{
+export type TOmitProperties<T extends TProperties, K extends keyof any> = Evaluate<AssertProperties<Omit<T, K>>>;
+export type TOmitRest<T extends TSchema[], K extends keyof any> = AssertRest<{
     [K2 in keyof T]: TOmit<AssertType<T[K2]>, K>;
 }>;
-export type TOmitProperties<T extends TProperties, K extends keyof any> = Evaluate<AssertProperties<Omit<T, K>>>;
-export type TOmit<T extends TSchema = TSchema, K extends keyof any = keyof any> = T extends TRecursive<infer S> ? TRecursive<TOmit<S, K>> : 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 TOmit<T extends TSchema = TSchema, K extends keyof any = keyof any> = T extends TRecursive<infer S> ? TRecursive<TOmit<S, K>> : T extends TIntersect<infer S> ? TIntersect<TOmitRest<S, K>> : T extends TUnion<infer S> ? TUnion<TOmitRest<S, K>> : T extends TObject<infer S> ? TObject<TOmitProperties<S, K>> : T;
 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 TPickArray<T extends TSchema[], K extends keyof any> = {
-    [K2 in keyof T]: TPick<AssertType<T[K2]>, K>;
-};
+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;
-export type TPick<T extends TSchema = TSchema, K extends keyof any = keyof any> = T extends TRecursive<infer S> ? TRecursive<TPick<S, K>> : 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 TPickRest<T extends TSchema[], K extends keyof any> = {
+    [K2 in keyof T]: TPick<AssertType<T[K2]>, K>;
+};
+export type TPick<T extends TSchema = TSchema, K extends keyof any = keyof any> = T extends TRecursive<infer S> ? TRecursive<TPick<S, K>> : T extends TIntersect<infer S> ? TIntersect<TPickRest<S, K>> : T extends TUnion<infer S> ? TUnion<TPickRest<S, K>> : T extends TObject<infer S> ? TObject<TPickProperties<S, K>> : T;
 export interface TPromise<T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Promise';
     static: Promise<Static<T, this['params']>>;
@@ -344,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 {
@@ -394,7 +412,6 @@ export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLi
     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';
@@ -682,75 +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]` Creates a Composite object type. */
+    /** `[Standard]` Capitalize a LiteralString type */
+    Capitalize<T extends TLiteral<string>>(schema: T, options?: SchemaOptions): TLiteral<Capitalize<T['const']>>;
+    /** `[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 */
+    /** `[Standard]` Returns an Indexed property type 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 */
+    /** `[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, Key[]>>;
-    /** `[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 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 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]` 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>;
@@ -768,34 +790,40 @@ 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]` 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;
     /** `[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>;
-    /** `[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]` 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]` 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;
     /** `[Extended]` Extracts the ConstructorParameters from the given Constructor type */
@@ -806,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>;
@@ -814,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

@@ -222,12 +222,12 @@ var TypeGuard;
             schema.type === 'array' &&
             IsOptionalString(schema.$id) &&
             TSchema(schema.items) &&
-            IsOptionalSchema(schema.contains) &&
-            IsOptionalNumber(schema.minContains) &&
-            IsOptionalNumber(schema.maxContains) &&
             IsOptionalNumber(schema.minItems) &&
             IsOptionalNumber(schema.maxItems) &&
-            IsOptionalBoolean(schema.uniqueItems));
+            IsOptionalBoolean(schema.uniqueItems) &&
+            IsOptionalSchema(schema.contains) &&
+            IsOptionalNumber(schema.minContains) &&
+            IsOptionalNumber(schema.maxContains));
     }
     TypeGuard.TArray = TArray;
     /** Returns true if the given schema is TAsyncIterator */
@@ -1945,14 +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]` Creates a Composite object type. */
+    /** `[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 */
     Composite(objects, options) {
         const intersect = exports.Type.Intersect(objects, {});
         const keys = KeyResolver.ResolveKeys(intersect, { includePatterns: false });
@@ -1966,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:
@@ -1977,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);
@@ -2025,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();
@@ -2070,13 +2076,17 @@ class StandardTypeBuilder extends TypeBuilder {
     Literal(value, options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Literal', const: value, type: typeof value });
     }
+    /** `[Standard]` Lowercase a LiteralString type */
+    Lowercase(schema, options = {}) {
+        return exports.Type.Literal(schema.const.toLowerCase(), options);
+    }
     /** `[Standard]` Creates a Never type */
     Never(options = {}) {
         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 = {}) {
@@ -2100,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
@@ -2116,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) => {
@@ -2126,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
@@ -2194,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) => {
@@ -2204,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))
@@ -2219,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))
@@ -2237,6 +2249,12 @@ class StandardTypeBuilder extends TypeBuilder {
             { ...options, [exports.Kind]: 'Tuple', type: 'array', minItems, maxItems });
         return this.Create(schema);
     }
+    /** `[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);
@@ -2255,10 +2273,14 @@ 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]` Uppercase a LiteralString type */
+    Uppercase(schema, options = {}) {
+        return exports.Type.Literal(schema.const.toUpperCase(), options);
+    }
 }
 exports.StandardTypeBuilder = StandardTypeBuilder;
 // --------------------------------------------------------------------------
@@ -2269,6 +2291,20 @@ class ExtendedTypeBuilder extends StandardTypeBuilder {
     AsyncIterator(items, options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'AsyncIterator', type: 'AsyncIterator', items: TypeClone.Clone(items) });
     }
+    /** `[Extended]` Constructs a type by recursively unwrapping Promise types */
+    Awaited(schema, options = {}) {
+        const AwaitedRest = (rest) => {
+            if (rest.length === 0)
+                return rest;
+            const [L, ...R] = rest;
+            return [this.Awaited(L), ...AwaitedRest(R)];
+        };
+        // prettier-ignore
+        return (TypeGuard.TIntersect(schema) ? exports.Type.Intersect(AwaitedRest(schema.allOf)) :
+            TypeGuard.TUnion(schema) ? exports.Type.Union(AwaitedRest(schema.anyOf)) :
+                TypeGuard.TPromise(schema) ? this.Awaited(schema.item) :
+                    TypeClone.Clone(schema, options));
+    }
     /** `[Extended]` Creates a BigInt type */
     BigInt(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'BigInt', type: 'bigint' });
@@ -2293,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);
     }
@@ -2309,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 });
@@ -2320,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);
     }

package/value/convert.js

@@ -280,7 +280,7 @@ function TUnknown(schema, references, value) {
 function TVoid(schema, references, value) {
     return value;
 }
-function TUserDefined(schema, references, value) {
+function TKind(schema, references, value) {
     return value;
 }
 function Visit(schema, references, value) {
@@ -348,7 +348,7 @@ function Visit(schema, references, value) {
         default:
             if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
                 throw new ValueConvertUnknownTypeError(schema_);
-            return TUserDefined(schema_, references_, value);
+            return TKind(schema_, references_, value);
     }
 }
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible. */