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

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

@@ -6,18 +6,17 @@ import { type TUnion } from '../union/index';
 import { type TNever } from '../never/index';
 import { type TLiteral } from '../literal/index';
 import { type Static } from '../static/index';
-import { UnionEvaluated } from '../union/index';
+import { type TUnionEvaluated } from '../union/index';
 import { type TExcludeFromMappedResult } from './exclude-from-mapped-result';
-type ExcludeTemplateLiteralResult<T extends string> = UnionEvaluated<AssertRest<UnionToTuple<{
+type TExcludeTemplateLiteralResult<T extends string> = TUnionEvaluated<AssertRest<UnionToTuple<{
     [K in T]: TLiteral<K>;
 }[T]>>>;
-type ExcludeTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = (Exclude<Static<T>, Static<U>> extends infer S ? ExcludeTemplateLiteralResult<Assert<S, string>> : never);
-type ExcludeArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
+type TExcludeTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = (Exclude<Static<T>, Static<U>> extends infer S ? TExcludeTemplateLiteralResult<Assert<S, string>> : never);
+type TExcludeArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
     [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? never : T[K];
-}[number]>> extends infer R extends TSchema[] ? UnionEvaluated<R> : never;
-type ExcludeResolve<T extends TSchema, U extends TSchema> = T extends TTemplateLiteral ? ExcludeTemplateLiteral<T, U> : T extends TUnion<infer S> ? ExcludeArray<S, U> : T extends U ? TNever : T;
-declare function ExcludeResolve<L extends TSchema, R extends TSchema>(L: L, R: R): ExcludeResolve<L, R>;
-export type TExclude<T extends TSchema, U extends TSchema> = ExcludeResolve<T, U>;
+}[number]>> extends infer R extends TSchema[] ? TUnionEvaluated<R> : never;
+type TExcludeResolve<T extends TSchema, U extends TSchema> = T extends TTemplateLiteral ? TExcludeTemplateLiteral<T, U> : T extends TUnion<infer S> ? TExcludeArray<S, U> : T extends U ? TNever : T;
+export type TExclude<T extends TSchema, U extends TSchema> = TExcludeResolve<T, U>;
 /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
 export declare function Exclude<L extends TMappedResult, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromMappedResult<L, R>;
 /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */

package/build/require/type/extends/extends-from-mapped-key.d.ts

@@ -4,14 +4,11 @@ import type { Assert } from '../helpers/index';
 import { type TMappedResult, type TMappedKey } from '../mapped/index';
 import { TLiteral, TLiteralValue } from '../literal/index';
 import { type TExtends } from './extends';
-type FromPropertyKey<K extends PropertyKey, U extends TSchema, L extends TSchema, R extends TSchema> = {
+type TFromPropertyKey<K extends PropertyKey, U extends TSchema, L extends TSchema, R extends TSchema> = {
     [_ in K]: TExtends<TLiteral<Assert<K, TLiteralValue>>, U, L, R>;
 };
-declare function FromPropertyKey<K extends PropertyKey, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R, options: SchemaOptions): FromPropertyKey<K, U, L, R>;
-type FromPropertyKeys<K extends PropertyKey[], U extends TSchema, L extends TSchema, R extends TSchema> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? FromPropertyKey<LK, U, L, R> & FromPropertyKeys<RK, U, L, R> : {});
-declare function FromPropertyKeys<K extends PropertyKey[], U extends TSchema, L extends TSchema, R extends TSchema>(K: [...K], U: U, L: L, R: R, options: SchemaOptions): FromPropertyKeys<K, U, L, R>;
-type FromMappedKey<K extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema> = (FromPropertyKeys<K['keys'], U, L, R>);
-declare function FromMappedKey<K extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R, options: SchemaOptions): FromMappedKey<K, U, L, R>;
-export type TExtendsFromMappedKey<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = FromMappedKey<T, U, L, R>> = (TMappedResult<P>);
-export declare function ExtendsFromMappedKey<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = FromMappedKey<T, U, L, R>>(T: T, U: U, L: L, R: R, options: SchemaOptions): TMappedResult<P>;
+type TFromPropertyKeys<K extends PropertyKey[], U extends TSchema, L extends TSchema, R extends TSchema, Acc extends TProperties = {}> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? TFromPropertyKeys<RK, U, L, R, Acc & TFromPropertyKey<LK, U, L, R>> : Acc);
+type TFromMappedKey<K extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema> = (TFromPropertyKeys<K['keys'], U, L, R>);
+export type TExtendsFromMappedKey<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = TFromMappedKey<T, U, L, R>> = (TMappedResult<P>);
+export declare function ExtendsFromMappedKey<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = TFromMappedKey<T, U, L, R>>(T: T, U: U, L: L, R: R, options: SchemaOptions): TMappedResult<P>;
 export {};

package/build/require/type/extends/extends-from-mapped-key.js

@@ -12,11 +12,11 @@ function FromPropertyKey(K, U, L, R, options) {
     };
 }
 // prettier-ignore
