@sinclair/typebox 0.32.0-dev-20 → 0.32.0-dev-21

package/build/require/errors/errors.js

@@ -133,8 +133,8 @@ function Create(type, schema, path, value) {
 // --------------------------------------------------------------------------
 // Types
 // --------------------------------------------------------------------------
-function* TAny(schema, references, path, value) { }
-function* TArray(schema, references, path, value) {
+function* FromAny(schema, references, path, value) { }
+function* FromArray(schema, references, path, value) {
     if (!(0, index_8.IsArray)(value)) {
         return yield Create(ValueErrorType.Array, schema, path, value);
     }
@@ -175,11 +175,11 @@ function* TArray(schema, references, path, value) {
         yield Create(ValueErrorType.ArrayMaxContains, schema, path, value);
     }
 }
-function* TAsyncIterator(schema, references, path, value) {
+function* FromAsyncIterator(schema, references, path, value) {
     if (!(0, index_8.IsAsyncIterator)(value))
         yield Create(ValueErrorType.AsyncIterator, schema, path, value);
 }
-function* TBigInt(schema, references, path, value) {
+function* FromBigInt(schema, references, path, value) {
     if (!(0, index_8.IsBigInt)(value))
         return yield Create(ValueErrorType.BigInt, schema, path, value);
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -198,14 +198,14 @@ function* TBigInt(schema, references, path, value) {
         yield Create(ValueErrorType.BigIntMultipleOf, schema, path, value);
     }
 }
-function* TBoolean(schema, references, path, value) {
+function* FromBoolean(schema, references, path, value) {
     if (!(0, index_8.IsBoolean)(value))
         yield Create(ValueErrorType.Boolean, schema, path, value);
 }
-function* TConstructor(schema, references, path, value) {
+function* FromConstructor(schema, references, path, value) {
     yield* Visit(schema.returns, references, path, value.prototype);
 }
-function* TDate(schema, references, path, value) {
+function* FromDate(schema, references, path, value) {
     if (!(0, index_8.IsDate)(value))
         return yield Create(ValueErrorType.Date, schema, path, value);
     if (IsDefined(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
@@ -224,11 +224,11 @@ function* TDate(schema, references, path, value) {
         yield Create(ValueErrorType.DateMultipleOfTimestamp, schema, path, value);
     }
 }
-function* TFunction(schema, references, path, value) {
+function* FromFunction(schema, references, path, value) {
     if (!(0, index_8.IsFunction)(value))
         yield Create(ValueErrorType.Function, schema, path, value);
 }
-function* TInteger(schema, references, path, value) {
+function* FromInteger(schema, references, path, value) {
     if (!(0, index_8.IsInteger)(value))
         return yield Create(ValueErrorType.Integer, schema, path, value);
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -247,7 +247,7 @@ function* TInteger(schema, references, path, value) {
         yield Create(ValueErrorType.IntegerMultipleOf, schema, path, value);
     }
 }
-function* TIntersect(schema, references, path, value) {
+function* FromIntersect(schema, references, path, value) {
     for (const inner of schema.allOf) {
         const next = Visit(inner, references, path, value).next();
         if (!next.done) {
@@ -274,26 +274,26 @@ function* TIntersect(schema, references, path, value) {
         }
     }
 }
-function* TIterator(schema, references, path, value) {
+function* FromIterator(schema, references, path, value) {
     if (!(0, index_8.IsIterator)(value))
         yield Create(ValueErrorType.Iterator, schema, path, value);
 }
-function* TLiteral(schema, references, path, value) {
+function* FromLiteral(schema, references, path, value) {
     if (!(value === schema.const))
         yield Create(ValueErrorType.Literal, schema, path, value);
 }
-function* TNever(schema, references, path, value) {
+function* FromNever(schema, references, path, value) {
     yield Create(ValueErrorType.Never, schema, path, value);
 }
-function* TNot(schema, references, path, value) {
+function* FromNot(schema, references, path, value) {
     if (Visit(schema.not, references, path, value).next().done === true)
         yield Create(ValueErrorType.Not, schema, path, value);
 }
-function* TNull(schema, references, path, value) {
+function* FromNull(schema, references, path, value) {
     if (!(0, index_8.IsNull)(value))
         yield Create(ValueErrorType.Null, schema, path, value);
 }
-function* TNumber(schema, references, path, value) {
+function* FromNumber(schema, references, path, value) {
     if (!index_1.TypeSystemPolicy.IsNumberLike(value))
         return yield Create(ValueErrorType.Number, schema, path, value);
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -312,7 +312,7 @@ function* TNumber(schema, references, path, value) {
         yield Create(ValueErrorType.NumberMultipleOf, schema, path, value);
     }
 }
-function* TObject(schema, references, path, value) {
+function* FromObject(schema, references, path, value) {
     if (!index_1.TypeSystemPolicy.IsObjectLike(value))
         return yield Create(ValueErrorType.Object, schema, path, value);
     if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
@@ -358,11 +358,11 @@ function* TObject(schema, references, path, value) {
         }
     }
 }
-function* TPromise(schema, references, path, value) {
+function* FromPromise(schema, references, path, value) {
     if (!(0, index_8.IsPromise)(value))
         yield Create(ValueErrorType.Promise, schema, path, value);
 }
-function* TRecord(schema, references, path, value) {
+function* FromRecord(schema, references, path, value) {
     if (!index_1.TypeSystemPolicy.IsRecordLike(value))
         return yield Create(ValueErrorType.Object, schema, path, value);
     if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
@@ -391,10 +391,10 @@ function* TRecord(schema, references, path, value) {
         }
     }
 }
-function* TRef(schema, references, path, value) {
+function* FromRef(schema, references, path, value) {
     yield* Visit((0, index_4.Deref)(schema, references), references, path, value);
 }
-function* TString(schema, references, path, value) {
+function* FromString(schema, references, path, value) {
     if (!(0, index_8.IsString)(value))
         return yield Create(ValueErrorType.String, schema, path, value);
     if (IsDefined(schema.minLength) && !(value.length >= schema.minLength)) {
@@ -421,11 +421,11 @@ function* TString(schema, references, path, value) {
         }
     }
 }
-function* TSymbol(schema, references, path, value) {
+function* FromSymbol(schema, references, path, value) {
     if (!(0, index_8.IsSymbol)(value))
         yield Create(ValueErrorType.Symbol, schema, path, value);
 }
-function* TTemplateLiteral(schema, references, path, value) {
+function* FromTemplateLiteral(schema, references, path, value) {
     if (!(0, index_8.IsString)(value))
         return yield Create(ValueErrorType.String, schema, path, value);
     const regex = new RegExp(schema.pattern);
@@ -433,10 +433,10 @@ function* TTemplateLiteral(schema, references, path, value) {
         yield Create(ValueErrorType.StringPattern, schema, path, value);
     }
 }
-function* TThis(schema, references, path, value) {
+function* FromThis(schema, references, path, value) {
     yield* Visit((0, index_4.Deref)(schema, references), references, path, value);
 }
-function* TTuple(schema, references, path, value) {
+function* FromTuple(schema, references, path, value) {
     if (!(0, index_8.IsArray)(value))
         return yield Create(ValueErrorType.Tuple, schema, path, value);
     if (schema.items === undefined && !(value.length === 0)) {
@@ -452,11 +452,11 @@ function* TTuple(schema, references, path, value) {
         yield* Visit(schema.items[i], references, `${path}/${i}`, value[i]);
     }
 }
-function* TUndefined(schema, references, path, value) {
+function* FromUndefined(schema, references, path, value) {
     if (!(0, index_8.IsUndefined)(value))
         yield Create(ValueErrorType.Undefined, schema, path, value);
 }
-function* TUnion(schema, references, path, value) {
+function* FromUnion(schema, references, path, value) {
     let count = 0;
     for (const subschema of schema.anyOf) {
         const errors = [...Visit(subschema, references, path, value)];
@@ -468,7 +468,7 @@ function* TUnion(schema, references, path, value) {
         yield Create(ValueErrorType.Union, schema, path, value);
     }
 }
-function* TUint8Array(schema, references, path, value) {
+function* FromUint8Array(schema, references, path, value) {
     if (!(0, index_8.IsUint8Array)(value))
         return yield Create(ValueErrorType.Uint8Array, schema, path, value);
     if (IsDefined(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
@@ -478,12 +478,12 @@ function* TUint8Array(schema, references, path, value) {
         yield Create(ValueErrorType.Uint8ArrayMinByteLength, schema, path, value);
     }
 }
-function* TUnknown(schema, references, path, value) { }
-function* TVoid(schema, references, path, value) {
+function* FromUnknown(schema, references, path, value) { }
+function* FromVoid(schema, references, path, value) {
     if (!index_1.TypeSystemPolicy.IsVoidLike(value))
         yield Create(ValueErrorType.Void, schema, path, value);
 }
-function* TKind(schema, references, path, value) {
+function* FromKind(schema, references, path, value) {
     const check = index_3.TypeRegistry.Get(schema[index_6.Kind]);
     if (!check(schema, value))
         yield Create(ValueErrorType.Kind, schema, path, value);
@@ -493,69 +493,69 @@ function* Visit(schema, references, path, value) {
     const schema_ = schema;
     switch (schema_[index_6.Kind]) {
         case 'Any':
-            return yield* TAny(schema_, references_, path, value);
+            return yield* FromAny(schema_, references_, path, value);
         case 'Array':
-            return yield* TArray(schema_, references_, path, value);
+            return yield* FromArray(schema_, references_, path, value);
         case 'AsyncIterator':
-            return yield* TAsyncIterator(schema_, references_, path, value);
+            return yield* FromAsyncIterator(schema_, references_, path, value);
         case 'BigInt':
-            return yield* TBigInt(schema_, references_, path, value);
+            return yield* FromBigInt(schema_, references_, path, value);
         case 'Boolean':
-            return yield* TBoolean(schema_, references_, path, value);
+            return yield* FromBoolean(schema_, references_, path, value);
         case 'Constructor':
-            return yield* TConstructor(schema_, references_, path, value);
+            return yield* FromConstructor(schema_, references_, path, value);
         case 'Date':
-            return yield* TDate(schema_, references_, path, value);
+            return yield* FromDate(schema_, references_, path, value);
         case 'Function':
-            return yield* TFunction(schema_, references_, path, value);
+            return yield* FromFunction(schema_, references_, path, value);
         case 'Integer':
-            return yield* TInteger(schema_, references_, path, value);
+            return yield* FromInteger(schema_, references_, path, value);
         case 'Intersect':
-            return yield* TIntersect(schema_, references_, path, value);
+            return yield* FromIntersect(schema_, references_, path, value);
         case 'Iterator':
-            return yield* TIterator(schema_, references_, path, value);
+            return yield* FromIterator(schema_, references_, path, value);
         case 'Literal':
-            return yield* TLiteral(schema_, references_, path, value);
+            return yield* FromLiteral(schema_, references_, path, value);
         case 'Never':
-            return yield* TNever(schema_, references_, path, value);
+            return yield* FromNever(schema_, references_, path, value);
         case 'Not':
-            return yield* TNot(schema_, references_, path, value);
+            return yield* FromNot(schema_, references_, path, value);
         case 'Null':
-            return yield* TNull(schema_, references_, path, value);
+            return yield* FromNull(schema_, references_, path, value);
         case 'Number':
-            return yield* TNumber(schema_, references_, path, value);
+            return yield* FromNumber(schema_, references_, path, value);
         case 'Object':
-            return yield* TObject(schema_, references_, path, value);
+            return yield* FromObject(schema_, references_, path, value);
         case 'Promise':
-            return yield* TPromise(schema_, references_, path, value);
+            return yield* FromPromise(schema_, references_, path, value);
         case 'Record':
-            return yield* TRecord(schema_, references_, path, value);
+            return yield* FromRecord(schema_, references_, path, value);
         case 'Ref':
-            return yield* TRef(schema_, references_, path, value);
+            return yield* FromRef(schema_, references_, path, value);
         case 'String':
-            return yield* TString(schema_, references_, path, value);
+            return yield* FromString(schema_, references_, path, value);
         case 'Symbol':
-            return yield* TSymbol(schema_, references_, path, value);
+            return yield* FromSymbol(schema_, references_, path, value);
         case 'TemplateLiteral':
-            return yield* TTemplateLiteral(schema_, references_, path, value);
+            return yield* FromTemplateLiteral(schema_, references_, path, value);
         case 'This':
-            return yield* TThis(schema_, references_, path, value);
+            return yield* FromThis(schema_, references_, path, value);
         case 'Tuple':
-            return yield* TTuple(schema_, references_, path, value);
+            return yield* FromTuple(schema_, references_, path, value);
         case 'Undefined':
-            return yield* TUndefined(schema_, references_, path, value);
+            return yield* FromUndefined(schema_, references_, path, value);
         case 'Union':
-            return yield* TUnion(schema_, references_, path, value);
+            return yield* FromUnion(schema_, references_, path, value);
         case 'Uint8Array':
-            return yield* TUint8Array(schema_, references_, path, value);
+            return yield* FromUint8Array(schema_, references_, path, value);
         case 'Unknown':
-            return yield* TUnknown(schema_, references_, path, value);
+            return yield* FromUnknown(schema_, references_, path, value);
         case 'Void':
-            return yield* TVoid(schema_, references_, path, value);
+            return yield* FromVoid(schema_, references_, path, value);
         default:
             if (!index_3.TypeRegistry.Has(schema_[index_6.Kind]))
                 throw new ValueErrorsUnknownTypeError(schema);
-            return yield* TKind(schema_, references_, path, value);
+            return yield* FromKind(schema_, references_, path, value);
     }
 }
 /** Returns an iterator for each error in this value. */

package/build/require/index.d.ts

@@ -7,7 +7,7 @@ export { Any, type TAny } from './type/any/index';
 export { Array, type TArray, type ArrayOptions } from './type/array/index';
 export { AsyncIterator, type TAsyncIterator } from './type/async-iterator/index';
 export { Awaited, type TAwaited } from './type/awaited/index';
-export { BigInt, type TBigInt, BigIntOptions } from './type/bigint/index';
+export { BigInt, type TBigInt, type BigIntOptions } from './type/bigint/index';
 export { Boolean, type TBoolean } from './type/boolean/index';
 export { Composite, type TComposite } from './type/composite/index';
 export { Const, type TConst } from './type/const/index';
@@ -54,9 +54,9 @@ export { type TSchema, type TKind, type SchemaOptions, type TAnySchema } from '.
 export { type Static, type StaticDecode, type StaticEncode } from './type/static/index';
 export { Strict } from './type/strict/index';
 export { String, type TString, type StringOptions, type StringFormatOption, type StringContentEncodingOption } from './type/string/index';
-export { Symbol, type TSymbol, type SymbolValue } from './type/symbol/index';
-export { TemplateLiteral, IsTemplateLiteralFinite, TemplateLiteralParse, TemplateLiteralParseExact, TemplateLiteralGenerate, type TTemplateLiteral, type TTemplateLiteralKind } from './type/template-literal/index';
-export { Transform, type TTransform, type TransformOptions, type TransformFunction, TransformDecodeBuilder, TransformEncodeBuilder } from './type/transform/index';
+export { Symbol, type TSymbol, type TSymbolValue as SymbolValue } from './type/symbol/index';
+export { TemplateLiteral, IsTemplateLiteralFinite, IsTemplateLiteralExpressionFinite, TemplateLiteralParse, TemplateLiteralParseExact, TemplateLiteralGenerate, TemplateLiteralExpressionGenerate, type TTemplateLiteral, type TIsTemplateLiteralFinite, type TTemplateLiteralGenerate, type TTemplateLiteralKind, } from './type/template-literal/index';
+export { Transform, TransformDecodeBuilder, TransformEncodeBuilder, type TTransform, type TransformOptions, type TransformFunction } from './type/transform/index';
 export { Tuple, type TTuple } from './type/tuple/index';
 export { Uint8Array, type TUint8Array, type Uint8ArrayOptions } from './type/uint8array/index';
 export { Undefined, type TUndefined } from './type/undefined/index';

package/build/require/index.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Lowercase = exports.Capitalize = exports.IntrinsicFromMappedKey = exports.Intrinsic = exports.Iterator = exports.IntersectEvaluated = exports.Intersect = exports.Integer = exports.InstanceType = exports.IndexFromMappedKey = exports.IndexPropertyKeys = exports.Index = exports.Increment = exports.Function = exports.Extract = exports.ExtendsUndefinedCheck = exports.ExtendsResult = exports.ExtendsCheck = exports.Extends = exports.Exclude = exports.Enum = exports.Deref = exports.Date = exports.ConstructorParameters = exports.Constructor = exports.Const = exports.Composite = exports.Boolean = exports.BigInt = exports.Awaited = exports.AsyncIterator = exports.Array = exports.Any = exports.CloneRest = exports.CloneType = exports.ValueGuard = exports.TypeGuard = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternString = exports.PatternNumberExact = exports.PatternNumber = exports.PatternBooleanExact = exports.PatternBoolean = exports.TransformKind = exports.OptionalKind = exports.ReadonlyKind = exports.Hint = exports.Kind = void 0;
-exports.Unsafe = exports.Unknown = exports.UnionEvaluated = exports.Union = exports.Undefined = exports.Uint8Array = exports.Tuple = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = exports.Transform = exports.TemplateLiteralGenerate = exports.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.IsTemplateLiteralFinite = exports.TemplateLiteral = exports.Symbol = exports.String = exports.Strict = exports.ReturnType = exports.Rest = exports.Required = exports.RegExp = exports.Ref = exports.Recursive = exports.Record = exports.ReadonlyOptional = exports.ReadonlyFromMappedResult = exports.Readonly = exports.Promise = exports.Pick = exports.PartialFromMappedResult = exports.Partial = exports.Parameters = exports.OptionalFromMappedResult = exports.Optional = exports.Omit = exports.Object = exports.Number = exports.Null = exports.Not = exports.Never = exports.MappedResult = exports.MappedKey = exports.Mapped = exports.Literal = exports.KeyOfPattern = exports.KeyOfPropertyKeys = exports.KeyOf = exports.Uppercase = exports.Uncapitalize = void 0;
-exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = exports.Type = exports.Void = void 0;
+exports.UnionEvaluated = exports.Union = exports.Undefined = exports.Uint8Array = exports.Tuple = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = exports.Transform = exports.TemplateLiteralExpressionGenerate = exports.TemplateLiteralGenerate = exports.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.IsTemplateLiteralExpressionFinite = exports.IsTemplateLiteralFinite = exports.TemplateLiteral = exports.Symbol = exports.String = exports.Strict = exports.ReturnType = exports.Rest = exports.Required = exports.RegExp = exports.Ref = exports.Recursive = exports.Record = exports.ReadonlyOptional = exports.ReadonlyFromMappedResult = exports.Readonly = exports.Promise = exports.Pick = exports.PartialFromMappedResult = exports.Partial = exports.Parameters = exports.OptionalFromMappedResult = exports.Optional = exports.Omit = exports.Object = exports.Number = exports.Null = exports.Not = exports.Never = exports.MappedResult = exports.MappedKey = exports.Mapped = exports.Literal = exports.KeyOfPattern = exports.KeyOfPropertyKeys = exports.KeyOf = exports.Uppercase = exports.Uncapitalize = void 0;
+exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = exports.Type = exports.Void = exports.Unsafe = exports.Unknown = void 0;
 // ------------------------------------------------------------------
 // Infrastructure
 // ------------------------------------------------------------------
@@ -153,9 +153,11 @@ Object.defineProperty(exports, "Symbol", { enumerable: true, get: function () {
 var index_55 = require("./type/template-literal/index");
 Object.defineProperty(exports, "TemplateLiteral", { enumerable: true, get: function () { return index_55.TemplateLiteral; } });
 Object.defineProperty(exports, "IsTemplateLiteralFinite", { enumerable: true, get: function () { return index_55.IsTemplateLiteralFinite; } });
+Object.defineProperty(exports, "IsTemplateLiteralExpressionFinite", { enumerable: true, get: function () { return index_55.IsTemplateLiteralExpressionFinite; } });
 Object.defineProperty(exports, "TemplateLiteralParse", { enumerable: true, get: function () { return index_55.TemplateLiteralParse; } });
 Object.defineProperty(exports, "TemplateLiteralParseExact", { enumerable: true, get: function () { return index_55.TemplateLiteralParseExact; } });
 Object.defineProperty(exports, "TemplateLiteralGenerate", { enumerable: true, get: function () { return index_55.TemplateLiteralGenerate; } });
+Object.defineProperty(exports, "TemplateLiteralExpressionGenerate", { enumerable: true, get: function () { return index_55.TemplateLiteralExpressionGenerate; } });
 var index_56 = require("./type/transform/index");
 Object.defineProperty(exports, "Transform", { enumerable: true, get: function () { return index_56.Transform; } });
 Object.defineProperty(exports, "TransformDecodeBuilder", { enumerable: true, get: function () { return index_56.TransformDecodeBuilder; } });

package/build/require/type/indexed/indexed-property-keys.d.ts

@@ -1,10 +1,10 @@
-import { type TTemplateLiteral, TemplateLiteralGenerate, IsTemplateLiteralFinite } from '../template-literal/index';
+import { type TTemplateLiteral, TTemplateLiteralGenerate } from '../template-literal/index';
 import { type TLiteral, type TLiteralValue } from '../literal/index';
 import { type TInteger } from '../integer/index';
 import { type TNumber } from '../number/index';
 import { type TSchema } from '../schema/index';
 import { type TUnion } from '../union/index';
-type FromTemplateLiteral<T extends TTemplateLiteral, F = IsTemplateLiteralFinite<T>> = (F extends true ? TemplateLiteralGenerate<T> extends infer R extends string[] ? R : [] : []);
+type FromTemplateLiteral<T extends TTemplateLiteral, R extends string[] = TTemplateLiteralGenerate<T>> = (R);
 declare function FromTemplateLiteral<T extends TTemplateLiteral>(T: T): FromTemplateLiteral<T>;
 type FromUnion<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [...TIndexPropertyKeys<L>, ...FromUnion<R>] : []);
 declare function FromUnion<T extends TSchema[]>(T: T): FromUnion<T>;

package/build/require/type/indexed/indexed-property-keys.js

@@ -10,14 +10,8 @@ const index_1 = require("../template-literal/index");
 const type_1 = require("../guard/type");
 // prettier-ignore
 function FromTemplateLiteral(T) {
-    const E = (0, index_1.TemplateLiteralParseExact)(T.pattern);
-    const F = (0, index_1.IsTemplateLiteralFinite)(E);
-    const S = (0, index_1.TemplateLiteralToUnion)(T);
-    return (F === true
-        ? (0, type_1.IsUnionLiteral)(S)
-            ? S.anyOf.map(S => S.const.toString())
-            : []
-        : []);
+    const R = (0, index_1.TemplateLiteralGenerate)(T);
+    return R.map(S => S.toString());
 }
 // prettier-ignore
 function FromUnion(T) {
@@ -28,7 +22,8 @@ function FromUnion(T) {
 }
 // prettier-ignore
 function FromLiteral(T) {
-    return ([T.toString()]);
+    return ([T.toString()] // TS 5.4 observes TLiteralValue as not having a toString()
+    );
 }
 /** Returns a tuple of PropertyKeys derived from the given TSchema */
 // prettier-ignore

package/build/require/type/intrinsic/intrinsic.js

@@ -32,10 +32,10 @@ function FromTemplateLiteral(schema, mode, options) {
     // note: template literals require special runtime handling as they are encoded in string patterns.
     // This diverges from the mapped type which would otherwise map on the template literal kind.
     const expression = (0, index_1.TemplateLiteralParseExact)(schema.pattern);
-    const finite = (0, index_1.IsTemplateLiteralFinite)(expression);
+    const finite = (0, index_1.IsTemplateLiteralExpressionFinite)(expression);
     if (!finite)
         return { ...schema, pattern: FromLiteralValue(schema.pattern, mode) };
-    const strings = [...(0, index_1.TemplateLiteralGenerate)(expression)];
+    const strings = [...(0, index_1.TemplateLiteralExpressionGenerate)(expression)];
     const literals = strings.map((value) => (0, index_2.Literal)(value));
     const mapped = FromRest(literals, mode);
     const union = (0, index_3.Union)(mapped);

package/build/require/type/record/record.d.ts

@@ -9,13 +9,13 @@ import { type TString } from '../string/index';
 import { type TInteger } from '../integer/index';
 import { type TNumber } from '../number/index';
 import { type TEnum } from '../enum/index';
-import { TTemplateLiteral, IsTemplateLiteralFinite } from '../template-literal/index';
+import { TTemplateLiteral, TIsTemplateLiteralFinite } from '../template-literal/index';
 import { Kind } from '../symbols/index';
 type FromTemplateLiteralKeyInfinite<K extends TTemplateLiteral, T extends TSchema> = Ensure<TRecord<K, T>>;
 type FromTemplateLiteralKeyFinite<K extends TTemplateLiteral, T extends TSchema, I extends string = Static<K>> = (Ensure<TObject<Evaluate<{
     [_ in I]: T;
 }>>>);
-type FromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema> = IsTemplateLiteralFinite<K> extends false ? FromTemplateLiteralKeyInfinite<K, T> : FromTemplateLiteralKeyFinite<K, T>;
+type FromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema> = TIsTemplateLiteralFinite<K> extends false ? FromTemplateLiteralKeyInfinite<K, T> : FromTemplateLiteralKeyFinite<K, T>;
 declare function FromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema>(K: K, T: T, options: ObjectOptions): FromTemplateLiteralKey<K, T>;
 type FromEnumKey<K extends Record<string, string | number>, T extends TSchema> = Ensure<TObject<{
     [_ in K[keyof K]]: T;

package/build/require/type/record/record.js

@@ -38,8 +38,7 @@ function RecordCreateFromKeys(K, T, options) {
 }
 // prettier-ignore
 function FromTemplateLiteralKey(K, T, options) {
-    const expression = (0, index_4.TemplateLiteralParseExact)(K.pattern);
-    return ((0, index_4.IsTemplateLiteralFinite)(expression)
+    return ((0, index_4.IsTemplateLiteralFinite)(K)
         ? RecordCreateFromKeys((0, index_6.IndexPropertyKeys)(K), T, options)
         : RecordCreateFromPattern(K.pattern, T, options));
 }

package/build/require/type/schema/schema.d.ts

@@ -20,7 +20,7 @@ export interface SchemaOptions {
 export interface TKind {
     [Kind]: string;
 }
-export interface TSchema extends SchemaOptions, TKind {
+export interface TSchema extends TKind, SchemaOptions {
     [ReadonlyKind]?: string;
     [OptionalKind]?: string;
     [Hint]?: string;

package/build/require/type/symbol/symbol.d.ts

@@ -1,6 +1,6 @@
 import { TSchema, SchemaOptions } from '../schema/index';
 import { Kind } from '../symbols/index';
-export type SymbolValue = string | number | undefined;
+export type TSymbolValue = string | number | undefined;
 export interface TSymbol extends TSchema, SchemaOptions {
     [Kind]: 'Symbol';
     static: symbol;

package/build/require/type/template-literal/finite.d.ts

@@ -6,11 +6,13 @@ import type { TNumber } from '../number/index';
 import type { TInteger } from '../integer/index';
 import type { TBigInt } from '../bigint/index';
 import type { TLiteral } from '../literal/index';
-import type { Expression } from './parser';
+import type { Expression } from './parse';
 export declare class TemplateLiteralFiniteError extends Error {
 }
-type IsTemplateLiteralFiniteCheck<T> = T extends TTemplateLiteral<infer U extends TTemplateLiteralKind[]> ? IsTemplateLiteralFiniteArray<U> : T extends TUnion<infer U extends TTemplateLiteralKind[]> ? IsTemplateLiteralFiniteArray<U> : T extends TString ? false : T extends TBoolean ? false : T extends TNumber ? false : T extends TInteger ? false : T extends TBigInt ? false : T extends TLiteral ? true : false;
-type IsTemplateLiteralFiniteArray<T extends TTemplateLiteralKind[]> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? IsTemplateLiteralFiniteCheck<L> extends false ? false : IsTemplateLiteralFiniteArray<R> : true;
-export type IsTemplateLiteralFinite<T> = T extends TTemplateLiteral<infer U> ? IsTemplateLiteralFiniteArray<U> : false;
-export declare function IsTemplateLiteralFinite(expression: Expression): boolean;
+type FromTemplateLiteralKind<T> = T extends TTemplateLiteral<infer U extends TTemplateLiteralKind[]> ? FromTemplateLiteralKinds<U> : T extends TUnion<infer U extends TTemplateLiteralKind[]> ? FromTemplateLiteralKinds<U> : T extends TString ? false : T extends TNumber ? false : T extends TInteger ? false : T extends TBigInt ? false : T extends TBoolean ? true : T extends TLiteral ? true : false;
+type FromTemplateLiteralKinds<T extends TTemplateLiteralKind[]> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? FromTemplateLiteralKind<L> extends false ? false : FromTemplateLiteralKinds<R> : true;
+export declare function IsTemplateLiteralExpressionFinite(expression: Expression): boolean;
+export type TIsTemplateLiteralFinite<T> = T extends TTemplateLiteral<infer U> ? FromTemplateLiteralKinds<U> : false;
+/** Returns true if this TemplateLiteral resolves to a finite set of values */
+export declare function IsTemplateLiteralFinite<T extends TTemplateLiteral>(schema: T): boolean;
 export {};

package/build/require/type/template-literal/finite.js

@@ -1,7 +1,8 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsTemplateLiteralFinite = exports.TemplateLiteralFiniteError = void 0;
+exports.IsTemplateLiteralFinite = exports.IsTemplateLiteralExpressionFinite = exports.TemplateLiteralFiniteError = void 0;
+const parse_1 = require("./parse");
 // ------------------------------------------------------------------
 // TemplateLiteralFiniteError
 // ------------------------------------------------------------------
@@ -33,13 +34,22 @@ function IsBooleanExpression(expression) {
 function IsStringExpression(expression) {
     return expression.type === 'const' && expression.const === '.*';
 }
+// ------------------------------------------------------------------
+// IsTemplateLiteralExpressionFinite
+// ------------------------------------------------------------------
 // prettier-ignore
-function IsTemplateLiteralFinite(expression) {
-    return (IsBooleanExpression(expression) ? true :
-        IsNumberExpression(expression) || IsStringExpression(expression) ? false :
-            (expression.type === 'and') ? expression.expr.every((expr) => IsTemplateLiteralFinite(expr)) :
-                (expression.type === 'or') ? expression.expr.every((expr) => IsTemplateLiteralFinite(expr)) :
+function IsTemplateLiteralExpressionFinite(expression) {
+    return (IsNumberExpression(expression) || IsStringExpression(expression) ? false :
+        IsBooleanExpression(expression) ? true :
+            (expression.type === 'and') ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) :
+                (expression.type === 'or') ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) :
                     (expression.type === 'const') ? true :
                         (() => { throw new TemplateLiteralFiniteError(`Unknown expression type`); })());
 }
+exports.IsTemplateLiteralExpressionFinite = IsTemplateLiteralExpressionFinite;
+/** Returns true if this TemplateLiteral resolves to a finite set of values */
+function IsTemplateLiteralFinite(schema) {
+    const expression = (0, parse_1.TemplateLiteralParseExact)(schema.pattern);
+    return IsTemplateLiteralExpressionFinite(expression);
+}
 exports.IsTemplateLiteralFinite = IsTemplateLiteralFinite;

package/build/require/type/template-literal/generate.d.ts

@@ -1,15 +1,21 @@
+import { TIsTemplateLiteralFinite } from './finite';
+import type { Assert } from '../helpers/index';
+import type { TBoolean } from '../boolean/index';
 import type { TTemplateLiteral, TTemplateLiteralKind } from './index';
 import type { TLiteral, TLiteralValue } from '../literal/index';
-import type { Expression } from './parser';
+import type { Expression } from './parse';
 import type { TUnion } from '../union/index';
+export declare class TemplateLiteralGenerateError extends Error {
+}
 type StringReduceUnary<L extends string, R extends string[]> = R extends [infer A extends string, ...infer B extends string[]] ? [`${L}${A}`, ...StringReduceUnary<L, B>] : [];
 type StringReduceBinary<L extends string[], R extends string[]> = L extends [infer A extends string, ...infer B extends string[]] ? [...StringReduceUnary<A, R>, ...StringReduceBinary<B, R>] : [];
 type StringReduceMany<T extends string[][]> = T extends [infer L extends string[], infer R extends string[], ...infer Rest extends string[][]] ? StringReduceMany<[StringReduceBinary<L, R>, ...Rest]> : T;
-type StringReduce<T extends string[][], O = StringReduceMany<T>> = 0 extends keyof O ? O[0] : [];
-type TemplateLiteralReduceUnion<T extends TTemplateLiteralKind[]> = T extends [infer L extends TLiteral, ...infer R extends TLiteral[]] ? [L['const'], ...TemplateLiteralReduceUnion<R>] : [];
-type TemplateLiteralReduce<T extends TTemplateLiteralKind[]> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? L extends TLiteral<infer S extends TLiteralValue> ? [[S], ...TemplateLiteralReduce<R>] : L extends TUnion<infer S extends TTemplateLiteralKind[]> ? [TemplateLiteralReduceUnion<S>, ...TemplateLiteralReduce<R>] : [] : [];
-export declare class TemplateLiteralGenerateError extends Error {
-}
-export type TemplateLiteralGenerate<T> = T extends TTemplateLiteral<infer S extends TTemplateLiteralKind[]> ? TemplateLiteralReduce<S> extends infer R extends string[][] ? StringReduce<R> : [] : [];
-export declare function TemplateLiteralGenerate(expression: Expression): IterableIterator<string>;
+type StringReduce<T extends string[][], O = StringReduceMany<T>> = 0 extends keyof O ? Assert<O[0], string[]> : [];
+type FromTemplateLiteralUnionKinds<T extends TTemplateLiteralKind[]> = T extends [infer L extends TLiteral, ...infer R extends TLiteral[]] ? [L['const'], ...FromTemplateLiteralUnionKinds<R>] : [];
+type FromTemplateLiteralKinds<T extends TTemplateLiteralKind[]> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? (L extends TLiteral<infer S extends TLiteralValue> ? [[S], ...FromTemplateLiteralKinds<R>] : L extends TUnion<infer S extends TTemplateLiteralKind[]> ? [FromTemplateLiteralUnionKinds<S>, ...FromTemplateLiteralKinds<R>] : L extends TBoolean ? [['true', 'false'], ...FromTemplateLiteralKinds<R>] : [
+]) : [];
+export declare function TemplateLiteralExpressionGenerate(expression: Expression): IterableIterator<string>;
+export type TTemplateLiteralGenerate<T extends TTemplateLiteral, F = TIsTemplateLiteralFinite<T>> = F extends true ? (T extends TTemplateLiteral<infer S extends TTemplateLiteralKind[]> ? FromTemplateLiteralKinds<S> extends infer R extends string[][] ? StringReduce<R> : [] : []) : [];
+/** Generates a tuple of strings from the given TemplateLiteral. Returns an empty tuple if infinite. */
+export declare function TemplateLiteralGenerate<T extends TTemplateLiteral>(schema: T): TTemplateLiteralGenerate<T>;
 export {};

package/build/require/type/template-literal/generate.js

@@ -1,9 +1,17 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TemplateLiteralGenerate = exports.TemplateLiteralGenerateError = void 0;
+exports.TemplateLiteralGenerate = exports.TemplateLiteralExpressionGenerate = exports.TemplateLiteralGenerateError = void 0;
+const finite_1 = require("./finite");
+const parse_1 = require("./parse");
 // ------------------------------------------------------------------
-// GenerateFromExpression
+// TemplateLiteralGenerateError
+// ------------------------------------------------------------------
+class TemplateLiteralGenerateError extends Error {
+}
+exports.TemplateLiteralGenerateError = TemplateLiteralGenerateError;
+// ------------------------------------------------------------------
+// TemplateLiteralExpressionGenerate
 // ------------------------------------------------------------------
 // prettier-ignore
 function* GenerateReduce(buffer) {
@@ -17,24 +25,18 @@ function* GenerateReduce(buffer) {
 }
 // prettier-ignore
 function* GenerateAnd(expression) {
-    return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralGenerate(expr)]));
+    return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralExpressionGenerate(expr)]));
 }
 // prettier-ignore
 function* GenerateOr(expression) {
     for (const expr of expression.expr)
-        yield* TemplateLiteralGenerate(expr);
+        yield* TemplateLiteralExpressionGenerate(expr);
 }
 // prettier-ignore
 function* GenerateConst(expression) {
     return yield expression.const;
 }
-// ------------------------------------------------------------------
-// TemplateLiteralGenerateError
-// ------------------------------------------------------------------
-class TemplateLiteralGenerateError extends Error {
-}
-exports.TemplateLiteralGenerateError = TemplateLiteralGenerateError;
-function* TemplateLiteralGenerate(expression) {
+function* TemplateLiteralExpressionGenerate(expression) {
     return expression.type === 'and'
         ? yield* GenerateAnd(expression)
         : expression.type === 'or'
@@ -45,4 +47,13 @@ function* TemplateLiteralGenerate(expression) {
                     throw new TemplateLiteralGenerateError('Unknown expression');
                 })();
 }
+exports.TemplateLiteralExpressionGenerate = TemplateLiteralExpressionGenerate;
+/** Generates a tuple of strings from the given TemplateLiteral. Returns an empty tuple if infinite. */
+function TemplateLiteralGenerate(schema) {
+    const expression = (0, parse_1.TemplateLiteralParseExact)(schema.pattern);
+    // prettier-ignore
+    return ((0, finite_1.IsTemplateLiteralExpressionFinite)(expression)
+        ? [...TemplateLiteralExpressionGenerate(expression)]
+        : []);
+}
 exports.TemplateLiteralGenerate = TemplateLiteralGenerate;

package/build/require/type/template-literal/index.d.ts

@@ -1,7 +1,7 @@
 export * from './finite';
 export * from './generate';
 export * from './syntax';
-export * from './parser';
+export * from './parse';
 export * from './pattern';
 export * from './union';
 export * from './template-literal';