diff --git a/examples/index.ts b/examples/index.ts
index 953bc060c..de5058a87 100644
--- a/examples/index.ts
+++ b/examples/index.ts
@@ -1,184 +1,143 @@
 import { TypeSystem } from '@sinclair/typebox/system'
 import { TypeCompiler } from '@sinclair/typebox/compiler'
 import { Value, ValuePointer } from '@sinclair/typebox/value'
-import { Type, TypeGuard, Kind, Static, TSchema, TProperties, TArray, TLiteral, TTemplateLiteral } from '@sinclair/typebox'
-import { TObject, TUnion, TInteger, TBigInt, TIntersect, TString, TNumber, TBoolean, TNever, TTuple, UnionType, TRecursive } from '@sinclair/typebox'
-
-export type EmptyString = ''
-
-export type Filter<T extends TSchema[], U extends TSchema> = 
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? L extends U ? [L, ...Filter<R, U>] : Filter<R, U>
-    : []
-// ------------------------------------------------------------------
-// TemplateLiteralFinite
-// ------------------------------------------------------------------
-// prettier-ignore
-export type IsTemplateLiteralFiniteCheck<T> =
-  T extends TTemplateLiteral<infer S> ? IsTemplateLiteralFiniteRest<S> :    
-  T extends TUnion<infer S> ? IsTemplateLiteralFiniteRest<S> :    
-  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
-// prettier-ignore
-export type IsTemplateLiteralFiniteRest<T extends TTemplateLiteralKind[]> = 
-  T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] 
-    ? IsTemplateLiteralFiniteCheck<L> extends false 
-      ? false 
-      : IsTemplateLiteralFiniteRest<R> 
-    : true
-// prettier-ignore
-export type IsTemplateLiteralFinite<T extends TTemplateLiteralKind> = 
-  T extends TTemplateLiteral<infer U> 
-    ? IsTemplateLiteralFiniteRest<U> 
-    : false
-// ------------------------------------------------------------------
-// TemplateLiteralRest
-// ------------------------------------------------------------------
-// prettier-ignore
-export type TTemplateLiteralKind = 
-  | TUnion 
-  | TLiteral 
-  | TInteger 
-  | TTemplateLiteral 
-  | TNumber 
-  | TBigInt 
-  | TString 
-  | TBoolean 
-  | TNever
-
-// prettier-ignore
-export type TTemplateLiteralUnion<T extends TSchema[]> =
-  T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]]
-    ? `${TTemplateLiteralString<L>}` | `${TTemplateLiteralUnion<R>}`
-    : ''
-// prettier-ignore
-export type TTemplateLiteralString<T extends TTemplateLiteralKind> = 
-  T extends TTemplateLiteral<infer S> ? `${TTemplateLiteralRest<S>}` : 
-  T extends TUnion<infer S> ? TTemplateLiteralUnion<S> :
-  T extends TLiteral<infer S> ? `${S}` :
-  T extends TString ? `${string}` :
-  T extends TInteger ? `${number}` :
-  T extends TNumber ? `${number}` : 
-  T extends TBigInt ? `${bigint}` : 
-  T extends TBoolean ? `${boolean}` :
-  ''
-// prettier-ignore
-export type TTemplateLiteralRest<T extends TSchema[]> = 
-  T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] 
-    ? `${TTemplateLiteralString<L>}${TTemplateLiteralRest<R>}`
-    : ''
-
-const T = Type.TemplateLiteral('a${1|2|3}z')
-
-type Map<T> = T extends TTemplateLiteral<infer S> ? TTemplateLiteralRest<S> : ''
-    
-type Q = Map<typeof T>
-
-type H = Static<typeof T>
-
-type X = ['A', 'B', 'C']
-
-// ------------------------------------------------------------------
-// TIndexer
-// ------------------------------------------------------------------
-// prettier-ignore
-export type TIndexerUnion<T extends TSchema[]> = 
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? [...TIndexer<L>, ...TIndexerUnion<R>]
-    : []
-// prettier-ignore
-export type TIndexer<T extends TSchema> = 
-  T extends TTemplateLiteral<infer S> ? TTemplateLiteralRest<S> :
-  T extends TUnion<infer S> ? TIndexerUnion<S> :
-  T extends TLiteral<infer S> ? [S] :
-  T extends TString ? [string] :
-  T extends TNumber ? [number] :
-  []
+import { Type, Static, TSchema, TProperties, TArray, TLiteral, TTemplateLiteral, TypeGuard, TemplateLiteralParser, TemplateLiteralGenerator, TemplateLiteralResolver } from '@sinclair/typebox'
+import { TObject, TUnion, UnionToTuple, TInteger, TBigInt, TIntersect, TString, TNumber, TBoolean, TNever, TTuple, UnionType, TRecursive } from '@sinclair/typebox'
 
 // ------------------------------------------------------------------
 // TIndex
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TIndexProperties<T extends TProperties, K extends PropertyKey> = 
-  K extends keyof T 
-    ? [T[K]] 
+export type TIndexProperties<T extends TProperties, K extends PropertyKey> =
+  K extends keyof T
+    ? [T[K]]
     : []
 // prettier-ignore