-function FromPropertyKeys(K, U, L, R, options) {
+function FromPropertyKeys(K, U, L, R, options, Acc = {}) {
     const [LK, ...RK] = K;
     return (K.length > 0
-        ? { ...FromPropertyKey(LK, U, L, R, options), ...FromPropertyKeys(RK, U, L, R, options) }
-        : {});
+        ? FromPropertyKeys(RK, U, L, R, options, { ...Acc, ...FromPropertyKey(LK, U, L, R, options) })
+        : Acc);
 }
 // prettier-ignore
 function FromMappedKey(K, U, L, R, options) {

package/build/require/type/extends/extends-from-mapped-result.d.ts

@@ -2,12 +2,10 @@ import type { TSchema, SchemaOptions } from '../schema/index';
 import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
 import { type TExtends } from './extends';
-type FromProperties<K extends TProperties, U extends TSchema, L extends TSchema, R extends TSchema> = ({
+type TFromProperties<K extends TProperties, U extends TSchema, L extends TSchema, R extends TSchema> = ({
     [K2 in keyof K]: TExtends<K[K2], U, L, R>;
 });
-declare function FromProperties<K extends TProperties, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R, options: SchemaOptions): FromProperties<K, U, L, R>;
-type FromMappedResult<K extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema> = (FromProperties<K['properties'], U, L, R>);
-declare function FromMappedResult<K extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R, options: SchemaOptions): FromMappedResult<K, U, L, R>;
-export type TExtendsFromMappedResult<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = FromMappedResult<T, U, L, R>> = (TMappedResult<P>);
-export declare function ExtendsFromMappedResult<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = FromMappedResult<T, U, L, R>>(T: T, U: U, L: L, R: R, options: SchemaOptions): TMappedResult<P>;
+type TFromMappedResult<K extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema> = (TFromProperties<K['properties'], U, L, R>);
+export type TExtendsFromMappedResult<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = TFromMappedResult<T, U, L, R>> = (TMappedResult<P>);
+export declare function ExtendsFromMappedResult<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = TFromMappedResult<T, U, L, R>>(T: T, U: U, L: L, R: R, options: SchemaOptions): TMappedResult<P>;
 export {};

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

@@ -5,9 +5,8 @@ import { TMappedKey, TMappedResult } from '../mapped/index';
 import { UnionToTuple } from '../helpers/index';
 import { type TExtendsFromMappedKey } from './extends-from-mapped-key';
 import { type TExtendsFromMappedResult } from './extends-from-mapped-result';
-type ExtendsResolve<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = ((Static<L> extends Static<R> ? T : U) extends infer O extends TSchema ? UnionToTuple<O> extends [infer X extends TSchema, infer Y extends TSchema] ? TUnion<[X, Y]> : O : never);
-declare function ExtendsResolve<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U): ExtendsResolve<L, R, T, U>;
-export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema> = ExtendsResolve<L, R, T, F>;
+type TExtendsResolve<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = ((Static<L> extends Static<R> ? T : U) extends infer O extends TSchema ? UnionToTuple<O> extends [infer X extends TSchema, infer Y extends TSchema] ? TUnion<[X, Y]> : O : never);
+export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema> = TExtendsResolve<L, R, T, F>;
 /** `[Json]` Creates a Conditional type */
 export declare function Extends<L extends TMappedResult, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedResult<L, R, T, F>;
 /** `[Json]` Creates a Conditional type */

package/build/require/type/extract/extract-from-mapped-result.d.ts

@@ -2,12 +2,10 @@ import type { TSchema, SchemaOptions } from '../schema/index';
 import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
 import { type TExtract } from './extract';
