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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.30.0-dev-3",
+  "version": "0.30.0-dev-5",
   "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.2 kb' │ ' 58.2 kb' │  '2.20 x'   │
-│ typebox/errors       │ '110.4 kb' │ ' 49.5 kb' │  '2.23 x'   │
-│ typebox/system       │ ' 75.2 kb' │ ' 31.1 kb' │  '2.42 x'   │
-│ typebox/value        │ '179.6 kb' │ ' 78.7 kb' │  '2.28 x'   │
-│ typebox              │ ' 74.1 kb' │ ' 30.6 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

@@ -104,6 +104,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;
@@ -276,11 +278,11 @@ 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>>;
@@ -292,13 +294,13 @@ export type TPartialProperties<T extends TProperties> = Evaluate<AssertPropertie
     [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 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']>>;
@@ -601,7 +603,7 @@ export declare namespace TypeExtends {
 /** Specialized Clone for Types */
 export declare namespace TypeClone {
     /** Clones a type. */
-    function Clone<T extends TSchema>(schema: T, options: SchemaOptions): T;
+    function Clone<T extends TSchema>(schema: T, options?: SchemaOptions): T;
 }
 export declare namespace IndexedAccessor {
     function Resolve(schema: TSchema, keys: Key[], options?: SchemaOptions): TSchema;
@@ -685,6 +687,8 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     Array<T extends TSchema>(items: T, options?: ArrayOptions): TArray<T>;
     /** `[Standard]` Creates a Boolean type */
     Boolean(options?: SchemaOptions): TBoolean;
+    /** `[Standard]` Maps a literal strings first character to uppercase */
+    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 */
@@ -720,6 +724,8 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     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 */
+    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 */
@@ -780,6 +786,8 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     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 */
+    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 */
@@ -792,10 +800,14 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     Unknown(options?: SchemaOptions): TUnknown;
     /** `[Standard]` Creates a Unsafe type that infers for the generic argument */
     Unsafe<T>(options?: UnsafeOptions): TUnsafe<T>;
+    /** `[Standard]` Maps a literal string to uppercase */
+    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. */
+    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 */

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 */
@@ -1369,7 +1369,7 @@ var TypeClone;
         return value;
     }
     /** Clones a type. */
-    function Clone(schema, options) {
+    function Clone(schema, options = {}) {
         return { ...Visit(schema), ...options };
     }
     TypeClone.Clone = Clone;
@@ -1381,7 +1381,7 @@ var IndexedAccessor;
 (function (IndexedAccessor) {
     function OptionalUnwrap(schema) {
         return schema.map((schema) => {
-            const { [exports.Optional]: _, ...clone } = TypeClone.Clone(schema, {});
+            const { [exports.Optional]: _, ...clone } = TypeClone.Clone(schema);
             return clone;
         });
     }
@@ -1477,7 +1477,7 @@ var ObjectMap;
         return schema;
     }
     function Map(schema, callback, options) {
-        return { ...Visit(TypeClone.Clone(schema, {}), callback), ...options };
+        return { ...Visit(TypeClone.Clone(schema), callback), ...options };
     }
     ObjectMap.Map = Map;
 })(ObjectMap || (exports.ObjectMap = ObjectMap = {}));
@@ -1931,11 +1931,11 @@ class StandardTypeBuilder extends TypeBuilder {
     }
     /** `[Standard]` Creates a Readonly property */
     Readonly(schema) {
-        return { ...TypeClone.Clone(schema, {}), [exports.Readonly]: 'Readonly' };
+        return { ...TypeClone.Clone(schema), [exports.Readonly]: 'Readonly' };
     }
     /** `[Standard]` Creates an Optional property */
     Optional(schema) {
-        return { ...TypeClone.Clone(schema, {}), [exports.Optional]: 'Optional' };
+        return { ...TypeClone.Clone(schema), [exports.Optional]: 'Optional' };
     }
     // ------------------------------------------------------------------------
     // Types
@@ -1946,12 +1946,17 @@ class StandardTypeBuilder extends TypeBuilder {
     }
     /** `[Standard]` Creates an Array type */
     Array(items, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Array', type: 'array', items: TypeClone.Clone(items, {}) });
+        return this.Create({ ...options, [exports.Kind]: 'Array', type: 'array', items: TypeClone.Clone(items) });
     }
     /** `[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 */
+    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, {});
@@ -2012,12 +2017,12 @@ class StandardTypeBuilder extends TypeBuilder {
         }
         else if (TypeGuard.TTuple(schema) && TypeGuard.TNumber(unresolved)) {
             const items = ValueGuard.IsUndefined(schema.items) ? [] : schema.items;
-            const cloned = items.map((schema) => TypeClone.Clone(schema, {}));
+            const cloned = items.map((schema) => TypeClone.Clone(schema));
             return this.Union(cloned, options);
         }
         else {
             const keys = KeyArrayResolver.Resolve(unresolved);
-            const clone = TypeClone.Clone(schema, {});
+            const clone = TypeClone.Clone(schema);
             return IndexedAccessor.Resolve(clone, keys, options);
         }
     }