-export type TIndexTuple<T extends TSchema[], K extends PropertyKey> = 
-  K extends keyof T 
-    ? [T[K]] 
+export type TIndexTuple<T extends TSchema[], K extends PropertyKey> =
+  K extends keyof T
+    ? [T[K]]
     : []
 // prettier-ignore
-export type TIndexArray<T extends TSchema, K extends PropertyKey> = 
-  K extends number 
-    ? [T] 
+export type TIndexArray<T extends TSchema, K extends PropertyKey> =
+  K extends number
+    ? [T]
     : []
 // prettier-ignore
-export type TIndexIntersect<T extends TSchema[], K extends PropertyKey> = 
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]] 
-    ? [...TIndexKey<L, K>, ...TIndexIntersect<R, K>] 
+export type TIndexIntersect<T extends TSchema[], K extends PropertyKey> =
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? [...TIndexKey<L, K>, ...TIndexIntersect<R, K>]
     : []
 // prettier-ignore
-export type TIndexUnionGather<T extends TSchema[], K extends PropertyKey> = 
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]] 
-    ? [TIndexKey<L, K>, ...TIndexUnionGather<R, K>] 
+export type TIndexUnionGather<T extends TSchema[], K extends PropertyKey> =
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? [TIndexKey<L, K>, ...TIndexUnionGather<R, K>]
     : []
 // prettier-ignore
-export type TIndexUnionCheck<T extends TSchema[][]> = 
-  T extends [infer L extends TSchema[], ...infer R extends TSchema[][]] 
-    ? L extends [] 
-      ? false 
-      : TIndexUnionCheck<R> 
+export type TIndexUnionCheck<T extends TSchema[][]> =
+  T extends [infer L extends TSchema[], ...infer R extends TSchema[][]]
+    ? L extends []
+      ? false
+      : TIndexUnionCheck<R>
     : true
 // prettier-ignore
-export type TIndexUnionFinal<T extends TSchema[][]> = 
-  T extends [infer L extends TSchema[], ...infer R extends TSchema[][]] 
-    ? [...L, ...TIndexUnionFinal<R>] 
+export type TIndexUnionFinal<T extends TSchema[][]> =
+  T extends [infer L extends TSchema[], ...infer R extends TSchema[][]]
+    ? [...L, ...TIndexUnionFinal<R>]
     : []
 // prettier-ignore
-export type TIndexUnion<T extends TSchema[], K extends PropertyKey, G extends TSchema[][] = TIndexUnionGather<T, K>, C extends boolean = TIndexUnionCheck<G>> = 
-  C extends true 
-    ? TIndexUnionFinal<G> 
+export type TIndexUnion<T extends TSchema[], K extends PropertyKey, G extends TSchema[][] = TIndexUnionGather<T, K>, C extends boolean = TIndexUnionCheck<G>> =
+  C extends true
+    ? TIndexUnionFinal<G>
     : []
 // prettier-ignore
-export type TIndexKey<T extends TSchema, K extends PropertyKey> = 
+export type TIndexKey<T extends TSchema, K extends PropertyKey> =
   T extends TRecursive<infer S> ? TIndexKey<S, K> :
-  T extends TIntersect<infer S> ? TIndexIntersect<S, K> :  
+  T extends TIntersect<infer S> ? TIndexIntersect<S, K> :
   T extends TUnion<infer S> ? TIndexUnion<S, K> :
   T extends TTuple<infer S> ? TIndexTuple<S, K> :
   T extends TArray<infer S> ? TIndexArray<S, K> :
   T extends TObject<infer S> ? TIndexProperties<S, K> :
   []
 // prettier-ignore