-type FromProperties<K extends TProperties, U extends TSchema> = ({
+type TFromProperties<K extends TProperties, U extends TSchema> = ({
     [K2 in keyof K]: TExtract<K[K2], U>;
 });
-declare function FromProperties<K extends TProperties, U extends TSchema>(K: K, U: U, options: SchemaOptions): FromProperties<K, U>;
-type FromMappedResult<K extends TMappedResult, U extends TSchema> = (FromProperties<K['properties'], U>);
-declare function FromMappedResult<K extends TMappedResult, U extends TSchema>(K: K, U: U, options: SchemaOptions): FromMappedResult<K, U>;
-export type TExtractFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = FromMappedResult<T, U>> = (TMappedResult<P>);
-export declare function ExtractFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = FromMappedResult<T, U>>(T: T, U: U, options: SchemaOptions): TMappedResult<P>;
+type TFromMappedResult<K extends TMappedResult, U extends TSchema> = (TFromProperties<K['properties'], U>);
+export type TExtractFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = TFromMappedResult<T, U>> = (TMappedResult<P>);
+export declare function ExtractFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = TFromMappedResult<T, U>>(T: T, U: U, options: SchemaOptions): TMappedResult<P>;
 export {};

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

@@ -5,18 +5,18 @@ import { type TTemplateLiteral } from '../template-literal/index';
 import { type TLiteral } from '../literal/index';
 import { type TUnion } from '../union/index';
 import { type Static } from '../static/index';
-import { UnionEvaluated } from '../union/index';
+import { type TUnionEvaluated } from '../union/index';
 import { type TExtractFromMappedResult } from './extract-from-mapped-result';
-type FromTemplateLiteralResult<T extends string> = UnionEvaluated<AssertRest<UnionToTuple<{
+type TFromTemplateLiteralResult<T extends string> = TUnionEvaluated<AssertRest<UnionToTuple<{
     [K in T]: TLiteral<K>;
 }[T]>>>;
-type FromTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Extract<Static<T>, Static<U>> extends infer S ? FromTemplateLiteralResult<Assert<S, string>> : never;
-type FromArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
+type TFromTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Extract<Static<T>, Static<U>> extends infer S ? TFromTemplateLiteralResult<Assert<S, string>> : never;
+type TFromArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
     [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? T[K] : never;
-}[number]>> extends infer R extends TSchema[] ? UnionEvaluated<R> : never;
-export type ExtractResolve<T extends TSchema, U extends TSchema> = (T extends TTemplateLiteral ? FromTemplateLiteral<T, U> : T extends TUnion<infer S> ? FromArray<S, U> : T extends U ? T : T);
-export declare function ExtractResolve<L extends TSchema, R extends TSchema>(L: L, R: R): ExtractResolve<L, R>;
-export type TExtract<T extends TSchema, U extends TSchema> = ExtractResolve<T, U>;
+}[number]>> extends infer R extends TSchema[] ? TUnionEvaluated<R> : never;
+export type TExtractResolve<T extends TSchema, U extends TSchema> = (T extends TTemplateLiteral ? TFromTemplateLiteral<T, U> : T extends TUnion<infer S> ? TFromArray<S, U> : T extends U ? T : T);
+export declare function ExtractResolve<L extends TSchema, R extends TSchema>(L: L, R: R): TExtractResolve<L, R>;
+export type TExtract<T extends TSchema, U extends TSchema> = TExtractResolve<T, U>;
 /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
 export declare function Extract<L extends TMappedResult, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromMappedResult<L, R>;
 /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */

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

@@ -3,7 +3,7 @@ import type { Static } from '../static/index';
 import type { Ensure } from '../helpers/index';
 import { Kind } from '../symbols/index';
 type FunctionStaticReturnType<T extends TSchema, P extends unknown[]> = Static<T, P>;
-type FunctionStaticParameters<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...FunctionStaticParameters<R, P>] : [];
+type FunctionStaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? FunctionStaticParameters<R, P, [...Acc, Static<L, P>]> : Acc;
 type FunctionStatic<T extends TSchema[], U extends TSchema, P extends unknown[]> = (Ensure<(...param: FunctionStaticParameters<T, P>) => FunctionStaticReturnType<U, P>>);
 export interface TFunction<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Function';

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

@@ -7,7 +7,7 @@ export type TupleToUnion<T extends any[]> = {
 }[number];
 export type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
 export type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
-export type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, L>>, L];
+export type UnionToTuple<U, Acc extends unknown[] = [], R = UnionLast<U>> = [U] extends [never] ? Acc : UnionToTuple<Exclude<U, R>, [Extract<U, R>, ...Acc]>;
 export type Trim<T> = T extends `${' '}${infer U}` ? Trim<U> : T extends `${infer U}${' '}` ? Trim<U> : T;
 export type Assert<T, E> = T extends E ? T : never;
 export type Evaluate<T> = T extends infer O ? {

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

@@ -28,7 +28,6 @@ export * from './iterator/index';
 export * from './keyof/index';
 export * from './literal/index';
 export * from './mapped/index';
-export * from './modifiers/index';
 export * from './never/index';
 export * from './not/index';
 export * from './null/index';

package/build/require/type/index.js

@@ -45,7 +45,6 @@ __exportStar(require("./iterator/index"), exports);
 __exportStar(require("./keyof/index"), exports);
 __exportStar(require("./literal/index"), exports);
 __exportStar(require("./mapped/index"), exports);
-__exportStar(require("./modifiers/index"), exports);
 __exportStar(require("./never/index"), exports);
 __exportStar(require("./not/index"), exports);
 __exportStar(require("./null/index"), exports);

package/build/require/type/indexed/indexed-from-mapped-key.d.ts

@@ -3,14 +3,11 @@ import { type TProperties } from '../object/index';
 import { type TIndex } from './indexed';
 import { type TMappedResult, type TMappedKey } from '../mapped/index';
 import { Evaluate } from '../helpers/index';
-type MappedIndexPropertyKey<T extends TSchema, K extends PropertyKey> = {
+type TMappedIndexPropertyKey<T extends TSchema, K extends PropertyKey> = {
     [_ in K]: TIndex<T, [K]>;
 };
-declare function MappedIndexPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K, options: SchemaOptions): MappedIndexPropertyKey<T, K>;
-type MappedIndexPropertyKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? MappedIndexPropertyKey<T, L> & MappedIndexPropertyKeys<T, R> : {});
-declare function MappedIndexPropertyKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K], options: SchemaOptions): MappedIndexPropertyKeys<T, K>;
-type MappedIndexProperties<T extends TSchema, K extends TMappedKey> = Evaluate<MappedIndexPropertyKeys<T, K['keys']>>;
-declare function MappedIndexProperties<T extends TSchema, K extends TMappedKey>(T: T, K: K, options: SchemaOptions): MappedIndexProperties<T, K>;
-export type TIndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedIndexProperties<T, K>> = (TMappedResult<P>);
-export declare function IndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedIndexProperties<T, K>>(T: T, K: K, options: SchemaOptions): TMappedResult<P>;
+type TMappedIndexPropertyKeys<T extends TSchema, K extends PropertyKey[], Acc extends TProperties = {}> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TMappedIndexPropertyKeys<T, R, Acc & TMappedIndexPropertyKey<T, L>> : Acc);
+type TMappedIndexProperties<T extends TSchema, K extends TMappedKey> = Evaluate<TMappedIndexPropertyKeys<T, K['keys']>>;
+export type TIndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TMappedIndexProperties<T, K>> = (TMappedResult<P>);
+export declare function IndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TMappedIndexProperties<T, K>>(T: T, K: K, options: SchemaOptions): TMappedResult<P>;
 export {};