@@ -2031,8 +2036,8 @@ class StandardTypeBuilder extends TypeBuilder {
         if (allOf.length === 1)
             return TypeClone.Clone(allOf[0], options);
         const objects = allOf.every((schema) => TypeGuard.TObject(schema));
-        const cloned = allOf.map((schema) => TypeClone.Clone(schema, {}));
-        const clonedUnevaluatedProperties = TypeGuard.TSchema(options.unevaluatedProperties) ? { unevaluatedProperties: TypeClone.Clone(options.unevaluatedProperties, {}) } : {};
+        const cloned = allOf.map((schema) => TypeClone.Clone(schema));
+        const clonedUnevaluatedProperties = TypeGuard.TSchema(options.unevaluatedProperties) ? { unevaluatedProperties: TypeClone.Clone(options.unevaluatedProperties) } : {};
         if (options.unevaluatedProperties === false || TypeGuard.TSchema(options.unevaluatedProperties) || objects) {
             return this.Create({ ...options, ...clonedUnevaluatedProperties, [exports.Kind]: 'Intersect', type: 'object', allOf: cloned });
         }
@@ -2070,6 +2075,10 @@ 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 */
+    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: {} });
@@ -2091,8 +2100,8 @@ class StandardTypeBuilder extends TypeBuilder {
         const propertyKeys = Object.getOwnPropertyNames(properties);
         const optionalKeys = propertyKeys.filter((key) => TypeGuard.TOptional(properties[key]));
         const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name));
-        const clonedAdditionalProperties = TypeGuard.TSchema(options.additionalProperties) ? { additionalProperties: TypeClone.Clone(options.additionalProperties, {}) } : {};
-        const clonedProperties = propertyKeys.reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(properties[key], {}) }), {});
+        const clonedAdditionalProperties = TypeGuard.TSchema(options.additionalProperties) ? { additionalProperties: TypeClone.Clone(options.additionalProperties) } : {};
+        const clonedProperties = propertyKeys.reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(properties[key]) }), {});
         if (requiredKeys.length > 0) {
             return this.Create({ ...options, ...clonedAdditionalProperties, [exports.Kind]: 'Object', type: 'object', properties: clonedProperties, required: requiredKeys });
         }
