inferred-types 0.53.12 → 0.54.0

package/modules/runtime/dist/index.d.ts

@@ -1071,14 +1071,6 @@ type IsGreaterThanOrEqual<A extends NumberLike, B extends NumberLike> = IsEqual<
  */
 type IsInteger<T> = [IsNever<T>] extends [true] ? false : [T] extends [NumberLike] ? [IsStringLiteral<`${T}`>] extends [true] ? [HasCharacters<`${T}`, ".">] extends [true] ? false : true : boolean : false;
 
-/**
- * **IsLength**`<T, LEN>`
- *
- * Boolean type utility which returns true/false based on whether
- * the correct length for `T` is specified.
- */
-type IsLength<T, LEN extends number> = T extends readonly unknown[] ? IfEqual<Length<T>, LEN, true, false> : false;
-
 type Calc$2<A extends number, B extends number, Count extends 1[] = []> = Count["length"] extends B ? false : Count["length"] extends A ? true : Calc$2<A, B, [...Count, 1]>;
 /**
  * **IsLessThan**`<A,B>`
@@ -1289,6 +1281,14 @@ type IsUndefined<T> = T extends undefined ? true : false;
  */
 type IsUnionArray<T> = T extends readonly any[] ? IsEqual<T["length"], number> extends true ? IsUnion<ElementOf<T>> extends true ? true : false : false : false;
 