package/build/require/type/indexed/indexed-from-mapped-key.js

@@ -6,17 +6,14 @@ const indexed_1 = require("./indexed");
 const index_1 = require("../mapped/index");
 // prettier-ignore
 function MappedIndexPropertyKey(T, K, options) {
-    // todo: propogate options into index result. This type looks like it
-    // could use a clean up, possibly inlining it into indexed.ts to
-    // bring it inline with other mapping types.
     return { [K]: (0, indexed_1.Index)(T, [K], options) };
 }
 // prettier-ignore
-function MappedIndexPropertyKeys(T, K, options) {
+function MappedIndexPropertyKeys(T, K, options, Acc = {}) {
     const [L, ...R] = K;
     return (K.length > 0
-        ? { ...MappedIndexPropertyKey(T, L, options), ...MappedIndexPropertyKeys(T, R, options) } // TS 5.4-dev
-        : {});
+        ? MappedIndexPropertyKeys(T, R, options, { ...Acc, ...MappedIndexPropertyKey(T, L, options) })
+        : Acc);
 }
 // prettier-ignore
 function MappedIndexProperties(T, K, options) {

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

@@ -1,16 +1,13 @@
-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 : [] : []);
-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>;
-type FromLiteral<T extends TLiteralValue> = (T extends PropertyKey ? [`${T}`] : []);
-declare function FromLiteral<T extends TLiteralValue>(T: T): FromLiteral<T>;
-export type TIndexPropertyKeys<T extends TSchema> = (T extends TTemplateLiteral ? FromTemplateLiteral<T> : T extends TUnion<infer S> ? FromUnion<S> : T extends TLiteral<infer S> ? FromLiteral<S> : T extends TNumber ? ['[number]'] : T extends TInteger ? ['[number]'] : [
+type TFromTemplateLiteral<T extends TTemplateLiteral, R extends string[] = TTemplateLiteralGenerate<T>> = (R);
+type TFromUnion<T extends TSchema[], Acc extends string[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, [...TIndexPropertyKeys<L>, ...Acc]> : Acc);
+type TFromLiteral<T extends TLiteralValue> = (T extends PropertyKey ? [`${T}`] : []);
+export type TIndexPropertyKeys<T extends TSchema> = (T extends TTemplateLiteral ? TFromTemplateLiteral<T> : T extends TUnion<infer S> ? TFromUnion<S> : T extends TLiteral<infer S> ? TFromLiteral<S> : T extends TNumber ? ['[number]'] : T extends TInteger ? ['[number]'] : [
 ]);
 /** Returns a tuple of PropertyKeys derived from the given TSchema */
 export declare function IndexPropertyKeys<T extends TSchema>(T: T): TIndexPropertyKeys<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/indexed/indexed.d.ts

@@ -8,32 +8,22 @@ import { type TMappedKey } from '../mapped/index';
 import { type TUnion } from '../union/index';
 import { type TTuple } from '../tuple/index';
 import { type TArray } from '../array/index';
-import { IntersectEvaluated } from '../intersect/index';
-import { UnionEvaluated } from '../union/index';
+import { type TIntersectEvaluated } from '../intersect/index';
+import { type TUnionEvaluated } from '../union/index';
 import { type TIndexPropertyKeys } from './indexed-property-keys';
 import { type TIndexFromMappedKey } from './indexed-from-mapped-key';
-type FromRest<T extends TSchema[], K extends PropertyKey> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [FromKey<L, K>, ...FromRest<R, K>] : []);
-declare function FromRest<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromRest<T, K>;
-type FromIntersectRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? [...FromIntersectRest<R>] : [L, ...FromIntersectRest<R>] : []);
-declare function FromIntersectRest<T extends TSchema[]>(T: [...T]): FromIntersectRest<T>;
-type FromIntersect<T extends TSchema[], K extends PropertyKey> = (IntersectEvaluated<FromIntersectRest<FromRest<T, K>>>);
-declare function FromIntersect<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromIntersect<T, K>;
-type FromUnionRest<T extends TSchema[], S = T> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? [] : FromUnionRest<R, S> : S);
-declare function FromUnionRest<T extends TSchema[]>(T: [...T], S?: [...T]): FromUnionRest<T>;
-type FromUnion<T extends TSchema[], K extends PropertyKey> = (UnionEvaluated<FromUnionRest<FromRest<T, K>>>);
-declare function FromUnion<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromUnion<T, K>;
-type FromTuple<T extends TSchema[], K extends PropertyKey> = (K extends keyof T ? T[K] : K extends '[number]' ? UnionEvaluated<T> : TNever);
-declare function FromTuple<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromTuple<T, K>;
-type FromArray<T extends TSchema, K extends PropertyKey> = (K extends '[number]' ? T : TNever);
-declare function FromArray<T extends TSchema, K extends PropertyKey>(T: T, K: K): FromArray<T, K>;
+type TFromRest<T extends TSchema[], K extends PropertyKey, Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, K, [...Acc, Assert<TFromKey<L, K>, TSchema>]> : Acc);
+type TFromIntersectRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? TFromIntersectRest<R, [...Acc]> : TFromIntersectRest<R, [...Acc, L]> : Acc);
+type TFromIntersect<T extends TSchema[], K extends PropertyKey> = (TIntersectEvaluated<TFromIntersectRest<TFromRest<T, K>>>);
+type TFromUnionRest<T extends TSchema[], Acc extends TSchema[] = T> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? [] : TFromUnionRest<R, Acc> : Acc);
+type TFromUnion<T extends TSchema[], K extends PropertyKey> = (TUnionEvaluated<TFromUnionRest<TFromRest<T, K>>>);
+type TFromTuple<T extends TSchema[], K extends PropertyKey> = (K extends keyof T ? T[K] : K extends '[number]' ? TUnionEvaluated<T> : TNever);
+type TFromArray<T extends TSchema, K extends PropertyKey> = (K extends '[number]' ? T : TNever);
 type AssertPropertyKey<T> = Assert<T, string | number>;