@@ -2103,17 +2112,17 @@ class StandardTypeBuilder extends TypeBuilder {
     Omit(schema, unresolved, options = {}) {
         const keys = KeyArrayResolver.Resolve(unresolved);
         // prettier-ignore
-        return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema) => {
-            if (schema.required) {
-                schema.required = schema.required.filter((key) => !keys.includes(key));
-                if (schema.required.length === 0)
-                    delete schema.required;
+        return ObjectMap.Map(TypeClone.Clone(schema), (object) => {
+            if (ValueGuard.IsArray(object.required)) {
+                object.required = object.required.filter((key) => !keys.includes(key));
+                if (object.required.length === 0)
+                    delete object.required;
             }
-            for (const key of Object.getOwnPropertyNames(schema.properties)) {
+            for (const key of Object.getOwnPropertyNames(object.properties)) {
                 if (keys.includes(key))
-                    delete schema.properties[key];
+                    delete object.properties[key];
             }
-            return this.Create(schema);
+            return this.Create(object);
         }, options);
     }
     /** `[Standard]` Creates a mapped type where all properties are Optional */
@@ -2129,17 +2138,17 @@ class StandardTypeBuilder extends TypeBuilder {
     Pick(schema, unresolved, options = {}) {
         const keys = KeyArrayResolver.Resolve(unresolved);
         // prettier-ignore
-        return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema) => {
-            if (schema.required) {
-                schema.required = schema.required.filter((key) => keys.includes(key));
-                if (schema.required.length === 0)
-                    delete schema.required;
+        return ObjectMap.Map(TypeClone.Clone(schema), (object) => {
+            if (ValueGuard.IsArray(object.required)) {
+                object.required = object.required.filter((key) => keys.includes(key));
+                if (object.required.length === 0)
+                    delete object.required;
             }
-            for (const key of Object.getOwnPropertyNames(schema.properties)) {
+            for (const key of Object.getOwnPropertyNames(object.properties)) {
                 if (!keys.includes(key))
-                    delete schema.properties[key];
+                    delete object.properties[key];
             }
-            return this.Create(schema);
+            return this.Create(object);
         }, options);
     }
     /** `[Standard]` Creates a Record type */
@@ -2148,13 +2157,13 @@ class StandardTypeBuilder extends TypeBuilder {
             const expression = TemplateLiteralParser.ParseExact(key.pattern);
             // prettier-ignore
             return TemplateLiteralFinite.Check(expression)
-                ? (this.Object([...TemplateLiteralGenerator.Generate(expression)].reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(schema, {}) }), {}), options))
-                : this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [key.pattern]: TypeClone.Clone(schema, {}) } });
+                ? (this.Object([...TemplateLiteralGenerator.Generate(expression)].reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(schema) }), {}), options))
+                : this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [key.pattern]: TypeClone.Clone(schema) } });
         }
         else if (TypeGuard.TUnion(key)) {
             const union = UnionResolver.Resolve(key);
             if (TypeGuard.TUnionLiteral(union)) {
-                const properties = union.anyOf.reduce((acc, literal) => ({ ...acc, [literal.const]: TypeClone.Clone(schema, {}) }), {});
+                const properties = union.anyOf.reduce((acc, literal) => ({ ...acc, [literal.const]: TypeClone.Clone(schema) }), {});
                 return this.Object(properties, { ...options, [exports.Hint]: 'Record' });
             }
             else
@@ -2162,17 +2171,17 @@ class StandardTypeBuilder extends TypeBuilder {
         }
         else if (TypeGuard.TLiteral(key)) {
             if (ValueGuard.IsString(key.const) || ValueGuard.IsNumber(key.const)) {
-                return this.Object({ [key.const]: TypeClone.Clone(schema, {}) }, options);
+                return this.Object({ [key.const]: TypeClone.Clone(schema) }, options);
             }
             else
                 throw Error('StandardTypeBuilder: Record key of type literal is not of type string or number');
         }
         else if (TypeGuard.TInteger(key) || TypeGuard.TNumber(key)) {
-            return this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [exports.PatternNumberExact]: TypeClone.Clone(schema, {}) } });
+            return this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [exports.PatternNumberExact]: TypeClone.Clone(schema) } });
         }
         else if (TypeGuard.TString(key)) {
             const pattern = ValueGuard.IsUndefined(key.pattern) ? exports.PatternStringExact : key.pattern;
-            return this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema, {}) } });
+            return this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema) } });
         }
         else {
             throw Error(`StandardTypeBuilder: Record key is an invalid type`);
@@ -2209,10 +2218,10 @@ class StandardTypeBuilder extends TypeBuilder {
         if (TypeGuard.TTuple(schema)) {
             if (ValueGuard.IsUndefined(schema.items))
                 return [];
-            return schema.items.map((schema) => TypeClone.Clone(schema, {}));
+            return schema.items.map((schema) => TypeClone.Clone(schema));
         }
         else {
-            return [TypeClone.Clone(schema, {})];
+            return [TypeClone.Clone(schema)];
         }
     }
     /** `[Standard]` Creates a String type */
@@ -2230,13 +2239,18 @@ class StandardTypeBuilder extends TypeBuilder {
     /** `[Standard]` Creates a Tuple type */
     Tuple(items, options = {}) {
         const [additionalItems, minItems, maxItems] = [false, items.length, items.length];
-        const clonedItems = items.map((item) => TypeClone.Clone(item, {}));
+        const clonedItems = items.map((item) => TypeClone.Clone(item));
         // prettier-ignore
         const schema = (items.length > 0 ?
             { ...options, [exports.Kind]: 'Tuple', type: 'array', items: clonedItems, additionalItems, minItems, maxItems } :
             { ...options, [exports.Kind]: 'Tuple', type: 'array', minItems, maxItems });
         return this.Create(schema);
     }
+    /** `[Standard]` Maps a literal strings first character to lowercase */
+    Uncapitalize(schema, options = {}) {
+        const [first, rest] = [schema.const.slice(0, 1), schema.const.slice(1)];
+        return exports.Type.Literal(`${first.toLocaleLowerCase()}${rest}`, options);
+    }
     Union(union, options = {}) {
         if (TypeGuard.TTemplateLiteral(union)) {
             return TemplateLiteralResolver.Resolve(union);
@@ -2247,7 +2261,7 @@ class StandardTypeBuilder extends TypeBuilder {
                 return this.Never(options);
             if (anyOf.length === 1)
                 return this.Create(TypeClone.Clone(anyOf[0], options));
-            const clonedAnyOf = anyOf.map((schema) => TypeClone.Clone(schema, {}));
+            const clonedAnyOf = anyOf.map((schema) => TypeClone.Clone(schema));
             return this.Create({ ...options, [exports.Kind]: 'Union', anyOf: clonedAnyOf });
         }
     }
@@ -2259,6 +2273,10 @@ class StandardTypeBuilder extends TypeBuilder {
     Unsafe(options = {}) {
         return this.Create({ ...options, [exports.Kind]: options[exports.Kind] || 'Unsafe' });
     }
+    /** `[Standard]` Maps a literal string to uppercase */
+    Uppercase(schema, options = {}) {
+        return exports.Type.Literal(schema.const.toUpperCase(), options);
+    }
 }
 exports.StandardTypeBuilder = StandardTypeBuilder;
 // --------------------------------------------------------------------------
@@ -2267,7 +2285,21 @@ exports.StandardTypeBuilder = StandardTypeBuilder;
 class ExtendedTypeBuilder extends StandardTypeBuilder {
     /** `[Extended]` Creates a AsyncIterator type */
     AsyncIterator(items, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'AsyncIterator', type: 'AsyncIterator', items: TypeClone.Clone(items, {}) });
+        return this.Create({ ...options, [exports.Kind]: 'AsyncIterator', type: 'AsyncIterator', items: TypeClone.Clone(items) });
+    }
+    /** `[Extended]` Recursively unwraps Promise from the given type. */
+    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 = {}) {
@@ -2279,8 +2311,8 @@ class ExtendedTypeBuilder extends StandardTypeBuilder {
     }
     /** `[Extended]` Creates a Constructor type */
     Constructor(parameters, returns, options) {
-        const clonedReturns = TypeClone.Clone(returns, {});
-        const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}));
+        const clonedReturns = TypeClone.Clone(returns);
+        const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter));
         return this.Create({ ...options, [exports.Kind]: 'Constructor', type: 'constructor', parameters: clonedParameters, returns: clonedReturns });
     }
     /** `[Extended]` Creates a Date type */