-export type TIndexKeys<T extends TSchema, K extends PropertyKey[]> = 
-  K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] 
-    ? [...TIndexKey<T, L>, ...TIndexKeys<T, R>] 
+export type TIndexKeys<T extends TSchema, K extends PropertyKey[]> =
+  K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
+    ? [...TIndexKey<T, L>, ...TIndexKeys<T, R>]
     : []
 export type TIndex<T extends TSchema, K extends PropertyKey[], R extends TSchema[] = TIndexKeys<T, K>> = UnionType<R>
 
 export function Index<T extends TSchema, K extends string[]>(schema: T, keys: [...K]): TIndex<T, K>
-export function Index<T extends TSchema, I extends TSchema, K extends PropertyKey[] = TIndexer<I>>(schema: T, keys: I): TIndex<T, K> 
+export function Index<T extends TSchema, I extends TSchema, K extends PropertyKey[] = TIndexer<I>>(schema: T, keys: I): TIndex<T, K>
 export function Index(schema: TSchema, keys: unknown): any {
 
 }
+// ------------------------------------------------------------------
+// TIndexer
+// ------------------------------------------------------------------
+export type TIndexerTemplateLiteral<T extends TTemplateLiteral> = UnionToTuple<Static<T>>
+export type TIndexerUnion<T extends TSchema[]> =
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? [...TIndexer<L>, ...TIndexerUnion<R>]
+    : []
+// prettier-ignore
+export type TIndexer<T extends TSchema> =
+  T extends TTemplateLiteral ? TIndexerTemplateLiteral<T> :
+  T extends TUnion<infer S> ? TIndexerUnion<S> :
+  T extends TLiteral<infer S> ? [S] :
+  T extends TString ? [string] :
+  T extends TNumber ? [number] :
+  T extends TInteger ? [number] :
+  T extends TBigInt ? [bigint] :
+  []
+
+export namespace Indexer {
+  function TIndexerTemplateLiteral(schema: TUnion<TLiteral[]> | TString | TNever): string[] {
+    switch(true) {
+      case TypeGuard.TUnionLiteral(schema): return schema.anyOf.map(schema => schema.const.toString())
+      case TypeGuard.TString(schema): return [`{string}`]
+      default: return []
+    }
+  }
+  function TIndexerUnion(schemas: TSchema[]): string[] {
+    const [L, R] = [schemas.slice(0, 1), ...schemas.slice(1)]
+    return []
+  }
+  function Visit(schema: TSchema, keys: string): string[] {
+    switch (true) {
+      case TypeGuard.TTemplateLiteral(schema): return TIndexerTemplateLiteral(TemplateLiteralResolver.Resolve(schema))
+      case TypeGuard.TUnion(schema): return TIndexerUnion(schema.anyOf)
+      case TypeGuard.TLiteral(schema): return [schema.const.toString()]
+      case TypeGuard.TString(schema): return ['{string}']
+      case TypeGuard.TNumber(schema): return ['{number}']
+      case TypeGuard.TInteger(schema): return ['{number}']
+      case TypeGuard.TBigInt(schema): return ['{bigint}']
+      default: return []
+    }
+  }
+}
+
+
+
+
+const A = Type.TemplateLiteral('a${1|2|3}')
+
+const R = TemplateLiteralResolver.Resolve(A)
+console.log(R)
 
 const S = Type.Intersect([
   Type.Object({ x: Type.Number() }),
-  Type.Object({ y: Type.String() })
+  Type.Object({ y: Type.String() }),
+  Type.Object({ z: Type.Boolean() })
 ])
 
-const A = Type.TemplateLiteral('${x|y}')
-
-type A = TIndexer<typeof A>
-
-const I = Index(S, Type.TemplateLiteral('${x|y}'))
+// const T = Type.Object({
+//   x: Type.Object({
+//     y: Type.Object({
+//       i: Index(S, Type.TemplateLiteral('${x|a}'))
+//     })
+//   })
+// })
 
-type S = Array<string>
+// type T = Static<typeof T>
 
 
 // type A = TObject<{ x: TNumber }>
diff --git a/src/typebox.ts b/src/typebox.ts
index 8bc1a38bd..be90cb8b3 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -2593,7 +2593,7 @@ export namespace TemplateLiteralPattern {
 // --------------------------------------------------------------------------------------
 export namespace TemplateLiteralResolver {
   /** Resolves a template literal as a TUnion */
-  export function Resolve(template: TTemplateLiteral): TString | TUnion | TLiteral {
+  export function Resolve(template: TTemplateLiteral): TNever | TString | TUnion<TLiteral[]> {
     const expression = TemplateLiteralParser.ParseExact(template.pattern)
     if (!TemplateLiteralFinite.Check(expression)) return Type.String()
     const literals = [...TemplateLiteralGenerator.Generate(expression)].map((value) => Type.Literal(value))