-type FromProperty<T extends TProperties, K extends PropertyKey> = (K extends keyof T ? T[K] : `${AssertPropertyKey<K>}` extends `${AssertPropertyKey<keyof T>}` ? T[AssertPropertyKey<K>] : TNever);
-declare function FromProperty<T extends TProperties, K extends PropertyKey>(T: T, K: K): FromProperty<T, K>;
-type FromKey<T extends TSchema, K extends PropertyKey> = (T extends TRecursive<infer S> ? FromKey<S, K> : T extends TIntersect<infer S> ? FromIntersect<S, K> : T extends TUnion<infer S> ? FromUnion<S, K> : T extends TTuple<infer S> ? FromTuple<S, K> : T extends TArray<infer S> ? FromArray<S, K> : T extends TObject<infer S> ? FromProperty<S, K> : TNever);
-declare function FromKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): FromKey<T, K>;
-type FromKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? [FromKey<T, L>, ...FromKeys<T, R>] : []);
-declare function FromKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): FromKeys<T, K>;
-type FromSchema<T extends TSchema, K extends PropertyKey[]> = (UnionEvaluated<FromKeys<T, K>>);
+type TFromProperty<T extends TProperties, K extends PropertyKey> = (K extends keyof T ? T[K] : `${AssertPropertyKey<K>}` extends `${AssertPropertyKey<keyof T>}` ? T[AssertPropertyKey<K>] : TNever);
+type TFromKey<T extends TSchema, K extends PropertyKey> = (T extends TRecursive<infer S> ? TFromKey<S, K> : T extends TIntersect<infer S> ? TFromIntersect<S, K> : T extends TUnion<infer S> ? TFromUnion<S, K> : T extends TTuple<infer S> ? TFromTuple<S, K> : T extends TArray<infer S> ? TFromArray<S, K> : T extends TObject<infer S> ? TFromProperty<S, K> : TNever);
+type TFromKeys<T extends TSchema, K extends PropertyKey[], Acc extends TSchema[] = []> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TFromKeys<T, R, [...Acc, Assert<TFromKey<T, L>, TSchema>]> : Acc);
+type FromSchema<T extends TSchema, K extends PropertyKey[]> = (TUnionEvaluated<TFromKeys<T, K>>);
 declare function FromSchema<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): FromSchema<T, K>;
 export type TIndex<T extends TSchema, K extends PropertyKey[]> = (FromSchema<T, K>);
 /** `[Json]` Returns an Indexed property type for the given keys */

package/build/require/type/indexed/indexed.js

@@ -14,33 +14,33 @@ const indexed_from_mapped_key_1 = require("./indexed-from-mapped-key");
 // prettier-ignore
 const type_2 = require("../guard/type");
 // prettier-ignore
-function FromRest(T, K) {
+function FromRest(T, K, Acc = []) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? [FromKey(L, K), ...FromRest(R, K)]
-        : []);
+        ? FromRest(R, K, [...Acc, FromKey(L, K)])
+        : Acc);
 }
 // prettier-ignore