@@ -2290,7 +2322,7 @@ class ExtendedTypeBuilder extends StandardTypeBuilder {
     /** `[Extended]` Creates a Function type */
     Function(parameters, returns, options) {
         const clonedReturns = TypeClone.Clone(returns, {});
-        const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}));
+        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 */
@@ -2299,7 +2331,7 @@ class ExtendedTypeBuilder extends StandardTypeBuilder {
     }
     /** `[Extended]` Creates an Iterator type */
     Iterator(items, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Iterator', type: 'Iterator', items: TypeClone.Clone(items, {}) });
+        return this.Create({ ...options, [exports.Kind]: 'Iterator', type: 'Iterator', items: TypeClone.Clone(items) });
     }
     /** `[Extended]` Extracts the Parameters from the given Function type */
     Parameters(schema, options = {}) {
@@ -2307,7 +2339,7 @@ class ExtendedTypeBuilder extends StandardTypeBuilder {
     }
     /** `[Extended]` Creates a Promise type */
     Promise(item, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Promise', type: 'Promise', item: TypeClone.Clone(item, {}) });
+        return this.Create({ ...options, [exports.Kind]: 'Promise', type: 'Promise', item: TypeClone.Clone(item) });
     }
     /** `[Extended]` Creates a String pattern type from Regular Expression */
     RegExp(unresolved, 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. */