+/**
+ * **IsUnset**`<T>`
+ *
+ * Boolean operator which reports true/false on whether
+ * `T` is the value `Unset`.
+ */
+type IsUnset<T> = IsEqual<T, Unset>;
+
 type HasUrlPath<T extends string> = And<[
     Not<IsNever<GetUrlPath<T>>>,
     Or<[
@@ -4377,6 +4377,18 @@ declare const WALGREENS_DNS: readonly ["www.walgreens.com"];
 declare const CVS_DNS: readonly ["www.cvs.com"];
 declare const WHOLE_FOODS_DNS: readonly ["www.wholefoodsmarket.com", "www.wholefoodsmarket.co.uk"];
 
+declare const SIMPLE_DICT_VALUES: readonly ["string", "number", "boolean", "unknown", "Opt<string>", "Opt<number>", "Opt<boolean>", "Opt<unknown>"];
+declare const SIMPLE_SET_TYPES: readonly ["string", "number", "boolean", "unknown", "Opt<string>", "Opt<number>", "Opt<boolean>", "Opt<unknown>"];
+declare const SIMPLE_SCALAR_TOKENS: readonly ["string", "number", `string(${string})`, `number(${number})` | `number(${number},${string})`, "boolean", "true", "false", "null", "undefined", "unknown", "any", "never"];
+declare const SIMPLE_OPT_SCALAR_TOKENS: readonly ["Opt<string>", "Opt<number>", "Opt<boolean>", "Opt<true>", "Opt<false>", "Opt<null>", "Opt<undefined>", "Opt<unknown>", "Opt<any>", `Opt<string(${string})>` | `Opt<string(${string},${string})>`, `Opt<number(${number})` | `Opt<number(${number},${string})`, "Opt<undefined>"];
+declare const SIMPLE_UNION_TOKENS: readonly [`union(${string})` | `union(${string},${string})`];
+declare const SIMPLE_MAP_KEYS: readonly ["string", "number", "Dict", "Dict<string, string>", "Dict<string, number>", "Dict<string, boolean>", "Dict<string, unknown>", "Dict<string, Opt<string>>", "Dict<string, Opt<number>>", "Dict<string, Opt<boolean>>"];
+declare const SIMPLE_MAP_VALUES: readonly ["string", "number", "Dict", "Dict<string, string>", "Dict<string, number>", "Dict<string, boolean>", "Dict<string, unknown>", "Dict<string, Opt<string>>", "Dict<string, Opt<number>>", "Dict<string, Opt<boolean>>", "boolean", "unknown", "undefined", "Dict", "Array", "Dict<string, Opt<string>>", "Dict<string, Opt<number>>", "Dict<string, Opt<boolean>>", "Dict<string, Opt<unknown>>"];
+declare const SIMPLE_DICT_TOKENS: readonly ["Dict", "Dict<string, string>", "Dict<string, number>", "Dict<string, boolean>", "Dict<string, unknown>", "Dict<string, Opt<string>>", "Dict<string, Opt<number>>", "Dict<string, Opt<boolean>>", "Dict<string, Opt<unknown>>", `Dict<{${string}: string}>` | `Dict<{${string}: number}>` | `Dict<{${string}: boolean}>` | `Dict<{${string}: undefined}>` | `Dict<{${string}: never}>` | `Dict<{${string}: unknown}>` | `Dict<{${string}: null}>` | `Dict<{${string}: Opt<string>}>` | `Dict<{${string}: Opt<number>}>` | `Dict<{${string}: Opt<boolean>}>` | `Dict<{${string}: Opt<unknown>}>` | `Dict<{${string}: string(${string})}>` | `Dict<{${string}: number(${number})}>` | `Dict<{${string}: number(${number},${string})}>` | `Dict<{${string}: true}>` | `Dict<{${string}: false}>` | `Dict<{${string}: any}>` | `Dict<{${string}: Opt<true>}>` | `Dict<{${string}: Opt<false>}>` | `Dict<{${string}: Opt<null>}>` | `Dict<{${string}: Opt<undefined>}>` | `Dict<{${string}: Opt<any>}>` | `Dict<{${string}: Opt<string(${string})>}>` | `Dict<{${string}: Opt<string(${string},${string})>}>` | `Dict<{${string}: Opt<number(${number})}>` | `Dict<{${string}: Opt<number(${number},${string})}>`, `Dict<{${string}: string, ${string}: ${string}}` | `Dict<{${string}: number, ${string}: ${string}}` | `Dict<{${string}: boolean, ${string}: ${string}}` | `Dict<{${string}: undefined, ${string}: ${string}}` | `Dict<{${string}: never, ${string}: ${string}}` | `Dict<{${string}: unknown, ${string}: ${string}}` | `Dict<{${string}: null, ${string}: ${string}}` | `Dict<{${string}: Opt<string>, ${string}: ${string}}` | `Dict<{${string}: Opt<number>, ${string}: ${string}}` | `Dict<{${string}: Opt<boolean>, ${string}: ${string}}` | `Dict<{${string}: Opt<unknown>, ${string}: ${string}}` | `Dict<{${string}: string(${string}), ${string}: ${string}}` | `Dict<{${string}: number(${number}), ${string}: ${string}}` | `Dict<{${string}: number(${number},${string}), ${string}: ${string}}` | `Dict<{${string}: true, ${string}: ${string}}` | `Dict<{${string}: false, ${string}: ${string}}` | `Dict<{${string}: any, ${string}: ${string}}` | `Dict<{${string}: Opt<true>, ${string}: ${string}}` | `Dict<{${string}: Opt<false>, ${string}: ${string}}` | `Dict<{${string}: Opt<null>, ${string}: ${string}}` | `Dict<{${string}: Opt<undefined>, ${string}: ${string}}` | `Dict<{${string}: Opt<any>, ${string}: ${string}}` | `Dict<{${string}: Opt<string(${string})>, ${string}: ${string}}` | `Dict<{${string}: Opt<string(${string},${string})>, ${string}: ${string}}` | `Dict<{${string}: Opt<number(${number}), ${string}: ${string}}` | `Dict<{${string}: Opt<number(${number},${string}), ${string}: ${string}}`];
+declare const SIMPLE_ARRAY_TOKENS: readonly ["Array", "Array<string>", `Array<string(${string})>`, "Array<number>", `Array<number(${number})>` | `Array<number(${number},${string})>`, "Array<boolean>", "Array<unknown>", "Array<Dict>", "Array<Set>", "Array<Map>"];
+declare const SIMPLE_MAP_TOKENS: readonly ["Map", "Map<string, string>" | "Map<string, number>" | "Map<string, boolean>" | "Map<string, undefined>" | "Map<string, unknown>" | "Map<string, Dict>" | "Map<string, Dict<string, string>>" | "Map<string, Dict<string, number>>" | "Map<string, Dict<string, boolean>>" | "Map<string, Dict<string, unknown>>" | "Map<string, Dict<string, Opt<string>>>" | "Map<string, Dict<string, Opt<number>>>" | "Map<string, Dict<string, Opt<boolean>>>" | "Map<string, Array>" | "Map<string, Dict<string, Opt<unknown>>>" | "Map<number, string>" | "Map<number, number>" | "Map<number, boolean>" | "Map<number, undefined>" | "Map<number, unknown>" | "Map<number, Dict>" | "Map<number, Dict<string, string>>" | "Map<number, Dict<string, number>>" | "Map<number, Dict<string, boolean>>" | "Map<number, Dict<string, unknown>>" | "Map<number, Dict<string, Opt<string>>>" | "Map<number, Dict<string, Opt<number>>>" | "Map<number, Dict<string, Opt<boolean>>>" | "Map<number, Array>" | "Map<number, Dict<string, Opt<unknown>>>" | "Map<Dict, string>" | "Map<Dict, number>" | "Map<Dict, boolean>" | "Map<Dict, undefined>" | "Map<Dict, unknown>" | "Map<Dict, Dict>" | "Map<Dict, Dict<string, string>>" | "Map<Dict, Dict<string, number>>" | "Map<Dict, Dict<string, boolean>>" | "Map<Dict, Dict<string, unknown>>" | "Map<Dict, Dict<string, Opt<string>>>" | "Map<Dict, Dict<string, Opt<number>>>" | "Map<Dict, Dict<string, Opt<boolean>>>" | "Map<Dict, Array>" | "Map<Dict, Dict<string, Opt<unknown>>>" | "Map<Dict<string, string>, string>" | "Map<Dict<string, string>, number>" | "Map<Dict<string, string>, boolean>" | "Map<Dict<string, string>, undefined>" | "Map<Dict<string, string>, unknown>" | "Map<Dict<string, string>, Dict>" | "Map<Dict<string, string>, Dict<string, string>>" | "Map<Dict<string, string>, Dict<string, number>>" | "Map<Dict<string, string>, Dict<string, boolean>>" | "Map<Dict<string, string>, Dict<string, unknown>>" | "Map<Dict<string, string>, Dict<string, Opt<string>>>" | "Map<Dict<string, string>, Dict<string, Opt<number>>>" | "Map<Dict<string, string>, Dict<string, Opt<boolean>>>" | "Map<Dict<string, string>, Array>" | "Map<Dict<string, string>, Dict<string, Opt<unknown>>>" | "Map<Dict<string, number>, string>" | "Map<Dict<string, number>, number>" | "Map<Dict<string, number>, boolean>" | "Map<Dict<string, number>, undefined>" | "Map<Dict<string, number>, unknown>" | "Map<Dict<string, number>, Dict>" | "Map<Dict<string, number>, Dict<string, string>>" | "Map<Dict<string, number>, Dict<string, number>>" | "Map<Dict<string, number>, Dict<string, boolean>>" | "Map<Dict<string, number>, Dict<string, unknown>>" | "Map<Dict<string, number>, Dict<string, Opt<string>>>" | "Map<Dict<string, number>, Dict<string, Opt<number>>>" | "Map<Dict<string, number>, Dict<string, Opt<boolean>>>" | "Map<Dict<string, number>, Array>" | "Map<Dict<string, number>, Dict<string, Opt<unknown>>>" | "Map<Dict<string, boolean>, string>" | "Map<Dict<string, boolean>, number>" | "Map<Dict<string, boolean>, boolean>" | "Map<Dict<string, boolean>, undefined>" | "Map<Dict<string, boolean>, unknown>" | "Map<Dict<string, boolean>, Dict>" | "Map<Dict<string, boolean>, Dict<string, string>>" | "Map<Dict<string, boolean>, Dict<string, number>>" | "Map<Dict<string, boolean>, Dict<string, boolean>>" | "Map<Dict<string, boolean>, Dict<string, unknown>>" | "Map<Dict<string, boolean>, Dict<string, Opt<string>>>" | "Map<Dict<string, boolean>, Dict<string, Opt<number>>>" | "Map<Dict<string, boolean>, Dict<string, Opt<boolean>>>" | "Map<Dict<string, boolean>, Array>" | "Map<Dict<string, boolean>, Dict<string, Opt<unknown>>>" | "Map<Dict<string, unknown>, string>" | "Map<Dict<string, unknown>, number>" | "Map<Dict<string, unknown>, boolean>" | "Map<Dict<string, unknown>, undefined>" | "Map<Dict<string, unknown>, unknown>" | "Map<Dict<string, unknown>, Dict>" | "Map<Dict<string, unknown>, Dict<string, string>>" | "Map<Dict<string, unknown>, Dict<string, number>>" | "Map<Dict<string, unknown>, Dict<string, boolean>>" | "Map<Dict<string, unknown>, Dict<string, unknown>>" | "Map<Dict<string, unknown>, Dict<string, Opt<string>>>" | "Map<Dict<string, unknown>, Dict<string, Opt<number>>>" | "Map<Dict<string, unknown>, Dict<string, Opt<boolean>>>" | "Map<Dict<string, unknown>, Array>" | "Map<Dict<string, unknown>, Dict<string, Opt<unknown>>>" | "Map<Dict<string, Opt<string>>, string>" | "Map<Dict<string, Opt<string>>, number>" | "Map<Dict<string, Opt<string>>, boolean>" | "Map<Dict<string, Opt<string>>, undefined>" | "Map<Dict<string, Opt<string>>, unknown>" | "Map<Dict<string, Opt<string>>, Dict>" | "Map<Dict<string, Opt<string>>, Dict<string, string>>" | "Map<Dict<string, Opt<string>>, Dict<string, number>>" | "Map<Dict<string, Opt<string>>, Dict<string, boolean>>" | "Map<Dict<string, Opt<string>>, Dict<string, unknown>>" | "Map<Dict<string, Opt<string>>, Dict<string, Opt<string>>>" | "Map<Dict<string, Opt<string>>, Dict<string, Opt<number>>>" | "Map<Dict<string, Opt<string>>, Dict<string, Opt<boolean>>>" | "Map<Dict<string, Opt<string>>, Array>" | "Map<Dict<string, Opt<string>>, Dict<string, Opt<unknown>>>" | "Map<Dict<string, Opt<number>>, string>" | "Map<Dict<string, Opt<number>>, number>" | "Map<Dict<string, Opt<number>>, boolean>" | "Map<Dict<string, Opt<number>>, undefined>" | "Map<Dict<string, Opt<number>>, unknown>" | "Map<Dict<string, Opt<number>>, Dict>" | "Map<Dict<string, Opt<number>>, Dict<string, string>>" | "Map<Dict<string, Opt<number>>, Dict<string, number>>" | "Map<Dict<string, Opt<number>>, Dict<string, boolean>>" | "Map<Dict<string, Opt<number>>, Dict<string, unknown>>" | "Map<Dict<string, Opt<number>>, Dict<string, Opt<string>>>" | "Map<Dict<string, Opt<number>>, Dict<string, Opt<number>>>" | "Map<Dict<string, Opt<number>>, Dict<string, Opt<boolean>>>" | "Map<Dict<string, Opt<number>>, Array>" | "Map<Dict<string, Opt<number>>, Dict<string, Opt<unknown>>>" | "Map<Dict<string, Opt<boolean>>, string>" | "Map<Dict<string, Opt<boolean>>, number>" | "Map<Dict<string, Opt<boolean>>, boolean>" | "Map<Dict<string, Opt<boolean>>, undefined>" | "Map<Dict<string, Opt<boolean>>, unknown>" | "Map<Dict<string, Opt<boolean>>, Dict>" | "Map<Dict<string, Opt<boolean>>, Dict<string, string>>" | "Map<Dict<string, Opt<boolean>>, Dict<string, number>>" | "Map<Dict<string, Opt<boolean>>, Dict<string, boolean>>" | "Map<Dict<string, Opt<boolean>>, Dict<string, unknown>>" | "Map<Dict<string, Opt<boolean>>, Dict<string, Opt<string>>>" | "Map<Dict<string, Opt<boolean>>, Dict<string, Opt<number>>>" | "Map<Dict<string, Opt<boolean>>, Dict<string, Opt<boolean>>>" | "Map<Dict<string, Opt<boolean>>, Array>" | "Map<Dict<string, Opt<boolean>>, Dict<string, Opt<unknown>>>", "WeakMap"];
+declare const SIMPLE_SET_TOKENS: readonly ["Set", "Set<string>" | "Set<number>" | "Set<boolean>" | "Set<unknown>" | "Set<Opt<string>>" | "Set<Opt<number>>" | "Set<Opt<boolean>>" | "Set<Opt<unknown>>"];
+
 declare const SOCIAL_MEDIA: [{
     readonly name: "Facebook";
     readonly description: "Connect with friends, family, and communities worldwide on one of the largest social networks.";
@@ -4597,39 +4609,34 @@ declare const TW_MODIFIERS_SIZING: readonly ["sm", "md", "lg", "xl", "2xl"];
  */
 declare const TYPE_OF: readonly ["string", "number", "boolean", "undefined", "symbol", "bigint", "function", "object"];
 
-declare const SIMPLE_DICT_VALUES: readonly ["string", "number", "boolean", "unknown", "Opt<string>", "Opt<number>", "Opt<boolean>", "Opt<unknown>"];
-declare const SIMPLE_SET_TYPES: readonly ["string", "number", "boolean", "unknown", "Opt<string>", "Opt<number>", "Opt<boolean>", "Opt<unknown>"];
-declare const SIMPLE_SCALAR_TOKENS: readonly ["string", "number", `string(${string})`, `number(${number})` | `number(${number},${string})`, "boolean", "true", "false", "null", "undefined", "unknown", "any", "never"];
-declare const SIMPLE_OPT_SCALAR_TOKENS: readonly ["Opt<string>", "Opt<number>", "Opt<boolean>", "Opt<true>", "Opt<false>", "Opt<null>", "Opt<undefined>", "Opt<unknown>", "Opt<any>", `Opt<string(${string})>` | `Opt<string(${string},${string})>`, `Opt<number(${number})` | `Opt<number(${number},${string})`, "Opt<undefined>"];
-declare const SIMPLE_UNION_TOKENS: readonly [`union(${string})` | `union(${string},${string})`];
-declare const SIMPLE_MAP_KEYS: readonly ["string", "number", "Dict", "Dict<string, string>", "Dict<string, number>", "Dict<string, boolean>", "Dict<string, unknown>", "Dict<string, Opt<string>>", "Dict<string, Opt<number>>", "Dict<string, Opt<boolean>>"];
-declare const SIMPLE_MAP_VALUES: readonly ["string", "number", "Dict", "Dict<string, string>", "Dict<string, number>", "Dict<string, boolean>", "Dict<string, unknown>", "Dict<string, Opt<string>>", "Dict<string, Opt<number>>", "Dict<string, Opt<boolean>>", "boolean", "unknown", "undefined", "Dict", "Array", "Dict<string, Opt<string>>", "Dict<string, Opt<number>>", "Dict<string, Opt<boolean>>", "Dict<string, Opt<unknown>>"];
-declare const SIMPLE_DICT_TOKENS: readonly ["Dict", "Dict<string, string>", "Dict<string, number>", "Dict<string, boolean>", "Dict<string, unknown>", "Dict<string, Opt<string>>", "Dict<string, Opt<number>>", "Dict<string, Opt<boolean>>", "Dict<string, Opt<unknown>>", `Dict<{${string}: string}>` | `Dict<{${string}: number}>` | `Dict<{${string}: boolean}>` | `Dict<{${string}: undefined}>` | `Dict<{${string}: never}>` | `Dict<{${string}: unknown}>` | `Dict<{${string}: null}>` | `Dict<{${string}: true}>` | `Dict<{${string}: false}>` | `Dict<{${string}: Opt<string>}>` | `Dict<{${string}: Opt<number>}>` | `Dict<{${string}: Opt<boolean>}>` | `Dict<{${string}: Opt<unknown>}>` | `Dict<{${string}: string(${string})}>` | `Dict<{${string}: number(${number})}>` | `Dict<{${string}: number(${number},${string})}>` | `Dict<{${string}: any}>` | `Dict<{${string}: Opt<true>}>` | `Dict<{${string}: Opt<false>}>` | `Dict<{${string}: Opt<null>}>` | `Dict<{${string}: Opt<undefined>}>` | `Dict<{${string}: Opt<any>}>` | `Dict<{${string}: Opt<string(${string})>}>` | `Dict<{${string}: Opt<string(${string},${string})>}>` | `Dict<{${string}: Opt<number(${number})}>` | `Dict<{${string}: Opt<number(${number},${string})}>`, `Dict<{${string}: string, ${string}: ${string}}` | `Dict<{${string}: number, ${string}: ${string}}` | `Dict<{${string}: boolean, ${string}: ${string}}` | `Dict<{${string}: undefined, ${string}: ${string}}` | `Dict<{${string}: never, ${string}: ${string}}` | `Dict<{${string}: unknown, ${string}: ${string}}` | `Dict<{${string}: null, ${string}: ${string}}` | `Dict<{${string}: true, ${string}: ${string}}` | `Dict<{${string}: false, ${string}: ${string}}` | `Dict<{${string}: Opt<string>, ${string}: ${string}}` | `Dict<{${string}: Opt<number>, ${string}: ${string}}` | `Dict<{${string}: Opt<boolean>, ${string}: ${string}}` | `Dict<{${string}: Opt<unknown>, ${string}: ${string}}` | `Dict<{${string}: string(${string}), ${string}: ${string}}` | `Dict<{${string}: number(${number}), ${string}: ${string}}` | `Dict<{${string}: number(${number},${string}), ${string}: ${string}}` | `Dict<{${string}: any, ${string}: ${string}}` | `Dict<{${string}: Opt<true>, ${string}: ${string}}` | `Dict<{${string}: Opt<false>, ${string}: ${string}}` | `Dict<{${string}: Opt<null>, ${string}: ${string}}` | `Dict<{${string}: Opt<undefined>, ${string}: ${string}}` | `Dict<{${string}: Opt<any>, ${string}: ${string}}` | `Dict<{${string}: Opt<string(${string})>, ${string}: ${string}}` | `Dict<{${string}: Opt<string(${string},${string})>, ${string}: ${string}}` | `Dict<{${string}: Opt<number(${number}), ${string}: ${string}}` | `Dict<{${string}: Opt<number(${number},${string}), ${string}: ${string}}`];
-declare const SIMPLE_ARRAY_TOKENS: readonly ["Array", "Array<string>", `Array<string(${string})>`, "Array<number>", `Array<number(${number})>` | `Array<number(${number},${string})>`, "Array<boolean>", "Array<unknown>", "Array<Dict>", "Array<Set>", "Array<Map>"];
-declare const SIMPLE_MAP_TOKENS: readonly ["Map", "Map<string, string>" | "Map<string, number>" | "Map<string, boolean>" | "Map<string, undefined>" | "Map<string, unknown>" | "Map<string, Dict>" | "Map<string, Dict<string, string>>" | "Map<string, Dict<string, number>>" | "Map<string, Dict<string, boolean>>" | "Map<string, Dict<string, unknown>>" | "Map<string, Dict<string, Opt<string>>>" | "Map<string, Dict<string, Opt<number>>>" | "Map<string, Dict<string, Opt<boolean>>>" | "Map<string, Array>" | "Map<string, Dict<string, Opt<unknown>>>" | "Map<number, string>" | "Map<number, number>" | "Map<number, boolean>" | "Map<number, undefined>" | "Map<number, unknown>" | "Map<number, Dict>" | "Map<number, Dict<string, string>>" | "Map<number, Dict<string, number>>" | "Map<number, Dict<string, boolean>>" | "Map<number, Dict<string, unknown>>" | "Map<number, Dict<string, Opt<string>>>" | "Map<number, Dict<string, Opt<number>>>" | "Map<number, Dict<string, Opt<boolean>>>" | "Map<number, Array>" | "Map<number, Dict<string, Opt<unknown>>>" | "Map<Dict, string>" | "Map<Dict, number>" | "Map<Dict, boolean>" | "Map<Dict, undefined>" | "Map<Dict, unknown>" | "Map<Dict, Dict>" | "Map<Dict, Dict<string, string>>" | "Map<Dict, Dict<string, number>>" | "Map<Dict, Dict<string, boolean>>" | "Map<Dict, Dict<string, unknown>>" | "Map<Dict, Dict<string, Opt<string>>>" | "Map<Dict, Dict<string, Opt<number>>>" | "Map<Dict, Dict<string, Opt<boolean>>>" | "Map<Dict, Array>" | "Map<Dict, Dict<string, Opt<unknown>>>" | "Map<Dict<string, string>, string>" | "Map<Dict<string, string>, number>" | "Map<Dict<string, string>, boolean>" | "Map<Dict<string, string>, undefined>" | "Map<Dict<string, string>, unknown>" | "Map<Dict<string, string>, Dict>" | "Map<Dict<string, string>, Dict<string, string>>" | "Map<Dict<string, string>, Dict<string, number>>" | "Map<Dict<string, string>, Dict<string, boolean>>" | "Map<Dict<string, string>, Dict<string, unknown>>" | "Map<Dict<string, string>, Dict<string, Opt<string>>>" | "Map<Dict<string, string>, Dict<string, Opt<number>>>" | "Map<Dict<string, string>, Dict<string, Opt<boolean>>>" | "Map<Dict<string, string>, Array>" | "Map<Dict<string, string>, Dict<string, Opt<unknown>>>" | "Map<Dict<string, number>, string>" | "Map<Dict<string, number>, number>" | "Map<Dict<string, number>, boolean>" | "Map<Dict<string, number>, undefined>" | "Map<Dict<string, number>, unknown>" | "Map<Dict<string, number>, Dict>" | "Map<Dict<string, number>, Dict<string, string>>" | "Map<Dict<string, number>, Dict<string, number>>" | "Map<Dict<string, number>, Dict<string, boolean>>" | "Map<Dict<string, number>, Dict<string, unknown>>" | "Map<Dict<string, number>, Dict<string, Opt<string>>>" | "Map<Dict<string, number>, Dict<string, Opt<number>>>" | "Map<Dict<string, number>, Dict<string, Opt<boolean>>>" | "Map<Dict<string, number>, Array>" | "Map<Dict<string, number>, Dict<string, Opt<unknown>>>" | "Map<Dict<string, boolean>, string>" | "Map<Dict<string, boolean>, number>" | "Map<Dict<string, boolean>, boolean>" | "Map<Dict<string, boolean>, undefined>" | "Map<Dict<string, boolean>, unknown>" | "Map<Dict<string, boolean>, Dict>" | "Map<Dict<string, boolean>, Dict<string, string>>" | "Map<Dict<string, boolean>, Dict<string, number>>" | "Map<Dict<string, boolean>, Dict<string, boolean>>" | "Map<Dict<string, boolean>, Dict<string, unknown>>" | "Map<Dict<string, boolean>, Dict<string, Opt<string>>>" | "Map<Dict<string, boolean>, Dict<string, Opt<number>>>" | "Map<Dict<string, boolean>, Dict<string, Opt<boolean>>>" | "Map<Dict<string, boolean>, Array>" | "Map<Dict<string, boolean>, Dict<string, Opt<unknown>>>" | "Map<Dict<string, unknown>, string>" | "Map<Dict<string, unknown>, number>" | "Map<Dict<string, unknown>, boolean>" | "Map<Dict<string, unknown>, undefined>" | "Map<Dict<string, unknown>, unknown>" | "Map<Dict<string, unknown>, Dict>" | "Map<Dict<string, unknown>, Dict<string, string>>" | "Map<Dict<string, unknown>, Dict<string, number>>" | "Map<Dict<string, unknown>, Dict<string, boolean>>" | "Map<Dict<string, unknown>, Dict<string, unknown>>" | "Map<Dict<string, unknown>, Dict<string, Opt<string>>>" | "Map<Dict<string, unknown>, Dict<string, Opt<number>>>" | "Map<Dict<string, unknown>, Dict<string, Opt<boolean>>>" | "Map<Dict<string, unknown>, Array>" | "Map<Dict<string, unknown>, Dict<string, Opt<unknown>>>" | "Map<Dict<string, Opt<string>>, string>" | "Map<Dict<string, Opt<string>>, number>" | "Map<Dict<string, Opt<string>>, boolean>" | "Map<Dict<string, Opt<string>>, undefined>" | "Map<Dict<string, Opt<string>>, unknown>" | "Map<Dict<string, Opt<string>>, Dict>" | "Map<Dict<string, Opt<string>>, Dict<string, string>>" | "Map<Dict<string, Opt<string>>, Dict<string, number>>" | "Map<Dict<string, Opt<string>>, Dict<string, boolean>>" | "Map<Dict<string, Opt<string>>, Dict<string, unknown>>" | "Map<Dict<string, Opt<string>>, Dict<string, Opt<string>>>" | "Map<Dict<string, Opt<string>>, Dict<string, Opt<number>>>" | "Map<Dict<string, Opt<string>>, Dict<string, Opt<boolean>>>" | "Map<Dict<string, Opt<string>>, Array>" | "Map<Dict<string, Opt<string>>, Dict<string, Opt<unknown>>>" | "Map<Dict<string, Opt<number>>, string>" | "Map<Dict<string, Opt<number>>, number>" | "Map<Dict<string, Opt<number>>, boolean>" | "Map<Dict<string, Opt<number>>, undefined>" | "Map<Dict<string, Opt<number>>, unknown>" | "Map<Dict<string, Opt<number>>, Dict>" | "Map<Dict<string, Opt<number>>, Dict<string, string>>" | "Map<Dict<string, Opt<number>>, Dict<string, number>>" | "Map<Dict<string, Opt<number>>, Dict<string, boolean>>" | "Map<Dict<string, Opt<number>>, Dict<string, unknown>>" | "Map<Dict<string, Opt<number>>, Dict<string, Opt<string>>>" | "Map<Dict<string, Opt<number>>, Dict<string, Opt<number>>>" | "Map<Dict<string, Opt<number>>, Dict<string, Opt<boolean>>>" | "Map<Dict<string, Opt<number>>, Array>" | "Map<Dict<string, Opt<number>>, Dict<string, Opt<unknown>>>" | "Map<Dict<string, Opt<boolean>>, string>" | "Map<Dict<string, Opt<boolean>>, number>" | "Map<Dict<string, Opt<boolean>>, boolean>" | "Map<Dict<string, Opt<boolean>>, undefined>" | "Map<Dict<string, Opt<boolean>>, unknown>" | "Map<Dict<string, Opt<boolean>>, Dict>" | "Map<Dict<string, Opt<boolean>>, Dict<string, string>>" | "Map<Dict<string, Opt<boolean>>, Dict<string, number>>" | "Map<Dict<string, Opt<boolean>>, Dict<string, boolean>>" | "Map<Dict<string, Opt<boolean>>, Dict<string, unknown>>" | "Map<Dict<string, Opt<boolean>>, Dict<string, Opt<string>>>" | "Map<Dict<string, Opt<boolean>>, Dict<string, Opt<number>>>" | "Map<Dict<string, Opt<boolean>>, Dict<string, Opt<boolean>>>" | "Map<Dict<string, Opt<boolean>>, Array>" | "Map<Dict<string, Opt<boolean>>, Dict<string, Opt<unknown>>>", "WeakMap"];
-declare const SIMPLE_SET_TOKENS: readonly ["Set", "Set<string>" | "Set<number>" | "Set<boolean>" | "Set<unknown>" | "Set<Opt<string>>" | "Set<Opt<number>>" | "Set<Opt<boolean>>" | "Set<Opt<unknown>>"];
 /**
  * **Type Tokens** which have zero configuration elements.
  */
-declare const TT_Atomics: readonly ["undefined", "null", "boolean", "true", "false"];
+declare const TT_ATOMICS: readonly ["undefined", "null", "boolean", "true", "false"];
 /**
  * **Type Tokens** which have a literal variant which represents
  * the _single_ configuration of this type which is available.
  */
-declare const TT_Singletons: readonly ["string", "number"];
-declare const TT_Sets: readonly ["string-set", "numeric-set", "union-set"];
+declare const TT_SINGLETONS: readonly ["string", "number"];
+declare const TT_SETS: readonly ["string-set", "numeric-set", "fn-set", "union-set"];
 /**
  * **Type Tokens** which represent _functions_ (either the typical
  * variety or Generator functions).
  */
-declare const TT_Functions: readonly ["fn", "gen"];
+declare const TT_FUNCTIONS: readonly ["fn", "gen"];
 /**
  * **Type Tokens** which _contain_ other **Type Tokens** to make up their
  * identity.
  */
-declare const TT_Containers: readonly ["rec", "arr", "set", "map", "union", "obj", "tuple"];
+declare const TT_CONTAINERS: readonly ["rec", "arr", "set", "map", "union", "obj", "tuple"];
 declare const TT_START: "<<";
 declare const TT_STOP: ">>";
+declare const TT_DELIMITER: "::";
+
+declare const TYPE_TOKEN_REC_VARIANTS: readonly ["object-key", "string-key"];
+declare const TYPE_TOKEN_REC_KEY_VARIANTS: readonly ["unknown", "any", "string", "number", "boolean", "truthy", "numberlike", "scalar", "object", "string|undefined", "number|undefined", "boolean|undefined", "object|undefined", "unknown[]", "any[]", "string[]", "number[]", "boolean[]"];
+declare const TYPE_TOKEN_STRING_SET_VARIANTS: readonly ["endsWith::${string}", "startsWith::${string}", "contains::${string}", "civilianTime", "militaryTime", "ipv4Address", "ipv4Address::tight", "ipv4Address::loose", "ipv6Address", "ipv6Address::${string}", "numericString", "zipCode5", "zipCode5+4", "countryCode2", "countryCode3", "countryName", "capitalized", "url", "url::${string}", "isoDate", "isoDateTime", "usStateAbbrev", "usCitySuggestions", "metricCategory", "metric", "metric::${Metric}"];
+declare const TYPE_TOKEN_UNION_SET_VARIANTS: string[];
 
 interface OnPassRemap<TNever = unknown, TFalse = unknown, TError = unknown> {
     never: TNever;
@@ -4948,9 +4955,9 @@ type PreProcess$2<A extends NumberLike, B extends NumberLike> = CheckWide<A, B>
  */
 type Add<A extends NumberLike, B extends NumberLike> = A extends number ? As<PreProcess$2<A, B>, number> : A extends `${number}` ? As<PreProcess$2<A, B>, `${number}`> : never;
 
-type Convert$2<T> = T extends `${number}` ? ToNumber<T> : T;
+type Convert$3<T> = T extends `${number}` ? ToNumber<T> : T;
 type ConvertTuple<T> = T extends unknown[] ? {
-    [K in keyof T]: Convert$2<T[K]>;
+    [K in keyof T]: Convert$3<T[K]>;
 } : never;
 type ConvertUnion$1<T> = If<IsUnion<T>, TupleToUnion<ConvertTuple<UnionToTuple$1<T>>>, never>;
 /**
@@ -4966,7 +4973,7 @@ type ConvertUnion$1<T> = If<IsUnion<T>, TupleToUnion<ConvertTuple<UnionToTuple$1
  * literal values will be converted to a numeric literal but the return type will
  * still be a _union_.
  */
-type AsNumberWhenPossible<T> = If<IsUnion<T>, ConvertUnion$1<T>, T extends readonly unknown[] ? ConvertTuple<T> : Convert$2<T>>;
+type AsNumberWhenPossible<T> = If<IsUnion<T>, ConvertUnion$1<T>, T extends readonly unknown[] ? ConvertTuple<T> : Convert$3<T>>;
 
 /**
  * **AsBoolean**`<T>`
@@ -4976,8 +4983,6 @@ type AsNumberWhenPossible<T> = If<IsUnion<T>, ConvertUnion$1<T>, T extends reado
  */
 type AsBoolean<T> = T extends boolean ? T : T extends "true" ? true : T extends "false" ? false : T extends "boolean" ? boolean : never;
 
-type AsDictionary<T> = T extends Dictionary ? T : never;
-
 interface TypeErrorInfo<TContext extends Record<string, unknown> = EmptyObject> {
     /**
      * if there is a particular "id" value which is useful to separate from the error message
@@ -5293,7 +5298,7 @@ type KebabCase<TString extends string, TPreserve extends boolean = false> = Proc
  */
 type LowerAllCaps<T extends string> = IsAllCaps<T> extends true ? Lowercase<T> : T;
 
-type Delimiter = "_" | "-" | " ";
+type Delimiter$1 = "_" | "-" | " ";
 /** convert all delimiters to dashes */
 type DashDelim<T extends string> = T extends `${infer Begin}${" "}${infer Rest}` ? DashDelim<`${Begin}-${Rest}`> : T extends `${infer Begin}${"_"}${infer Rest}` ? DashDelim<`${Begin}-${Rest}`> : T;
 /**
@@ -5306,7 +5311,7 @@ type DashDelim<T extends string> = T extends `${infer Begin}${" "}${infer Rest}`
  * type T = PascalCase<"\n foo_bar \t">;
  * ```
  */
-type PascalCase<S extends string> = string extends S ? string : Trim<DashDelim<LowerAllCaps<S>>> extends `${infer Begin}${Delimiter}${infer Rest}` ? PascalCase<`${Capitalize<Begin>}${Capitalize<Rest>}`> : Capitalize<Trim<LowerAllCaps<S>>>;
+type PascalCase<S extends string> = string extends S ? string : Trim<DashDelim<LowerAllCaps<S>>> extends `${infer Begin}${Delimiter$1}${infer Rest}` ? PascalCase<`${Capitalize<Begin>}${Capitalize<Rest>}`> : Capitalize<Trim<LowerAllCaps<S>>>;
 
 /** convert space to dash */
 type SpaceToDash<T extends string> = T extends `${infer Begin}${" "}${infer Rest}` ? SpaceToDash<`${Begin}-${Rest}`> : T;
@@ -7904,6 +7909,7 @@ type Volume = `${number}${OptSpace}${VolumeUom}`;
  * **Related:** `Uom`
  */
 type Metric = Acceleration | Area | Current | Distance | Frequency | Luminosity | Mass | Power | Pressure | Resistance | Speed | Temperature | TimeMetric | Voltage | Volume;
+type MetricCategory = "Acceleration" | "Area" | "Current" | "Distance" | "Frequency" | "Luminosity" | "Mass" | "Power" | "Pressure" | "Resistance" | "Speed" | "Temperature" | "Time" | "Voltage" | "Volume";
 /**
  * **Uom**
  *
@@ -9923,7 +9929,6 @@ interface LuxonJs {
     };
 }
 
-type HandleObject<TObj extends Dictionary, TKeys extends readonly unknown[], TResult extends Dictionary = EmptyObject> = [] extends TKeys ? ExpandDictionary<TResult> : HandleObject<TObj, AfterFirst<TKeys>, First<TKeys> extends keyof TObj ? TObj[First<TKeys>] extends ShapeCallback ? Record<First<TKeys>, HandleDoneFn<ReturnType<TObj[First<TKeys>]>>> & TResult : TObj[First<TKeys>] extends SimpleToken ? Record<First<TKeys>, AsType<TObj[First<TKeys>]>> & TResult : Record<First<TKeys>, TObj[First<TKeys>]> & TResult : never>;
 type ProcessUnion<T extends UnionElDefn> = T extends Tuple ? TupleToUnion<T> : T extends ShapeCallback ? HandleDoneFn<ReturnType<T>> : never;
 type IterateUnion<T extends readonly UnionElDefn[]> = {
     [K in keyof T]: ProcessUnion<T[K]>;
@@ -9935,11 +9940,10 @@ type IterateUnion<T extends readonly UnionElDefn[]> = {
  * and makes this into _union type_.
  */
 type AsUnion<T extends UnionElDefn | readonly [UnionElDefn, ...UnionElDefn[]]> = T extends UnionElDefn[] ? TupleToUnion<IterateUnion<T>> : T extends UnionElDefn ? ProcessUnion<T> : never;
-type IsDictionaryDefinition<T> = T extends Dictionary ? Contains<Values<T>, ShapeCallback> : false;
 /**
  * converts non-tuple definition types to actual type
  */
-type ToType$1<T, TElse> = [T] extends [ShapeCallback] ? HandleDoneFn<ReturnType<T>> : [IsDictionaryDefinition<T>] extends [true] ? HandleObject<AsDictionary<T>, Keys<AsDictionary<T>>> : T extends SimpleToken ? AsType<T> : IsEqual<TElse, Constant$1<"not-set">> extends true ? T : TElse extends SimpleToken ? AsType<TElse> : TElse;
+type ToType$1<T, TElse> = T extends ShapeCallback ? FromShapeCallback<T> : T extends SimpleToken ? FromSimpleToken<T> : T extends RecordKeyWideTokens ? FromSimpleRecordKey<T> : T extends WideTokenNames | WideContainerNames ? FromWideTokens<T> : T extends RecordKeyWideTokens ? FromSimpleRecordKey<T> : TElse;
 /**
  * iterates over tuple definition types to convert into real types
  */
@@ -9947,8 +9951,16 @@ type IterateOverDefinitions<T extends readonly unknown[], TElse> = {
     [K in keyof T]: ToType$1<T[K], TElse>;
 };
 type TypeDefinition = NarrowableScalar | ShapeCallback;
+/**
+ * converts a `ShapeCallback` into the _type_ which it is defining
+ */
+type FromShapeCallback<TShape extends ShapeCallback, TAsToken extends boolean = false> = TAsToken extends false ? ReturnType<HandleDoneFn<TShape>> : string;
+/**
+ * converts a `SimpleToken` into the _type_ which it is defining
+ */
+type FromSimpleToken<T extends SimpleToken> = SimpleType<T>;
 type _FromDefineObject<T extends Required<DefineObject>> = {
-    [K in keyof T]: T[K] extends SimpleToken ? SimpleType<T[K]> : T[K] extends ShapeCallback ? ReturnType<HandleDoneFn<T[K]>> : never;
+    [K in keyof T]: T[K] extends SimpleToken ? FromSimpleToken<T[K]> : T[K] extends ShapeCallback ? FromShapeCallback<T[K]> : never;
 };
 /**
  * Converts a `DefineObject` definition into the type that it is
@@ -9970,7 +9982,7 @@ type FromDefineObject<T extends DefineObject> = MakeKeysOptional<_FromDefineObje
  * Note: when dictionary objects are found the _values_ will be
  * interrogated for ShapeCallback's.
  */
-type FromDefn$1<T, TElse = Constant$1<"not-set">> = T extends DefineObject ? FromDefineObject<T> : T extends readonly unknown[] ? IterateOverDefinitions<T, TElse> : ToType$1<T, TElse>;
+type FromDefn$1<T, TElse = Unset> = T extends DefineObject ? FromDefineObject<T> : T extends readonly unknown[] ? IterateOverDefinitions<T, TElse> : ToType$1<T, TElse>;
 
 type WideTokenNames = "string" | "number" | "boolean" | "null" | "undefined" | "never" | "unknown" | "string[]" | "number[]" | "boolean[]" | "unknown[]";
 type ConvertWideTokenNames<T extends WideTokenNames> = T extends "string" ? string : T extends "number" ? number : T extends "boolean" ? boolean : T extends "null" ? null : T extends "undefined" ? undefined : T extends "never" ? never : T extends "unknown" ? unknown : T extends "string[]" ? string[] : T extends "number[]" ? number[] : T extends "boolean[]" ? boolean[] : T extends "unknown[]" ? unknown[] : never;
@@ -10366,47 +10378,6 @@ type Process$c<TKeys extends readonly string[], TValue, TObj extends Dictionary
  */
 type CreateKV<TKeys extends readonly string[], TValue = unknown> = ExpandRecursively<Process$c<TKeys, TValue>>;
 
-type SetTypes = typeof SIMPLE_SET_TYPES[number];
-type MapKeys = typeof SIMPLE_MAP_KEYS[number];
-type MapValues = typeof SIMPLE_MAP_VALUES[number];
-type DictValues = typeof SIMPLE_DICT_VALUES[number];
-/**
- * **SimpleTypeScalar**`<T>`
- *
- * Converts a `SimpleScalarToken` into the _type_ it represents.
- */
-type SimpleTypeScalar<T extends SimpleScalarToken> = T extends "string" ? string : T extends `string(${infer Literal})` ? Literal extends `${string},${string}` ? CsvToStrUnion<Literal> : Literal : T extends "number" ? number : T extends `number(${infer Literal})` ? Literal extends `${string},${string}` ? CsvToUnion<Literal> : AsNumber<Literal> : T extends "boolean" ? boolean : T extends "true" ? true : T extends "false" ? false : T extends "null" ? null : T extends "any" ? any : T extends "undefined" ? undefined : T extends "unknown" ? unknown : T extends `Opt<${infer Underlying extends SimpleScalarToken}>` ? undefined | SimpleTypeScalar<Underlying> : never;
-/**
- * **SimpleTypeUnion**`<T>`
- *
- * Converts a `SimpleUnionToken` into the _type_ it represents.
- */
-type SimpleTypeUnion<T extends SimpleUnionToken> = T extends "opt(string)" ? string | undefined : T extends "opt(number)" ? number | undefined : T extends "opt(boolean)" ? boolean | undefined : T extends "opt(unknown)" ? unknown | undefined : T extends `opt(${infer Literal extends string})` ? Literal extends `${string},${string}` ? TupleToUnion<CsvToTuple<Literal>> | undefined : UnderlyingType<Literal> | undefined : T extends `Union(${infer Literal})` ? Literal extends `${string},${string}` ? CsvToTuple<Literal> : Literal : never;
-type SimpleTypeDict<T extends SimpleDictToken> = T extends `Dict` ? Dictionary : T extends `Dict<string, ${infer Value extends DictValues & SimpleScalarToken}>` ? Dictionary<string, SimpleTypeScalar<Value>> : T extends `Dict<{${infer K}: ${infer V}, ${infer K2}: ${infer V2}}>` ? V extends SimpleScalarToken ? V2 extends SimpleScalarToken ? ExpandDictionary<Record<K, SimpleTypeScalar<V>> & Record<K2, SimpleTypeScalar<V2>> & Dictionary> : ExpandDictionary<Record<K, SimpleTypeScalar<V>> & Dictionary> : V2 extends SimpleScalarToken ? ExpandDictionary<Record<K2, SimpleTypeScalar<V2>> & Dictionary> : never : T extends `Dict<{${infer Key}: ${infer Value}}>` ? Value extends SimpleScalarToken ? ExpandDictionary<Record<Key, SimpleTypeScalar<Value>> & Dictionary> : never : never;
-type SimpleTypeArray<T extends SimpleArrayToken> = T extends "Array" ? any[] : T extends "Array<string>" ? string[] : T extends `Array<string(${infer StringUnion})>` ? Array<SimpleTypeScalar<`string(${StringUnion})`>> : T extends "Array<number>" ? number[] : T extends `Array<number(${infer NumericUnion extends `${number}`})>` ? Array<SimpleTypeScalar<`number(${NumericUnion})`>> : T extends "Array<boolean>" ? boolean[] : T extends "Array<unknown>" ? unknown[] : never;
-type SimpleTypeMap<T extends SimpleMapToken> = T extends "Map" ? Map<any, any> : T extends `Map<${infer Key extends MapKeys}, ${infer Value extends MapValues}>` ? Map<SimpleType<Key>, SimpleType<Value>> : never;
-type SimpleTypeSet<T extends SimpleSetToken> = T extends "Set" ? Set<any> : T extends `Set<${infer Type extends SetTypes}>` ? Set<SimpleType<Type>> : never;
-/**
- * **SimpleType**`<T>`
- *
- * A type utility which takes a `SimpleToken` and converts it to
- * it's _type_ in the type system.
- *
- * **Related:** `ToShapeToken`, `StructuredStringType`
- */
-type SimpleType<T extends SimpleToken> = T extends SimpleScalarToken ? SimpleTypeScalar<T> : T extends SimpleDictToken ? SimpleTypeDict<T> : T extends SimpleArrayToken ? SimpleTypeArray<T> : T extends SimpleMapToken ? SimpleTypeMap<T> : T extends SimpleSetToken ? SimpleTypeSet<T> : T extends SimpleUnionToken ? SimpleTypeUnion<T> : never;
-
-/**
- * **SimpleToken**
- *
- * An enumeration of string values which point to _types_ in the
- * the type system.
- *
- * **Related:**
- * - `SimpleScalarToken`, `SimpleContainerToken`, `SimpleUnionToken`,
- * - `TypeToken`
- */
-type SimpleToken = SimpleScalarToken | SimpleArrayToken | SimpleDictToken | SimpleMapToken | SimpleSetToken | SimpleUnionToken;
 /**
  * the _optional_ variants of the `SimpleScalarToken` type
  */
@@ -10415,30 +10386,12 @@ type OptionalSimpleScalarTokens = typeof SIMPLE_OPT_SCALAR_TOKENS[number];
  * the _required_ variants of the `SimpleScalarToken` type
  */
 type RequiredSimpleScalarTokens = typeof SIMPLE_SCALAR_TOKENS[number];
-/**
- * **SimpleScalarToken**
- *
- * A subset of the `SimpleToken` which may be more useful for building
- * simple string literal values.
- *
- * **Note:** this includes both `RequiredSimpleScalarTokens` and `OptionalSimpleScalarTokens`.
- */
-type SimpleScalarToken = RequiredSimpleScalarTokens | OptionalSimpleScalarTokens;
 /**
  * **SimpleUnionToken**
  *
  * A subset of `SimpleToken` which represents union types.
  */
 type SimpleUnionToken = typeof SIMPLE_UNION_TOKENS[number];
-/**
- * **BaseTypeToken**
- *
- * A very simple structure for `TypeTokens` to fit into.
- *
- * Use this type if you need to preserve type simplicity, otherwise
- * prefer `TypeToken` (or subsets like `AtomicToken`, `SingletonToken`, etc.)
- */
-type BaseTypeToken = `${TypeTokenStart}${string}${TypeTokenStop}`;
 /**
  * a subset of `SimpleContainerToken`
  */
@@ -10463,52 +10416,129 @@ type SimpleSetToken = typeof SIMPLE_SET_TOKENS[number];
  */
 type SimpleContainerToken = SimpleDictToken | SimpleArrayToken | SimpleMapToken | SimpleArrayToken;
 /**
- * TypeTokenAtomics
+ * **SimpleScalarToken**
  *
- * The token names which are considered "atomic"
+ * A subset of the `SimpleToken` which may be more useful for building
+ * simple string literal values.
+ *
+ * **Note:** this includes both `RequiredSimpleScalarTokens` and `OptionalSimpleScalarTokens`.
+ */
+type SimpleScalarToken = RequiredSimpleScalarTokens | OptionalSimpleScalarTokens;
+/**
+ * **SimpleToken**
+ *
+ * An enumeration of string values which point to _types_ in the
+ * the type system.
+ *
+ * **Related:**
+ * - `SimpleScalarToken`, `SimpleContainerToken`, `SimpleUnionToken`,
+ * - `FromSimpleToken`, `FromDefn`
+ * - `TypeToken`
+ */
+type SimpleToken = SimpleScalarToken | SimpleArrayToken | SimpleDictToken | SimpleMapToken | SimpleSetToken | SimpleUnionToken;
+
+type SetTypes = typeof SIMPLE_SET_TYPES[number];
+type MapKeys = typeof SIMPLE_MAP_KEYS[number];
+type MapValues = typeof SIMPLE_MAP_VALUES[number];
+type DictValues = typeof SIMPLE_DICT_VALUES[number];
+/**
+ * **SimpleTypeScalar**`<T>`
+ *
+ * Converts a `SimpleScalarToken` into the _type_ it represents.
  */
-type TypeTokenAtomics = typeof TT_Atomics[number];
+type SimpleTypeScalar<T extends SimpleScalarToken> = T extends "string" ? string : T extends `string(${infer Literal})` ? Literal extends `${string},${string}` ? CsvToStrUnion<Literal> : Literal : T extends "number" ? number : T extends `number(${infer Literal})` ? Literal extends `${string},${string}` ? CsvToUnion<Literal> : AsNumber<Literal> : T extends "boolean" ? boolean : T extends "true" ? true : T extends "false" ? false : T extends "null" ? null : T extends "any" ? any : T extends "undefined" ? undefined : T extends "unknown" ? unknown : T extends `Opt<${infer Underlying extends SimpleScalarToken}>` ? undefined | SimpleTypeScalar<Underlying> : never;
 /**
- * **AtomicToken**
+ * **SimpleTypeUnion**`<T>`
  *
- * A fully formed `TypeToken` of the "atomic" type.
+ * Converts a `SimpleUnionToken` into the _type_ it represents.
  */
-type AtomicToken = `<<${TypeTokenAtomics}>>`;
-type TypeTokenContainers = typeof TT_Containers[number];
-type ContainerToken = `<<${TypeTokenContainers}${string}>>`;
-type UnionToken<_TEls extends readonly unknown[] = unknown[]> = `<<union::[ ${string} ]>>`;
+type SimpleTypeUnion<T extends SimpleUnionToken> = T extends "opt(string)" ? string | undefined : T extends "opt(number)" ? number | undefined : T extends "opt(boolean)" ? boolean | undefined : T extends "opt(unknown)" ? unknown | undefined : T extends `opt(${infer Literal extends string})` ? Literal extends `${string},${string}` ? TupleToUnion<CsvToTuple<Literal>> | undefined : UnderlyingType<Literal> | undefined : T extends `Union(${infer Literal})` ? Literal extends `${string},${string}` ? CsvToTuple<Literal> : Literal : never;
+type SimpleTypeDict<T extends SimpleDictToken> = T extends `Dict` ? Dictionary : T extends `Dict<string, ${infer Value extends DictValues & SimpleScalarToken}>` ? Dictionary<string, SimpleTypeScalar<Value>> : T extends `Dict<{${infer K}: ${infer V}, ${infer K2}: ${infer V2}}>` ? V extends SimpleScalarToken ? V2 extends SimpleScalarToken ? ExpandDictionary<Record<K, SimpleTypeScalar<V>> & Record<K2, SimpleTypeScalar<V2>> & Dictionary> : ExpandDictionary<Record<K, SimpleTypeScalar<V>> & Dictionary> : V2 extends SimpleScalarToken ? ExpandDictionary<Record<K2, SimpleTypeScalar<V2>> & Dictionary> : never : T extends `Dict<{${infer Key}: ${infer Value}}>` ? Value extends SimpleScalarToken ? ExpandDictionary<Record<Key, SimpleTypeScalar<Value>> & Dictionary> : never : never;
+type SimpleTypeArray<T extends SimpleArrayToken> = T extends "Array" ? any[] : T extends "Array<string>" ? string[] : T extends `Array<string(${infer StringUnion})>` ? Array<SimpleTypeScalar<`string(${StringUnion})`>> : T extends "Array<number>" ? number[] : T extends `Array<number(${infer NumericUnion extends `${number}`})>` ? Array<SimpleTypeScalar<`number(${NumericUnion})`>> : T extends "Array<boolean>" ? boolean[] : T extends "Array<unknown>" ? unknown[] : never;
+type SimpleTypeMap<T extends SimpleMapToken> = T extends "Map" ? Map<any, any> : T extends `Map<${infer Key extends MapKeys}, ${infer Value extends MapValues}>` ? Map<SimpleType<Key>, SimpleType<Value>> : never;
+type SimpleTypeSet<T extends SimpleSetToken> = T extends "Set" ? Set<any> : T extends `Set<${infer Type extends SetTypes}>` ? Set<SimpleType<Type>> : never;
 /**
- * **UnionSetToken**
+ * **SimpleType**`<T>`
+ *
+ * A type utility which takes a `SimpleToken` and converts it to
+ * it's _type_ in the type system.
  *
- * - static `<<union-set::`, then
- * - set _name_ `${string}`, then
- * - static `::[ `, then
- * - set _parameters_ `${string}`, then
- * - static ` ]>>`
+ * **Related:** `ToShapeToken`, `StructuredStringType`
  */
-type UnionSetToken = `<<union-set::${string}::[ ${string} ]>>`;
-type ObjectToken = `<<obj::{ ${string} }>>`;
-type TupleToken = `<<tuple::[ ${string} ]>>`;
-type ArrayToken = `<<arr::${BaseTypeToken}>>`;
-type RecordToken = `<<rec::${BaseTypeToken}::${BaseTypeToken}>>`;
-type SetToken = `<<set::${BaseTypeToken}>>`;
-type MapToken = `<<map::${BaseTypeToken}::${BaseTypeToken}>>`;
-type WeakMapToken = `<<weak::${BaseTypeToken}::${BaseTypeToken}>>`;
-type FnToken = `<<fn::${string}::${BaseTypeToken}>>`;
-type GeneratorToken = `<<gen::${string}::${BaseTypeToken}>>`;
-type TypeTokenFunctions = typeof TT_Functions[number];
-type TypeTokenSingletons = typeof TT_Singletons[number];
+type SimpleType<T extends SimpleToken> = T extends SimpleScalarToken ? SimpleTypeScalar<T> : T extends SimpleDictToken ? SimpleTypeDict<T> : T extends SimpleArrayToken ? SimpleTypeArray<T> : T extends SimpleMapToken ? SimpleTypeMap<T> : T extends SimpleSetToken ? SimpleTypeSet<T> : T extends SimpleUnionToken ? SimpleTypeUnion<T> : never;
+
+type MakeDynamic<T extends readonly string[]> = {
+    [K in keyof T]: ReplaceAll<ReplaceAll<T[K], "${string}", `${string}`>, "${Metric}", MetricCategory>;
+};
 /**
- * **SingletonToken**
+ * Type extensions for the `string` variant
+ *
+ * Allow for wide "string", or a string literal.
+ */
+type TypeToken__String = `${string}`;
+type TypeToken__StringSet = MakeDynamic<typeof TYPE_TOKEN_STRING_SET_VARIANTS>[number];
+/**
+ * Type extensions for the `number` variant.
+ *
+ * Allow for wide "number", a numeric literal.
+ */
+type TypeToken__Number = `::${number}`;
+type TypeToken__NumberSet = "bigInt" | `bigInt::${bigint}` | "digit" | `digit::${2 | 3 | 4}` | "integer";
+type params = string;
+type rtn = string;
+type D = TypeTokenDelimiter;
+type TypeToken__Fn = `[${params}]` | `[${params}]${D}${rtn}` | `any::${rtn}`;
+type TypeToken__Gen = `[${params}]` | `[${params}]${D}${rtn}` | `gen${D}any${D}${rtn}`;
+type TypeToken__FnSet = `withoutParams` | `withoutParams${D}${rtn}` | `booleanLogic` | `booleanLogic${D}[${params}]`;
+type RecVariant = typeof TYPE_TOKEN_REC_VARIANTS[number];
+type RecKeyVariant = typeof TYPE_TOKEN_REC_KEY_VARIANTS[number];
+type TypeToken__Rec = `${RecVariant}${D}${RecKeyVariant}` | `${D}kv${D}${string}` | `${D}kv${D}${string}${D}${"withUnknownIndex" | "withAnyIndex"}`;
+type TypeToken__Undefined = "";
+type TypeToken__Null = "";
+type TypeToken__Boolean = "";
+type TypeToken__True = "";
+type TypeToken__False = "";
+type TypeToken__Never = "";
+type TypeToken__Unknown = "";
+type TypeToken__UnionSet = typeof TYPE_TOKEN_UNION_SET_VARIANTS[number];
+interface _TypeTokenLookup {
+    "string": TypeToken__String;
+    "string-set": TypeToken__StringSet;
+    "number": TypeToken__Number;
+    "number-set": TypeToken__NumberSet;
+    "undefined": TypeToken__Undefined;
+    "null": TypeToken__Null;
+    "boolean": TypeToken__Boolean;
+    "true": TypeToken__True;
+    "false": TypeToken__False;
+    "never": TypeToken__Never;
+    "unknown": TypeToken__Unknown;
+    "fn": TypeToken__Fn;
+    "fn-set": TypeToken__FnSet;
+    "gen": TypeToken__Gen;
+    "rec": TypeToken__Rec;
+    "arr": "";
+    "map": "";
+    "weak": "";
+    "union": "";
+    "union-set": TypeToken__UnionSet;
+}
+/**
+ * **TypeTokenLookup**`<T>`
  *
- * Shapes:
- * - Wide: `<<string>>` or `<<number>>`
- * - Literal: `<<string::{string}>` or `<number::{number}>`
- * - Union Literal: `<<string::{UnionToken}>>`
- * - Sets: `<<string-set::[set]::[...params]>`
+ * Adds allowed string literal variants for a given `TypeTokenKind`
  */
-type SingletonToken = `<<${TypeTokenSingletons}>>` | `<<${TypeTokenSingletons}::${string}>>` | `<<${TypeTokenSingletons}::${UnionToken}>>` | `<<string-set::${string}::[${string}]>>` | `<<number-set::${string}::[${string}]>>`;
-type TypeTokenSets = typeof TT_Sets[number];
+type TypeTokenLookup<T extends TypeTokenKind> = T extends keyof _TypeTokenLookup ? _TypeTokenLookup[T] : "";
+/**
+ * TypeTokenAtomics
+ *
+ * The token names which are considered "atomic"
+ */
+type TypeTokenAtomics = typeof TT_ATOMICS[number];
+type TypeTokenContainers = typeof TT_CONTAINERS[number];
+type TypeTokenFunctions = typeof TT_FUNCTIONS[number];
+type TypeTokenSingletons = typeof TT_SINGLETONS[number];
+type TypeTokenSets = typeof TT_SETS[number];
 /**
  * **TypeTokenKind**
  *
@@ -10525,24 +10555,32 @@ type TypeTokenStart = typeof TT_START;
  * string which indicates the end of a `TypeToken`
  */
 type TypeTokenStop = typeof TT_STOP;
+/** the _delimiter_ token used in a `TypeToken` */
+type TypeTokenDelimiter = typeof TT_DELIMITER;
+type Delim = TypeTokenDelimiter;
 /**
  * **TypeToken**
  *
+ * A **TypeToken** represents the general shape of all variants of the
+ * TypeToken family. Variants are distinguished at the highest level
+ * by their `TypeTokenKind`.
  *
+ * You can use the generic `T` to isolate to one or more of these kinds
+ * if you like but by default all are represented.
  */
-type TypeToken<T extends TypeTokenKind = TypeTokenKind> = `${TypeTokenStart}${T}${"" | `::${string}`}${TypeTokenStop}`;
-
-type ProcessSimple<T extends SimpleToken | TypeToken> = T extends SimpleToken ? SimpleType<T> : never;
-type Iterate<T extends readonly SimpleToken[], TResult = never> = [] extends T ? TResult : Iterate<AfterFirst<T>, TResult & (First<T> extends SimpleScalarToken ? SimpleTypeScalar<First<T>> : First<T> extends SimpleDictToken ? SimpleTypeDict<First<T>> : First<T> extends SimpleMapToken ? SimpleTypeMap<First<T>> : First<T> extends SimpleSetToken ? SimpleTypeSet<First<T>> : First<T> extends SimpleArrayToken ? SimpleTypeArray<First<T>> : First<T> extends SimpleUnionToken ? SimpleTypeUnion<First<T>> : never)>;
+type TypeToken<T extends TypeTokenKind = TypeTokenKind> = IsEqual<T, TypeTokenKind> extends true ? `${TypeTokenStart}${T}${"" | `${Delim}${string}`}${TypeTokenStop}` : T extends TypeTokenKind ? IsUnion<T> extends true ? null : T extends TypeTokenSets ? `${TypeTokenStart}${T}${Delim}${TypeTokenLookup<T>}${TypeTokenStop}` : T extends TypeTokenAtomics ? `${TypeTokenStart}${T}${TypeTokenStop}` : `${TypeTokenStart}${T}${TypeTokenStop}` | `${TypeTokenStart}${T}${Delim}${TypeTokenLookup<T>}${TypeTokenStop}` : never;
 /**
- * **AsType**`<T>`
- *
- * converts either a `SimpleToken` or a `TypeToken` into the
- * _type_ it represents.
- *
- * NOTE: only implemented for `SimpleToken` at the moment.
+ * the shape of `TypeToken` variants which represent one of the Singleton variants
  */
-type AsType<T extends SimpleToken | readonly SimpleToken[] | TypeToken> = T extends readonly SimpleToken[] ? Iterate<T> : T extends SimpleToken ? ProcessSimple<T> : never;
+type TT_Singleton = TypeToken<TypeTokenSingletons>;
+/** the shape of `TypeToken` variants which represent one of the Atomic variants */
+type TT_Atomic = TypeToken<TypeTokenAtomics>;
+/** the shape of `TypeToken` variants which a "set" of pattern based types */
+type TT_Set = TypeToken<TypeTokenSets>;
+/** the shape of `TypeToken` variants which represent a function */
+type TT_Function = TypeToken<TypeTokenFunctions>;
+/** the shape of `TypeToken` variants which represent a container */
+type TT_Container = TypeToken<TypeTokenContainers>;
 /**
  * **Shape**
  *
@@ -10550,7 +10588,7 @@ type AsType<T extends SimpleToken | readonly SimpleToken[] | TypeToken> = T exte
  * are produced as the runtime representation of a type by utilities
  * like the `ShapeApi` and the `shape()` runtime function.
  */
-type Shape<T extends TypeTokenKind = TypeTokenKind> = `<<${T}${string}>>`;
+type Shape$1<T extends TypeTokenKind = TypeTokenKind> = `<<${T}${string}>>`;
 interface StringTokenUtilities<T> {
     /**
      * **startsWith**
@@ -10713,22 +10751,27 @@ interface ShapeApi__Functions {
         done: () => AsLiteralFn<FromDefn$1<TArgs>>;
     });
 }
+/** used in Shape callbacks */
 type RecordKeyWideTokens = "string" | "symbol" | "string | symbol";
+type FromSimpleRecordKey<T extends RecordKeyWideTokens> = T extends "string" ? string : T extends "symbol" ? symbol : T extends "string | symbol" ? string | symbol : never;
+type RecordKeyDefn = RecordKeyWideTokens | ShapeCallback;
+type FromRecordKeyDefn<T extends RecordKeyDefn> = T extends ShapeCallback ? FromShapeCallback<T> extends ObjectKey ? FromShapeCallback<T> : never : T extends "string" ? string : T extends "symbol" ? symbol : T extends "string | symbol" ? string | symbol : never;
 /**
  * An input type for defining an object's "key".
  *
  * Note: use of `FromDefn<T>` will translate this into the actual key value.
  */
 type ObjKeyDefn = RecordKeyWideTokens | ShapeCallback;
-type ArrayTypeDefn = "string[]" | "number[]" | "boolean[]" | "unknown[]" | ShapeCallback;
+type FromObjKeyDefn<T extends ObjKeyDefn> = T extends ShapeCallback ? FromShapeCallback<T> extends ObjectKey ? FromShapeCallback<T> : never : FromRecordKeyDefn<T>;
+type ArrayTypeDefn = "Array<string>" | "Array<number>" | "Array<boolean>" | "Array<unknown>" | ShapeCallback;
 type RecordValueTypeDefn = ShapeCallback | WideTokenNames;
 type MapKeyDefn = ShapeCallback | WideTokenNames;
 type MapValueDefn = ShapeCallback | WideTokenNames;
 type WeakMapKeyDefn = WideContainerNames | ShapeCallback;
 type WeakMapValueDefn = ShapeCallback | WideTokenNames;
 interface ShapeApi__WideContainers {
-    record: <TKey extends ObjKeyDefn = "string | symbol", TValue extends RecordValueTypeDefn = "unknown">(key?: TKey, value?: TValue) => Record<FromDefn$1<TKey>, FromDefn$1<TValue>>;
-    array: <T extends ArrayTypeDefn = "unknown[]">(type?: T) => AsArray<FromDefn$1<T>>;
+    record: <TKey extends ObjKeyDefn = "string | symbol", TValue extends RecordValueTypeDefn = "unknown">(key?: TKey, value?: TValue) => TKey extends string | symbol ? Record<FromObjKeyDefn<TKey>, FromDefn$1<TValue>> : never;
+    array: <T extends ArrayTypeDefn = "Array<unknown>">(type?: T) => AsArray<FromDefn$1<T>>;
     set: <T extends WideTokenNames | ShapeCallback = "unknown">(type?: T) => T extends ShapeCallback ? Set<HandleDoneFn<ReturnType<T>>> : T extends WideTokenNames ? Set<FromDefn$1<T>> : Set<unknown>;
     map: <TKey extends MapKeyDefn = "unknown", TValue extends MapValueDefn = "unknown">(key?: TKey, value?: TValue) => Map<FromDefn$1<TKey>, FromDefn$1<TValue>>;
     weakMap: <TKey extends WeakMapKeyDefn = "object", TValue extends WeakMapValueDefn = "unknown">(key?: TKey, value?: TValue) => WeakMap<As<FromDefn$1<TKey>, Container>, FromDefn$1<TValue>>;
@@ -10844,7 +10887,7 @@ type TypeTuple<TType extends Narrowable = Narrowable, TDesc extends string = str
  *   }
  *   ```
  *
- * - typically used though a function of type `DefineObjectApi`
+ * - typically used alongside `FromDefn` or `FromDefineObject`
  */
 interface DefineObject {
     [key: string]: SimpleToken | ShapeCallback;
@@ -11406,7 +11449,7 @@ declare function getYesterday(): Iso8601Date<"explicit">;
  */
 declare function isLeapYear(val: NumberLike | Record<string, any> | Date | number): boolean;
 
-type Returns$1<T extends DefineObject, P extends readonly (keyof T & string)[]> = P["length"] extends 0 ? FromDefineObject<T> : MakeKeysOptional<T, P> extends DefineObject ? FromDefineObject<MakeKeysOptional<T, P>> : never;
+type Returns$2<T extends DefineObject, P extends readonly (keyof T & string)[]> = P["length"] extends 0 ? FromDefineObject<T> : MakeKeysOptional<T, P> extends DefineObject ? FromDefineObject<MakeKeysOptional<T, P>> : never;
 /**
  * Takes an object definition where the values are either
  * `SimpleToken` representations of a type or a `ShapeCallback`.
@@ -11414,7 +11457,7 @@ type Returns$1<T extends DefineObject, P extends readonly (keyof T & string)[]>
  * In both cases the runtime type is left unchanged but the
  * type is converted to represent the designed object shape.
  */
-declare function defineObject<T extends DefineObject, P extends readonly (keyof T & string)[]>(defn: T, ..._optProps: P): Returns$1<T, P>;
+declare function defineObject<T extends DefineObject, P extends readonly (keyof T & string)[]>(defn: T, ..._optProps: P): Returns$2<T, P>;
 
 /**
  * **entries**
@@ -11801,6 +11844,14 @@ type ConversionResult<TConvert extends Partial<ConverterDefn<any, any, any, any,
  */
 declare function createConverter<TStr extends Narrowable = never, TNum extends Narrowable = never, TBool extends Narrowable = never, TObj extends Narrowable = never, TTuple extends Narrowable = never, TNothing extends Narrowable = never>(mapper: Partial<ConverterDefn<TStr, TNum, TBool, TObj, TTuple, TNothing>>): <TInput extends Narrowable | Tuple>(input: TInput) => ConversionResult<typeof mapper, TInput>;
 
+/**
+ * **createFixedLengthArray**`(content, quantity)`
+ *
+ * Provides a type strong array of duplicates of what was
+ * passed in as `content`
+ */
+declare function createFixedLengthArray<T extends Narrowable, C extends number>(content: T, quantity: C): FixedLengthArray<T, C>;
+
 declare const filter = "NOT READY";
 
 /**
@@ -11887,7 +11938,7 @@ declare function logicalReturns<TConditions extends readonly (boolean | LogicFun
  */
 declare function reverse<T extends readonly unknown[]>(list: T): Reverse<T>;
 
-type Rtn$1<T extends readonly K[] | K[] | undefined, K extends Narrowable> = IsUndefined<T> extends true ? undefined : T extends readonly K[] | K[] ? IsEqual<T["length"], number> extends true ? undefined | string : T["length"] extends 0 ? undefined : First<T> : never;
+type Rtn$2<T extends readonly K[] | K[] | undefined, K extends Narrowable> = IsUndefined<T> extends true ? undefined : T extends readonly K[] | K[] ? IsEqual<T["length"], number> extends true ? undefined | string : T["length"] extends 0 ? undefined : First<T> : never;
 /**
  * **shift**(list)
  *
@@ -11905,7 +11956,7 @@ type Rtn$1<T extends readonly K[] | K[] | undefined, K extends Narrowable> = IsU
  * `createLifoQueue()` or `createFifoQueue()`
  *
  */
-declare function shift<T extends readonly K[] | K[] | undefined, K extends Narrowable>(list: T): Rtn$1<T, K>;
+declare function shift<T extends readonly K[] | K[] | undefined, K extends Narrowable>(list: T): Rtn$2<T, K>;
 
 /**
  * **slice**(list, start, end)
@@ -11963,13 +12014,13 @@ declare function capitalize<T extends string>(str: T): Capitalize<T>;
  */
 declare function cssColor<TColorSpace extends CssColorSpace, TV1 extends ColorFnValue, TV2 extends ColorFnValue, TV3 extends ColorFnValue, TOp extends undefined | ColorFnOptOpacity>(color: TColorSpace, v1: TV1, v2: TV2, v3: TV3, opacity?: TOp): CssColorFn<TColorSpace, TV1, TV2, TV3, TOp extends ` / ${number}` ? TOp : "">;
 
-type Rtn<TColor extends TwColor, TLum extends TwLuminosity> = TLum extends keyof TwLuminosityLookup ? TLum extends keyof TwChromaLookup ? TColor extends keyof TwHue ? `oklch(${TwLuminosityLookup[TLum]} ${TwChromaLookup[TLum]} ${TwHue[TColor]}) ` : never : never : never;
+type Rtn$1<TColor extends TwColor, TLum extends TwLuminosity> = TLum extends keyof TwLuminosityLookup ? TLum extends keyof TwChromaLookup ? TColor extends keyof TwHue ? `oklch(${TwLuminosityLookup[TLum]} ${TwChromaLookup[TLum]} ${TwHue[TColor]}) ` : never : never : never;
 /**
  * Provides a Tailwind Color using the `oklch` color
  * specification. The output is intended to put into
  * a CSS property.
  */
-declare function twColor<TColor extends TwColor, TLum extends TwLuminosity>(color: TColor, luminosity: TLum): Rtn<TColor, TLum>;
+declare function twColor<TColor extends TwColor, TLum extends TwLuminosity>(color: TColor, luminosity: TLum): Rtn$1<TColor, TLum>;
 
 /**
  * **ensureLeading**(content, strip)
@@ -12009,14 +12060,14 @@ type _Index<T extends readonly string[], IF, ELSE, Results extends readonly unkn
     ...Results,
     If<Extends<T, LowerAlphaChar>, IF, ELSE>
 ]>;
-type Returns<T extends string | readonly string[], IF, ELSE> = T extends string ? If<Extends<T, LowerAlphaChar>, IF, ELSE> : T extends readonly string[] ? _Index<T, IF, ELSE> : never;
+type Returns$1<T extends string | readonly string[], IF, ELSE> = T extends string ? If<Extends<T, LowerAlphaChar>, IF, ELSE> : T extends readonly string[] ? _Index<T, IF, ELSE> : never;
 /**
  * **ifLowercaseChar**(ch)
  *
  * Tests whether a passed in character is lowercase and then uses the appropriate callback to
  * mutate the value.
  */
-declare function ifLowercaseChar<T extends string, IF, ELSE>(ch: T, callbackForMatch: <V extends T>(v: V) => IF, callbackForNoMatch: <V extends T>(v: V) => ELSE): Returns<T, IF, ELSE>;
+declare function ifLowercaseChar<T extends string, IF, ELSE>(ch: T, callbackForMatch: <V extends T>(v: V) => IF, callbackForNoMatch: <V extends T>(v: V) => ELSE): Returns$1<T, IF, ELSE>;
 
 type Convert<T, IF, ELSE> = If<Extends<T, UpperAlphaChar>, IF, ELSE>;
 /**
@@ -12031,6 +12082,22 @@ declare function ifUppercaseChar<T extends string, IF extends Narrowable, ELSE e
 /** the character to be tested */
 ch: T & IsSingleChar<T> extends true ? T : never, callbackForMatch: ValueCallback<T, IF>, callbackForNoMatch: ValueCallback<T, ELSE>): Convert<T, IF, ELSE>;
 
+type Ext = "string" | "number" | "boolean";
+type InferenceVars<T extends string, V extends readonly [str: string[], num: string[], bool: string[]] = [[], [], []]> = T extends `${string}{{${OptSpace}infer ${infer Var} extends ${infer Type extends Ext}${OptSpace}}}${infer REST}` ? Type extends "number" ? InferenceVars<REST, [V[0], [...V[1], Var], V[2]]> : Type extends "boolean" ? InferenceVars<REST, [V[0], V[1], [...V[2], Var]]> : InferenceVars<REST, [[...V[0], Var], V[1], V[2]]> : T extends `${string}{{${OptSpace}infer ${infer Var}${OptSpace}as ${infer Type extends Ext}${OptSpace}}}${infer REST}` ? Type extends "number" ? InferenceVars<REST, [V[0], [...V[1], Var], V[2]]> : Type extends "boolean" ? InferenceVars<REST, [V[0], V[1], [...V[2], Var]]> : InferenceVars<REST, [[...V[0], Var], V[1], V[2]]> : T extends `${string}{{${OptSpace}infer ${infer Var}${OptSpace}}}${infer REST}` ? InferenceVars<REST, [[...V[0], Var], V[1], V[2]]> : V;
+type StrVars<T extends string> = InferenceVars<T>[0];
+type NumVars<T extends string> = InferenceVars<T>[1];
+type BoolVars<T extends string> = InferenceVars<T>[2];
+type Shape<T extends string> = ExpandDictionary<Record<StrVars<T>[number], string> & Record<NumVars<T>[number], number> & Record<BoolVars<T>[number], boolean>>;
+type Lit$1 = "string" | "number" | "boolean";
+type LiteralSections<T extends string, V extends Lit$1[] = []> = T extends `${string}{{${OptSpace}${infer Section extends Lit$1}${OptSpace}}}${infer REST}` ? LiteralSections<REST, [...V, Section]> : V;
+/**
+ * Boolean operator which indicates whether the string literal has any dynamic segments or not
+ */
+type IsDynamic<T extends string> = LiteralSections<T>["length"] extends 0 ? InferenceVars<T>["length"] extends 0 ? false : true : true;
+type GetInference<TPattern extends string> = <T extends string>(test: T) => Shape<TPattern> | false;
+type Returns<T extends string> = IsDynamic<T> extends true ? GetInference<T> : never;
+declare function infer<TTempl extends string>(inference: TTempl): Returns<TTempl>;
+
 /**
  * Takes an object as input --which has an `id` property and returns it as the same
  * run-time content but with the _type_ of the `id` property being forced to a literal type
@@ -12467,6 +12534,8 @@ declare function tuple<N extends Narrowable, K extends PropertyKey, T extends re
  */
 declare function uncapitalize<T extends string>(str: T): Uncapitalize<T>;
 
+declare const unset: Unset;
+
 /**
  * **uppercase**()
  *
@@ -12687,35 +12756,71 @@ declare function shape<T extends ShapeCallback>(cb: T): HandleDoneFn<ReturnType<
  *
  * Type guard which tests whether a value is a _type_ defined by a `Shape`.
  */
-declare function isShape(v: unknown): v is Shape;
+declare function isShape(v: unknown): v is Shape$1;
 
-type BaseReturn<TBase extends TypeTokenKind> = TBase extends TypeTokenAtomics ? `<<${TBase}>>` : TBase extends TypeTokenSingletons ? SingletonClosure<TBase> : unknown;
+/**
+ * A token representation of a **Parameter** definition inside
+ * of a function token definition.
+ */
+type FnParam = string & {
+    __brand: `parameter for function`;
+};
+type FnParams<T> = T extends readonly unknown[] ? IsLiteral<T["length"]> extends true ? Join<FixedLengthArray<FnParam, T["length"]>, ", "> : string : never;
+/**
+ * A token representation of a **Parameter** definition inside
+ * of a function token definition.
+ */
+type GenParam = string & {
+    __brand: `parameter for generator function`;
+};
+type GenParams<T> = T extends readonly unknown[] ? IsLiteral<T["length"]> extends true ? Join<FixedLengthArray<GenParam, T["length"]>, ", "> : string : never;
+type Rtn = string & {
+    __brand: `return type for a function`;
+};
+
+type VariantClosure<TVariant extends TypeTokenKind> = TVariant extends TypeTokenAtomics ? `<<${TVariant}>>` : TVariant extends TypeTokenSingletons ? SingletonClosure<TVariant> : TVariant extends TypeTokenSets ? TokenSetClosure<TVariant> : TVariant extends TypeTokenFunctions ? TokenFunctionClosure<TVariant, Unset, Unset> : TVariant extends TypeTokenContainers ? TokenContainerClosure<TVariant> : never;
 type UnionClosure = <T extends readonly unknown[]>(...elements: T) => `union::[${Join<T, ", ">}]`;
 /**
  * **SingletonClosure**
  *
  * Closes out the `string` or `number` base types to conclude as
- * either a wide type or a string literal. It does allow for multiple
- * literal values and in this case will need to add a union token as
- * a parameter
+ * a valid Singleton Token.
+ */
+interface SingletonClosure<T extends "string" | "number"> {
+    wide: () => `<<${T}>>`;
+    literal: <TLit extends T extends "string" ? string : number>(val: TLit) => `<<${T}::${TLit}>>`;
+}
+/**
+ * **TokenSetClosure**
  *
- * ```ts
- * // <<string>>
- * const a = closure<"string">();
- * // <<string::foo>>
- * const b = closure<"string">("foo");
- * // <<string::${UnionClosure("foo", "bar")}>>
- * const c = closure<"string">("foo","bar");
- * ```
+ * Closes out the `string` or `number` base types to conclude as
+ * a valid Singleton Token.
  */
-type SingletonClosure<T extends "string" | "number"> = <TLit extends readonly SimpleType<T>[]>(...literals: TLit) => If<IsLength<TLit, 0>, `<<${T}>>`, If<IsLength<TLit, 1>, `<<${T}::${TLit[0]}>>`, `<<${T}::>>`>>;
+type TokenSetClosure<T extends TypeTokenSets> = <P extends TypeTokenLookup<T>>(_p: P) => any;
+type TokenContainerClosure<_T> = any;
+/**
+ * Closes out the definition of a `TypeToken` for a _function_ based token
+ */
+interface TokenFunctionClosure<T extends TypeTokenFunctions, P extends (readonly (SimpleToken | ShapeCallback)[]) | Unset, R extends Unset | SimpleToken | ShapeCallback> {
+    params: P extends Unset ? <TParams extends (readonly (SimpleToken | ShapeCallback)[])>(...p: TParams) => TokenFunctionClosure<T, TParams, R> : never;
+    returns: R extends Unset ? <TReturns extends SimpleToken | ShapeCallback>(r: TReturns) => TokenFunctionClosure<T, P, TReturns> : never;
+    done: () => IsUnset<P> extends true ? IsUnset<R> extends true ? `<<${T}>>` : `<<${T}::any::${string}>>` : IsUnset<R> extends true ? `<<${T}::${string}>>` : `<<${T}::${string}>>`;
+}
 /**
  * **createTypeToken**`(base) => (secondary) => ...`
  *
  * A higher order function designed to creating a valid
  * `TypeToken` simple through a compound process.
  */
-declare function createTypeToken<TBase extends TypeTokenAtomics | TypeTokenSingletons>(base: TBase): BaseReturn<TBase>;
+declare function createTypeToken<TBase extends TypeTokenKind>(kind: TBase): VariantClosure<TBase>;
+
+/**
+ * **getTokenKind**`(token)`
+ *
+ * Given a `TypeToken`, this function will extract the
+ * `kind` variant name.
+ */
+declare function getTokenKind<T extends TypeToken>(token: T): TypeTokenKind;
 
 /**
  * **simpleToken**`(token)`
@@ -13532,18 +13637,6 @@ declare function isNotNull<T>(value: T): value is T & NotNull;
  */
 declare function isNull<T>(value: T): value is T & null;
 
-/**
- * **isNumber**(value)
- *
- * Type guard to test whether passed in value is a numeric type.
- */
-declare function isNumber<T>(value: T): value is T & number;
-
-/**
- * Type guard which validates that the passed in `val` is a string array.
- */
-declare function isNumericArray(val: unknown): val is number[];
-
 /**
  * **isNumericString**(value)
  *
@@ -13690,13 +13783,6 @@ declare function isTrue(value: unknown): value is true;
  */
 declare function isTruthy<V>(val: V): val is Exclude<V, FalsyValue>;
 
-/**
- * **isTypeToken**(val)
- *
- * Type guard which checks whether the given value is a valid `TypeToken`
- */
-declare function isTypeToken(val: unknown): val is TypeToken;
-
 /**
  * **isTypeTuple**(value)
  *
@@ -13849,40 +13935,65 @@ declare function isUrlSource<T>(val: T): val is (T & DomainName<AsString<T>>) |
 declare function hasUrlQueryParameter<T extends string, P extends string>(val: T, prop: P): boolean;
 
 /**
- * **isAtomicToken**`(val)`
+ * **isNumber**(value)
  *
- * Type guard which validates whether the value passed in is a
- * valid `AtomicToken`.
+ * Type guard to test whether passed in value is a numeric type.
+ */
+declare function isNumber<T>(value: T): value is T & number;
+
+/**
+ * Type guard which validates that the passed in `val` is a string array.
  */
-declare function isAtomicToken(val: unknown): val is AtomicToken;
+declare function isNumericArray(val: unknown): val is number[];
 
-declare function isObjectToken(val: unknown): val is ObjectToken;
-declare function isRecordToken(val: unknown): val is RecordToken;
-declare function isTupleToken(val: unknown): val is TupleToken;
-declare function isArrayToken(val: unknown): val is ArrayToken;
-declare function isMapToken(val: unknown): val is MapToken;
-declare function isSetToken(val: unknown): val is SetToken;
-declare function isWeakMapToken(val: unknown): val is WeakMapToken;
 /**
- * **isUnionToken**`(val)`: **val** is `UnionToken`
+ * A _multi-granularity_ type guard for validating whether `val` is
+ * a `TypeToken`.
+ *
+ * - when used without the `kind` parameter it will check whether `val`
+ * is _any_ kind of `TypeToken`
+ * - specifying a kind will narrow the check to that specific kind variant
  */
-declare function isUnionToken(val: unknown): val is UnionToken;
+declare function isTypeToken<T extends TypeTokenKind = TypeTokenKind>(val: unknown, kind?: T): val is TypeToken<T>;
 /**
- * **isUnionSetToken**`(val)`: **val** is `UnionSetToken`
+ * type guard which validates that `val` is a `TypeTokenKind`
  */
-declare function isUnionSetToken(val: unknown): val is UnionSetToken;
+declare function isTypeTokenKind(val: unknown): val is TypeTokenKind;
+
+/**
+ * **isAtomicToken**`(val)`
+ *
+ * Type guard which validates whether the value passed in is a
+ * valid `AtomicToken`.
+ */
+declare function isAtomicToken(val: unknown): val is TT_Atomic;
+declare function isAtomicKind(val: unknown): val is TypeTokenAtomics;
+
+declare function isObjectToken(val: unknown): val is TypeToken<"obj">;
+declare function isRecordToken(val: unknown): val is TypeToken<"rec">;
+declare function isTupleToken(val: unknown): val is TypeToken<"tuple">;
+declare function isArrayToken(val: unknown): val is TypeToken<"arr">;
+declare function isMapToken(val: unknown): val is TypeToken<"map">;
+declare function isSetToken(val: unknown): val is TypeToken<"set">;
 /**
  * **isContainerToken**`(val)`: **val** is `ContainerToken`
  */
-declare function isContainerToken(val: unknown): val is ContainerToken;
+declare function isContainerToken(val: unknown): val is TT_Container;
 
 /**
  * type guard which validates whether the `val` passed in a `DefineObject`
  */
 declare function isDefineObject(val: unknown): val is DefineObject;
 
-declare function isFnToken(val: unknown): val is FnToken;
-declare function isGeneratorToken(val: unknown): val is GeneratorToken;
+/**
+ * type guard which validates that `val` is a _function based_ `TypeToken`
+ */
+declare function isFnBasedToken(val: unknown): boolean | undefined;
+/**
+ * type guard which validates that `val` is a `TypeTokenKind` which
+ * represents a _function based_ token (excluding "-set" types)
+ */
+declare function isFnBasedKind(val: unknown): val is TT_Function;
 
 /**
  * type guard which validates that the `val` passed in is a `ShapeCallback`
@@ -13942,12 +14053,22 @@ declare function isSimpleScalarTokenTuple(val: unknown): val is SimpleScalarToke
 declare function isSimpleContainerTokenTuple(val: unknown): val is SimpleContainerToken[];
 
 /**
- * **isSingletonToken**`(val)`
+ * **isSetBasedToken**`(val)`
+ *
+ * Type guard which validates whether the value passed in is a
+ * valid `TypeToken` who's name "kind" ends in `-set`.
+ */
+declare function isSetBasedToken(val: unknown): val is TT_Set;
+declare function isSetBasedKind(val: unknown): val is TypeTokenSets;
+
+/**
+ * **isSingletonKind**`(val)`
  *
  * Type guard which validates whether the value passed in is a
- * valid `SingletonToken` of some sort.
+ * valid Singleton token kind of some sort.
  */
-declare function isSingletonToken(val: unknown): val is SingletonToken;
+declare function isSingletonKind(val: unknown): val is TypeTokenSingletons;
+declare function isSingletonToken(val: unknown): val is TT_Singleton;
 
 /**
  * **isTailwindColor**`(val)`
@@ -14476,4 +14597,4 @@ declare function isYouTubeVideosInPlaylist<T>(val: T): val is T & YouTubeVideosI
  */
 declare function asVueRef<T extends Narrowable>(value: T): VueRef<T>;
 
-export { type AsClassSelector, type AsList, type BoxValue, type BoxedFnParams, type CssKeyframeCallback, type CssSelectorOptions, type CsvFormat, type EndingWithTypeGuard, type EqualTo, type Finder, type GetEachOptions, type GetOptions, type Joiner, type KeyframeApi, ShapeApiImplementation, type SingletonClosure, type StartingWithTypeGuard, type StripSurroundConfigured, type SurroundWith, type TypeOfTypeGuard, type Unbox, type UndefinedArrayIsUnknown, type UnionClosure, type UrlMeta, type YouTubeMeta, addFnToProps, addPropsToFn, and, asApi, asArray, asChars, asDate, asEscapeFunction, asIsoDate, asOptionalParamFunction, asPhoneFormat, asRecord, asString, asStringLiteral, asType, asTypeToken, asVueRef, box, boxDictionaryValues, capitalize, choices, createConverter, createCssKeyframe, createCssSelector, createErrorCondition, createFifoQueue, createFnWithProps, createFnWithPropsExplicit, createLifoQueue, createTypeToken, cssColor, csv, defineCss, defineObj, defineObject, defineTuple, endsWith, ensureLeading, ensureSurround, ensureTrailing, entries, errCondition, filter, find, fnMeta, get, getDaysBetween, getEach, getPhoneCountryCode, getTailwindModifiers, getToday, getTomorrow, getUrlPath, getUrlPort, getUrlProtocol, getUrlQueryParams, getUrlSource, getWeekNumber, getYesterday, getYouTubePageType, handleDoneFn, hasDefaultValue, hasIndexOf, hasKeys, hasUrlPort, hasUrlQueryParameter, hasWhiteSpace, idLiteral, idTypeGuard, identity, ifArray, ifArrayPartial, ifBoolean, ifChar, ifContainer, ifDefined, ifFalse, ifFunction, ifHasKey, ifLength, ifLowercaseChar, ifNotNull, ifNull, ifNumber, ifObject, ifSameType, ifScalar, ifString, ifTrue, ifUndefined, ifUppercaseChar, indexOf, intersect, intersection, ip6GroupExpansion, ip6Prefix, isAccelerationMetric, isAccelerationUom, isAlpha, isAmazonUrl, isApi, isApiSurface, isAppleUrl, isAreaMetric, isAreaUom, isArray, isArrayToken, isAtomicToken, isAustralianNewsUrl, isBelgiumNewsUrl, isBestBuyUrl, isBitbucketUrl, isBoolean, isBooleanLike, isBox, isCanadianNewsUrl, isChineseNewsUrl, isCodeCommitUrl, isConstant, isContainer, isContainerToken, isCostCoUrl, isCountryAbbrev, isCountryCode2, isCountryCode3, isCountryName, isCssAspectRatio, isCurrentMetric, isCurrentUom, isCvsUrl, isDanishNewsUrl, isDate, isDefineObject, isDefined, isDellUrl, isDistanceMetric, isDistanceUom, isDomainName, isDoneFn, isDutchNewsUrl, isEbayUrl, isEmail, isEnergyMetric, isEnergyUom, isEqual, isErrorCondition, isEscapeFunction, isEtsyUrl, isFalse, isFalsy, isFnToken, isFnWithParams, isFrenchNewsUrl, isFrequencyMetric, isFrequencyUom, isFunction, isGeneratorToken, isGermanNewsUrl, isGithubIssueUrl, isGithubIssuesListUrl, isGithubOrgUrl, isGithubProjectUrl, isGithubProjectsListUrl, isGithubReleaseTagUrl, isGithubReleasesListUrl, isGithubRepoReleaseTagUrl, isGithubRepoReleasesUrl, isGithubRepoUrl, isGithubUrl, isHexadecimal, isHmUrl, isHomeDepotUrl, isHtmlElement, isIkeaUrl, isIndexable, isIndianNewsUrl, isInlineSvg, isIp4Address, isIp6Address, isIpAddress, isIso3166Alpha2, isIso3166Alpha3, isIso3166CountryCode, isIso3166CountryName, isIsoDate, isIsoDateTime, isIsoExplicitDate, isIsoExplicitTime, isIsoImplicitDate, isIsoImplicitTime, isIsoTime, isIsoYear, isItalianNewsUrl, isJapaneseNewsUrl, isKrogersUrl, isLeapYear, isLength, isLikeRegExp, isLowesUrl, isLuminosityMetric, isLuminosityUom, isLuxonDateTime, isMacysUrl, isMapToken, isMassMetric, isMassUom, isMetric, isMexicanNewsUrl, isMoment, isNever, isNewsUrl, isNikeUrl, isNorwegianNewsUrl, isNotNull, isNothing, isNull, isNumber, isNumberLike, isNumericArray, isNumericString, isObject, isObjectToken, isOptionalParamFunction, isPhoneNumber, isPowerMetric, isPowerUom, isPressureMetric, isPressureUom, isReadonlyArray, isRecordToken, isRef, isRegExp, isRepoSource, isRepoUrl, isResistance, isResistanceUom, isRetailUrl, isSameTypeOf, isScalar, isSemanticVersion, isSet, isSetToken, isShape, isShapeCallback, isSimpleContainerToken, isSimpleContainerTokenTuple, isSimpleScalarToken, isSimpleScalarTokenTuple, isSimpleToken, isSimpleTokenTuple, isSingletonToken, isSocialMediaProfileUrl, isSocialMediaUrl, isSouthKoreanNewsUrl, isSpanishNewsUrl, isSpecificConstant, isSpeedMetric, isSpeedUom, isString, isStringArray, isSwissNewsUrl, isSymbol, isTailwindColor, isTailwindColorClass, isTailwindColorName, isTailwindColorTarget, isTailwindColorWithLuminosity, isTailwindColorWithLuminosityAndOpacity, isTailwindModifier, isTargetUrl, isTemperatureMetric, isTemperatureUom, isThenable, isThisMonth, isThisWeek, isThisYear, isTimeMetric, isTimeUom, isToday, isTomorrow, isTrimable, isTrue, isTruthy, isTuple, isTupleToken, isTurkishNewsUrl, isTypeOf, isTypeToken, isTypeTuple, isUkNewsUrl, isUndefined, isUnionSetToken, isUnionToken, isUnset, isUom, isUri, isUrl, isUrlPath, isUrlSource, isUsNewsUrl, isUsStateAbbreviation, isUsStateName, isVoltageMetric, isVoltageUom, isVolumeMetric, isVolumeUom, isWalgreensUrl, isWalmartUrl, isWayfairUrl, isWeakMapToken, isWholeFoodsUrl, isYesterday, isYouTubeCreatorUrl, isYouTubeFeedHistoryUrl, isYouTubeFeedUrl, isYouTubePlaylistUrl, isYouTubePlaylistsUrl, isYouTubeShareUrl, isYouTubeSubscriptionsUrl, isYouTubeTrendingUrl, isYouTubeUrl, isYouTubeVideoUrl, isYouTubeVideosInPlaylist, isZaraUrl, isZipCode, isZipCode5, isZipPlus4, joinWith, jsonValue, jsonValues, keysOf, kindLiteral, last, list, literal, logicalReturns, lookupCountryAlpha2, lookupCountryAlpha3, lookupCountryCode, lookupCountryName, lowercase, mergeObjects, mergeScalars, mergeTuples, nameLiteral, narrow, never, omit, optional, optionalOrNull, or, orNull, pathJoin, pluralize, removePhoneCountryCode, removeTailwindModifiers, removeUrlProtocol, result, retain, retainAfter, retainAfterInclusive, retainChars, retainUntil, retainUntilInclusive, retainWhile, reverse, rightWhitespace, shape, sharedKeys, shift, simpleContainerToken, simpleContainerTokenToTypeToken, simpleContainerType, simpleScalarToken, simpleScalarTokenToTypeToken, simpleScalarType, simpleToken, simpleType, simpleUnionTokenToTypeToken, slice, split, startsWith, stripAfter, stripBefore, stripChars, stripLeading, stripParenthesis, stripSurround, stripTrailing, stripUntil, stripWhile, surround, takeNumericCharacters, takeProp, toCamelCase, toKebabCase, toNumber, toNumericArray, toPascalCase, toSnakeCase, toString, toUppercase, trim, trimEnd, trimLeft, trimRight, trimStart, truncate, tuple, twColor, unbox, uncapitalize, union, unionize, unique, uniqueKeys, uppercase, urlMeta, valuesOf, widen, withDefaults, withKeys, withoutKeys, withoutValue, wrapFn, youtubeEmbed, youtubeMeta };
+export { type AsClassSelector, type AsList, type BoxValue, type BoxedFnParams, type CssKeyframeCallback, type CssSelectorOptions, type CsvFormat, type EndingWithTypeGuard, type EqualTo, type Finder, type FnParam, type FnParams, type GenParam, type GenParams, type GetEachOptions, type GetInference, type GetOptions, type Joiner, type KeyframeApi, type Rtn, ShapeApiImplementation, type SingletonClosure, type StartingWithTypeGuard, type StripSurroundConfigured, type SurroundWith, type TokenContainerClosure, type TokenFunctionClosure, type TokenSetClosure, type TypeOfTypeGuard, type Unbox, type UndefinedArrayIsUnknown, type UnionClosure, type UrlMeta, type YouTubeMeta, addFnToProps, addPropsToFn, and, asApi, asArray, asChars, asDate, asEscapeFunction, asIsoDate, asOptionalParamFunction, asPhoneFormat, asRecord, asString, asStringLiteral, asType, asTypeToken, asVueRef, box, boxDictionaryValues, capitalize, choices, createConverter, createCssKeyframe, createCssSelector, createErrorCondition, createFifoQueue, createFixedLengthArray, createFnWithProps, createFnWithPropsExplicit, createLifoQueue, createTypeToken, cssColor, csv, defineCss, defineObj, defineObject, defineTuple, endsWith, ensureLeading, ensureSurround, ensureTrailing, entries, errCondition, filter, find, fnMeta, get, getDaysBetween, getEach, getPhoneCountryCode, getTailwindModifiers, getToday, getTokenKind, getTomorrow, getUrlPath, getUrlPort, getUrlProtocol, getUrlQueryParams, getUrlSource, getWeekNumber, getYesterday, getYouTubePageType, handleDoneFn, hasDefaultValue, hasIndexOf, hasKeys, hasUrlPort, hasUrlQueryParameter, hasWhiteSpace, idLiteral, idTypeGuard, identity, ifArray, ifArrayPartial, ifBoolean, ifChar, ifContainer, ifDefined, ifFalse, ifFunction, ifHasKey, ifLength, ifLowercaseChar, ifNotNull, ifNull, ifNumber, ifObject, ifSameType, ifScalar, ifString, ifTrue, ifUndefined, ifUppercaseChar, indexOf, infer, intersect, intersection, ip6GroupExpansion, ip6Prefix, isAccelerationMetric, isAccelerationUom, isAlpha, isAmazonUrl, isApi, isApiSurface, isAppleUrl, isAreaMetric, isAreaUom, isArray, isArrayToken, isAtomicKind, isAtomicToken, isAustralianNewsUrl, isBelgiumNewsUrl, isBestBuyUrl, isBitbucketUrl, isBoolean, isBooleanLike, isBox, isCanadianNewsUrl, isChineseNewsUrl, isCodeCommitUrl, isConstant, isContainer, isContainerToken, isCostCoUrl, isCountryAbbrev, isCountryCode2, isCountryCode3, isCountryName, isCssAspectRatio, isCurrentMetric, isCurrentUom, isCvsUrl, isDanishNewsUrl, isDate, isDefineObject, isDefined, isDellUrl, isDistanceMetric, isDistanceUom, isDomainName, isDoneFn, isDutchNewsUrl, isEbayUrl, isEmail, isEnergyMetric, isEnergyUom, isEqual, isErrorCondition, isEscapeFunction, isEtsyUrl, isFalse, isFalsy, isFnBasedKind, isFnBasedToken, isFnWithParams, isFrenchNewsUrl, isFrequencyMetric, isFrequencyUom, isFunction, isGermanNewsUrl, isGithubIssueUrl, isGithubIssuesListUrl, isGithubOrgUrl, isGithubProjectUrl, isGithubProjectsListUrl, isGithubReleaseTagUrl, isGithubReleasesListUrl, isGithubRepoReleaseTagUrl, isGithubRepoReleasesUrl, isGithubRepoUrl, isGithubUrl, isHexadecimal, isHmUrl, isHomeDepotUrl, isHtmlElement, isIkeaUrl, isIndexable, isIndianNewsUrl, isInlineSvg, isIp4Address, isIp6Address, isIpAddress, isIso3166Alpha2, isIso3166Alpha3, isIso3166CountryCode, isIso3166CountryName, isIsoDate, isIsoDateTime, isIsoExplicitDate, isIsoExplicitTime, isIsoImplicitDate, isIsoImplicitTime, isIsoTime, isIsoYear, isItalianNewsUrl, isJapaneseNewsUrl, isKrogersUrl, isLeapYear, isLength, isLikeRegExp, isLowesUrl, isLuminosityMetric, isLuminosityUom, isLuxonDateTime, isMacysUrl, isMapToken, isMassMetric, isMassUom, isMetric, isMexicanNewsUrl, isMoment, isNever, isNewsUrl, isNikeUrl, isNorwegianNewsUrl, isNotNull, isNothing, isNull, isNumber, isNumberLike, isNumericArray, isNumericString, isObject, isObjectToken, isOptionalParamFunction, isPhoneNumber, isPowerMetric, isPowerUom, isPressureMetric, isPressureUom, isReadonlyArray, isRecordToken, isRef, isRegExp, isRepoSource, isRepoUrl, isResistance, isResistanceUom, isRetailUrl, isSameTypeOf, isScalar, isSemanticVersion, isSet, isSetBasedKind, isSetBasedToken, isSetToken, isShape, isShapeCallback, isSimpleContainerToken, isSimpleContainerTokenTuple, isSimpleScalarToken, isSimpleScalarTokenTuple, isSimpleToken, isSimpleTokenTuple, isSingletonKind, isSingletonToken, isSocialMediaProfileUrl, isSocialMediaUrl, isSouthKoreanNewsUrl, isSpanishNewsUrl, isSpecificConstant, isSpeedMetric, isSpeedUom, isString, isStringArray, isSwissNewsUrl, isSymbol, isTailwindColor, isTailwindColorClass, isTailwindColorName, isTailwindColorTarget, isTailwindColorWithLuminosity, isTailwindColorWithLuminosityAndOpacity, isTailwindModifier, isTargetUrl, isTemperatureMetric, isTemperatureUom, isThenable, isThisMonth, isThisWeek, isThisYear, isTimeMetric, isTimeUom, isToday, isTomorrow, isTrimable, isTrue, isTruthy, isTuple, isTupleToken, isTurkishNewsUrl, isTypeOf, isTypeToken, isTypeTokenKind, isTypeTuple, isUkNewsUrl, isUndefined, isUnset, isUom, isUri, isUrl, isUrlPath, isUrlSource, isUsNewsUrl, isUsStateAbbreviation, isUsStateName, isVoltageMetric, isVoltageUom, isVolumeMetric, isVolumeUom, isWalgreensUrl, isWalmartUrl, isWayfairUrl, isWholeFoodsUrl, isYesterday, isYouTubeCreatorUrl, isYouTubeFeedHistoryUrl, isYouTubeFeedUrl, isYouTubePlaylistUrl, isYouTubePlaylistsUrl, isYouTubeShareUrl, isYouTubeSubscriptionsUrl, isYouTubeTrendingUrl, isYouTubeUrl, isYouTubeVideoUrl, isYouTubeVideosInPlaylist, isZaraUrl, isZipCode, isZipCode5, isZipPlus4, joinWith, jsonValue, jsonValues, keysOf, kindLiteral, last, list, literal, logicalReturns, lookupCountryAlpha2, lookupCountryAlpha3, lookupCountryCode, lookupCountryName, lowercase, mergeObjects, mergeScalars, mergeTuples, nameLiteral, narrow, never, omit, optional, optionalOrNull, or, orNull, pathJoin, pluralize, removePhoneCountryCode, removeTailwindModifiers, removeUrlProtocol, result, retain, retainAfter, retainAfterInclusive, retainChars, retainUntil, retainUntilInclusive, retainWhile, reverse, rightWhitespace, shape, sharedKeys, shift, simpleContainerToken, simpleContainerTokenToTypeToken, simpleContainerType, simpleScalarToken, simpleScalarTokenToTypeToken, simpleScalarType, simpleToken, simpleType, simpleUnionTokenToTypeToken, slice, split, startsWith, stripAfter, stripBefore, stripChars, stripLeading, stripParenthesis, stripSurround, stripTrailing, stripUntil, stripWhile, surround, takeNumericCharacters, takeProp, toCamelCase, toKebabCase, toNumber, toNumericArray, toPascalCase, toSnakeCase, toString, toUppercase, trim, trimEnd, trimLeft, trimRight, trimStart, truncate, tuple, twColor, unbox, uncapitalize, union, unionize, unique, uniqueKeys, unset, uppercase, urlMeta, valuesOf, widen, withDefaults, withKeys, withoutKeys, withoutValue, wrapFn, youtubeEmbed, youtubeMeta };