-function FromIntersectRest(T) {
+function FromIntersectRest(T, Acc = []) {
     const [L, ...R] = T;
     return (T.length > 0
         ? (0, type_2.IsNever)(L)
-            ? [...FromIntersectRest(R)]
-            : [L, ...FromIntersectRest(R)]
-        : []);
+            ? FromIntersectRest(R, [...Acc])
+            : FromIntersectRest(R, [...Acc, L])
+        : Acc);
 }
 // prettier-ignore
 function FromIntersect(T, K) {
     return ((0, index_2.IntersectEvaluated)(FromIntersectRest(FromRest(T, K))));
 }
 // prettier-ignore
-function FromUnionRest(T, S = T) {
+function FromUnionRest(T, Acc = T) {
     const [L, ...R] = T;
     return (T.length > 0
         ? (0, type_2.IsNever)(L)
             ? []
-            : FromUnionRest(R, S)
-        : S);
+            : FromUnionRest(R, Acc)
+        : Acc);
 }
 // prettier-ignore
 function FromUnion(T, K) {
@@ -74,11 +74,11 @@ function FromKey(T, K) {
                         (0, index_1.Never)());
 }
 // prettier-ignore
-function FromKeys(T, K) {
+function FromKeys(T, K, Acc = []) {
     const [L, ...R] = K;
     return (K.length > 0
-        ? [FromKey(T, L), ...FromKeys(T, R)]
-        : []);
+        ? FromKeys(T, R, [...Acc, FromKey(T, L)])
+        : Acc);
 }
 // prettier-ignore
 function FromSchema(T, K) {

package/build/require/type/intersect/intersect-create.js

@@ -7,7 +7,6 @@ const type_1 = require("../clone/type");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const type_2 = require("../guard/type");
 // ------------------------------------------------------------------
 // IntersectCreate

package/build/require/type/intersect/intersect-evaluated.d.ts

@@ -1,17 +1,13 @@
-import type { SchemaOptions, TSchema } from '../schema/index';
+import type { TSchema } from '../schema/index';
 import { type TNever } from '../never/index';
 import { type TOptional } from '../optional/index';
 import type { TReadonly } from '../readonly/index';
 import { TIntersect, IntersectOptions } from './intersect-type';
-type IsIntersectOptional<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<TSchema> ? IsIntersectOptional<R> : false : true);
-declare function IsIntersectOptional<T extends TSchema[]>(T: T): IsIntersectOptional<T>;
-type RemoveOptionalFromRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<infer S extends TSchema> ? [RemoveOptionalFromType<S>, ...RemoveOptionalFromRest<R>] : [L, ...RemoveOptionalFromRest<R>] : []);
-declare function RemoveOptionalFromRest<T extends TSchema[]>(T: T): RemoveOptionalFromRest<T>;
-type RemoveOptionalFromType<T extends TSchema> = (T extends TReadonly<infer S extends TSchema> ? TReadonly<RemoveOptionalFromType<S>> : T extends TOptional<infer S extends TSchema> ? RemoveOptionalFromType<S> : T);
-declare function RemoveOptionalFromType<T extends TSchema>(T: T): RemoveOptionalFromType<T>;
-type ResolveIntersect<T extends TSchema[]> = (IsIntersectOptional<T> extends true ? TOptional<TIntersect<RemoveOptionalFromRest<T>>> : TIntersect<RemoveOptionalFromRest<T>>);
-declare function ResolveIntersect<T extends TSchema[]>(T: [...T], options: SchemaOptions): ResolveIntersect<T>;
-export type IntersectEvaluated<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : ResolveIntersect<T>);
+type TIsIntersectOptional<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<TSchema> ? TIsIntersectOptional<R> : false : true);
+type TRemoveOptionalFromType<T extends TSchema> = (T extends TReadonly<infer S extends TSchema> ? TReadonly<TRemoveOptionalFromType<S>> : T extends TOptional<infer S extends TSchema> ? TRemoveOptionalFromType<S> : T);
+type TRemoveOptionalFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<infer S extends TSchema> ? TRemoveOptionalFromRest<R, [...Acc, TRemoveOptionalFromType<S>]> : TRemoveOptionalFromRest<R, [...Acc, L]> : Acc);
+type TResolveIntersect<T extends TSchema[]> = (TIsIntersectOptional<T> extends true ? TOptional<TIntersect<TRemoveOptionalFromRest<T>>> : TIntersect<TRemoveOptionalFromRest<T>>);
+export type TIntersectEvaluated<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : TResolveIntersect<T>);
 /** `[Json]` Creates an evaluated Intersect type */
-export declare function IntersectEvaluated<T extends TSchema[], R = IntersectEvaluated<T>>(T: [...T], options?: IntersectOptions): R;
+export declare function IntersectEvaluated<T extends TSchema[], R = TIntersectEvaluated<T>>(T: [...T], options?: IntersectOptions): R;
 export {};

package/build/require/type/intersect/intersect-evaluated.js

@@ -23,14 +23,19 @@ function IsIntersectOptional(T) {
         : true);
 }
 // prettier-ignore
-function RemoveOptionalFromRest(T) {
-    return (T.map(T => RemoveOptionalFromType(T)));
-}
-// prettier-ignore
 function RemoveOptionalFromType(T) {
     return ((0, index_2.Discard)(T, [index_1.OptionalKind]));
 }
 // prettier-ignore
+function RemoveOptionalFromRest(T, Acc = []) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? (0, type_2.IsOptional)(L)
+            ? RemoveOptionalFromRest(R, [...Acc, RemoveOptionalFromType(L)])
+            : RemoveOptionalFromRest(R, [...Acc, L])
+        : Acc);
+}
+// prettier-ignore
 function ResolveIntersect(T, options) {
     return (IsIntersectOptional(T)
         ? (0, index_4.Optional)((0, intersect_create_1.IntersectCreate)(RemoveOptionalFromRest(T), options))

package/build/require/type/intersect/intersect-type.d.ts

@@ -1,14 +1,14 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import type { Static } from '../static/index';
 import { Kind } from '../symbols/index';
-type IntersectStatic<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? Static<L, P> & IntersectStatic<R, P> : unknown;
+type TIntersectStatic<T extends TSchema[], P extends unknown[], Acc extends unknown = unknown> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TIntersectStatic<R, P, Acc & Static<L, P>> : Acc;
 export type TUnevaluatedProperties = undefined | TSchema | boolean;
 export interface IntersectOptions extends SchemaOptions {
     unevaluatedProperties?: TUnevaluatedProperties;
 }
 export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, IntersectOptions {
     [Kind]: 'Intersect';
-    static: IntersectStatic<T, this['params']>;
+    static: TIntersectStatic<T, this['params']>;
     type?: 'object';
     allOf: [...T];
 }

package/build/require/type/intersect/intersect.js

@@ -8,7 +8,6 @@ const intersect_create_1 = require("./intersect-create");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const type_2 = require("../guard/type");
 /** `[Json]` Creates an evaluated Intersect type */
 function Intersect(T, options = {}) {

package/build/require/type/intrinsic/intrinsic-from-mapped-key.d.ts

@@ -1,16 +1,14 @@
 import type { SchemaOptions } from '../schema/index';
 import type { TProperties } from '../object/index';
+import { Assert } from '../helpers/index';
 import { type TMappedResult, type TMappedKey } from '../mapped/index';
 import { type TIntrinsic, type IntrinsicMode } from './intrinsic';
 import { TLiteral, TLiteralValue } from '../literal/index';
-type MappedIntrinsicPropertyKey<K extends PropertyKey, M extends IntrinsicMode, P extends TLiteralValue = K extends TLiteralValue ? K : never> = {
-    [_ in K]: TIntrinsic<TLiteral<P>, M>;
+type TMappedIntrinsicPropertyKey<K extends PropertyKey, M extends IntrinsicMode> = {
+    [_ in K]: TIntrinsic<TLiteral<Assert<K, TLiteralValue>>, M>;
 };
-declare function MappedIntrinsicPropertyKey<K extends PropertyKey, M extends IntrinsicMode>(K: K, M: M, options: SchemaOptions): MappedIntrinsicPropertyKey<K, M>;
-type MappedIntrinsicPropertyKeys<K extends PropertyKey[], M extends IntrinsicMode> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? MappedIntrinsicPropertyKey<L, M> & MappedIntrinsicPropertyKeys<R, M> : {});
-declare function MappedIntrinsicPropertyKeys<K extends PropertyKey[], M extends IntrinsicMode>(K: [...K], M: M, options: SchemaOptions): MappedIntrinsicPropertyKeys<K, M>;
-type MappedIntrinsicProperties<K extends TMappedKey, M extends IntrinsicMode> = (MappedIntrinsicPropertyKeys<K['keys'], M>);
-declare function MappedIntrinsicProperties<K extends TMappedKey, M extends IntrinsicMode>(T: K, M: M, options: SchemaOptions): MappedIntrinsicProperties<K, M>;
-export type TIntrinsicFromMappedKey<K extends TMappedKey, M extends IntrinsicMode, P extends TProperties = MappedIntrinsicProperties<K, M>> = (TMappedResult<P>);
-export declare function IntrinsicFromMappedKey<K extends TMappedKey, M extends IntrinsicMode, P extends TProperties = MappedIntrinsicProperties<K, M>>(T: K, M: M, options: SchemaOptions): TMappedResult<P>;
+type TMappedIntrinsicPropertyKeys<K extends PropertyKey[], M extends IntrinsicMode, Acc extends TProperties = {}> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TMappedIntrinsicPropertyKeys<R, M, Acc & TMappedIntrinsicPropertyKey<L, M>> : Acc);
+type TMappedIntrinsicProperties<K extends TMappedKey, M extends IntrinsicMode> = (TMappedIntrinsicPropertyKeys<K['keys'], M>);
+export type TIntrinsicFromMappedKey<K extends TMappedKey, M extends IntrinsicMode, P extends TProperties = TMappedIntrinsicProperties<K, M>> = (TMappedResult<P>);
+export declare function IntrinsicFromMappedKey<K extends TMappedKey, M extends IntrinsicMode, P extends TProperties = TMappedIntrinsicProperties<K, M>>(T: K, M: M, options: SchemaOptions): TMappedResult<P>;
 export {};

package/build/require/type/intrinsic/intrinsic-from-mapped-key.js

@@ -12,11 +12,11 @@ function MappedIntrinsicPropertyKey(K, M, options) {
     };
 }
 // prettier-ignore
-function MappedIntrinsicPropertyKeys(K, M, options) {
+function MappedIntrinsicPropertyKeys(K, M, options, Acc = {}) {
     const [L, ...R] = K;
     return (K.length > 0
-        ? { ...MappedIntrinsicPropertyKey(L, M, options), ...MappedIntrinsicPropertyKeys(R, M, options) }
-        : {});
+        ? MappedIntrinsicPropertyKeys(R, M, options, { ...Acc, ...MappedIntrinsicPropertyKey(L, M, options) })
+        : Acc);
 }
 // prettier-ignore
 function MappedIntrinsicProperties(T, M, options) {

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

@@ -1,17 +1,15 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import { type TTemplateLiteral, type TTemplateLiteralKind } from '../template-literal/index';
 import { type TIntrinsicFromMappedKey } from './intrinsic-from-mapped-key';
-import { type TLiteral, type TLiteralValue } from '../literal/index';
+import { type TLiteral } from '../literal/index';
 import { type TUnion } from '../union/index';
 import { type TMappedKey } from '../mapped/index';
 export type IntrinsicMode = 'Uppercase' | 'Lowercase' | 'Capitalize' | 'Uncapitalize';
-type FromTemplateLiteral<T extends TTemplateLiteralKind[], M extends IntrinsicMode> = M extends IntrinsicMode ? T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? [TIntrinsic<L, M>, ...FromTemplateLiteral<R, M>] : T : T;
-declare function FromTemplateLiteral<T extends TTemplateLiteralKind[], M extends IntrinsicMode>(schema: TTemplateLiteral, mode: IntrinsicMode, options: SchemaOptions): FromTemplateLiteral<T, M>;
-type FromLiteralValue<T, M extends IntrinsicMode> = (T extends string ? M extends 'Uncapitalize' ? Uncapitalize<T> : M extends 'Capitalize' ? Capitalize<T> : M extends 'Uppercase' ? Uppercase<T> : M extends 'Lowercase' ? Lowercase<T> : string : T);
-declare function FromLiteralValue(value: TLiteralValue, mode: IntrinsicMode): string;
-type FromRest<T extends TSchema[], M extends IntrinsicMode> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [TIntrinsic<L, M>, ...FromRest<R, M>] : [];
-declare function FromRest<T extends TSchema[], M extends IntrinsicMode>(T: [...T], mode: M): FromRest<T, M>;
-export type TIntrinsic<T extends TSchema, M extends IntrinsicMode> = T extends TMappedKey ? TIntrinsicFromMappedKey<T, M> : T extends TTemplateLiteral<infer S> ? TTemplateLiteral<FromTemplateLiteral<S, M>> : T extends TUnion<infer S> ? TUnion<FromRest<S, M>> : T extends TLiteral<infer S> ? TLiteral<FromLiteralValue<S, M>> : T;
+type TFromTemplateLiteral<T extends TTemplateLiteralKind[], M extends IntrinsicMode> = M extends IntrinsicMode ? T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? [TIntrinsic<L, M>, ...TFromTemplateLiteral<R, M>] : T : T;
+type TFromLiteralValue<T, M extends IntrinsicMode> = (T extends string ? M extends 'Uncapitalize' ? Uncapitalize<T> : M extends 'Capitalize' ? Capitalize<T> : M extends 'Uppercase' ? Uppercase<T> : M extends 'Lowercase' ? Lowercase<T> : string : T);
+type FromRest<T extends TSchema[], M extends IntrinsicMode, Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? FromRest<R, M, [...Acc, TIntrinsic<L, M>]> : Acc;
+declare function FromRest<T extends TSchema[], M extends IntrinsicMode>(T: [...T], M: M, Acc?: TSchema[]): FromRest<T, M>;
+export type TIntrinsic<T extends TSchema, M extends IntrinsicMode> = T extends TMappedKey ? TIntrinsicFromMappedKey<T, M> : T extends TTemplateLiteral<infer S> ? TTemplateLiteral<TFromTemplateLiteral<S, M>> : T extends TUnion<infer S> ? TUnion<FromRest<S, M>> : T extends TLiteral<infer S> ? TLiteral<TFromLiteralValue<S, M>> : T;
 /** Applies an intrinsic string manipulation to the given type. */
 export declare function Intrinsic<T extends TMappedKey, M extends IntrinsicMode>(schema: T, mode: M, options?: SchemaOptions): TIntrinsicFromMappedKey<T, M>;
 /** Applies an intrinsic string manipulation to the given type. */