inferred-types 0.52.15 → 0.53.0

package/dist/constants/TypeComparisons.d.ts

@@ -1,230 +0,0 @@
-/**
- * **TYPE_COMPARISONS**
- *
- * A dictionary of all _comparison_ operations along with their `RefType`, description,
- * and `Params`.
- */
-export declare const TYPE_COMPARISONS: {
-    readonly Extends: [unknown, "extends the type", [(t: {
-        readonly boolean: () => boolean;
-        readonly string: () => string;
-        readonly number: () => number;
-        readonly symbol: () => symbol;
-        readonly null: () => null;
-        readonly function: () => (...args: unknown[]) => unknown;
-        readonly tuple: () => readonly unknown[];
-        readonly singularTuple: () => [readonly unknown[]];
-        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
-        readonly emptyObject: () => Record<never, unknown>;
-        readonly undefined: () => undefined;
-        readonly unknown: () => unknown;
-        readonly nothing: () => null | undefined;
-        readonly something: () => {};
-    }) => unknown]];
-    readonly NotExtends: [unknown, "does not extent the type", [(t: {
-        readonly boolean: () => boolean;
-        readonly string: () => string;
-        readonly number: () => number;
-        readonly symbol: () => symbol;
-        readonly null: () => null;
-        readonly function: () => (...args: unknown[]) => unknown;
-        readonly tuple: () => readonly unknown[];
-        readonly singularTuple: () => [readonly unknown[]];
-        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
-        readonly emptyObject: () => Record<never, unknown>;
-        readonly undefined: () => undefined;
-        readonly unknown: () => unknown;
-        readonly nothing: () => null | undefined;
-        readonly something: () => {};
-    }) => unknown]];
-    readonly Equals: [unknown, "equals the type", [(t: {
-        readonly boolean: () => boolean;
-        readonly string: () => string;
-        readonly number: () => number;
-        readonly symbol: () => symbol;
-        readonly null: () => null;
-        readonly function: () => (...args: unknown[]) => unknown;
-        readonly tuple: () => readonly unknown[];
-        readonly singularTuple: () => [readonly unknown[]];
-        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
-        readonly emptyObject: () => Record<never, unknown>;
-        readonly undefined: () => undefined;
-        readonly unknown: () => unknown;
-        readonly nothing: () => null | undefined;
-        readonly something: () => {};
-    }) => unknown]];
-    readonly NotEqual: [unknown, "does not equal the type", [(t: {
-        readonly boolean: () => boolean;
-        readonly string: () => string;
-        readonly number: () => number;
-        readonly symbol: () => symbol;
-        readonly null: () => null;
-        readonly function: () => (...args: unknown[]) => unknown;
-        readonly tuple: () => readonly unknown[];
-        readonly singularTuple: () => [readonly unknown[]];
-        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
-        readonly emptyObject: () => Record<never, unknown>;
-        readonly undefined: () => undefined;
-        readonly unknown: () => unknown;
-        readonly nothing: () => null | undefined;
-        readonly something: () => {};
-    }) => unknown]];
-    readonly Truthy: [unknown, "must be a truthy value", []];
-    readonly Falsy: [unknown, "must be a falsy value", []];
-    readonly IsSomething: [unknown, "must be 'something' (aka, not null or undefined)", []];
-    readonly IsNothing: [unknown, "must be 'nothing' (aka, null or undefined)", []];
-    readonly IsString: [string, "must extend a string type", []];
-    readonly IsNumber: [number, "must extend a number type", []];
-    readonly IsBoolean: [boolean, "must extend a boolean type", []];
-    readonly GreaterThan: [number, "must be a numeric literal greater than [[0]]", [(t: {
-        readonly boolean: () => boolean;
-        readonly string: () => string;
-        readonly number: () => number;
-        readonly symbol: () => symbol;
-        readonly null: () => null;
-        readonly function: () => (...args: unknown[]) => unknown;
-        readonly tuple: () => readonly unknown[];
-        readonly singularTuple: () => [readonly unknown[]];
-        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
-        readonly emptyObject: () => Record<never, unknown>;
-        readonly undefined: () => undefined;
-        readonly unknown: () => unknown;
-        readonly nothing: () => null | undefined;
-        readonly something: () => {};
-    }) => number]];
-    readonly LessThan: [number, "must be a numeric literal less than [[0]]", [(t: {
-        readonly boolean: () => boolean;
-        readonly string: () => string;
-        readonly number: () => number;
-        readonly symbol: () => symbol;
-        readonly null: () => null;
-        readonly function: () => (...args: unknown[]) => unknown;
-        readonly tuple: () => readonly unknown[];
-        readonly singularTuple: () => [readonly unknown[]];
-        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
-        readonly emptyObject: () => Record<never, unknown>;
-        readonly undefined: () => undefined;
-        readonly unknown: () => unknown;
-        readonly nothing: () => null | undefined;
-        readonly something: () => {};
-    }) => number]];
-    readonly StartsWith: [string, "must be a string literal that starts with '[[0]]'", [(t: {
-        readonly boolean: () => boolean;
-        readonly string: () => string;
-        readonly number: () => number;
-        readonly symbol: () => symbol;
-        readonly null: () => null;
-        readonly function: () => (...args: unknown[]) => unknown;
-        readonly tuple: () => readonly unknown[];
-        readonly singularTuple: () => [readonly unknown[]];
-        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
-        readonly emptyObject: () => Record<never, unknown>;
-        readonly undefined: () => undefined;
-        readonly unknown: () => unknown;
-        readonly nothing: () => null | undefined;
-        readonly something: () => {};
-    }) => string]];
-    readonly EndsWith: [string, "must be a string literal that ends with '[[0]]'", [(t: {
-        readonly boolean: () => boolean;
-        readonly string: () => string;
-        readonly number: () => number;
-        readonly symbol: () => symbol;
-        readonly null: () => null;
-        readonly function: () => (...args: unknown[]) => unknown;
-        readonly tuple: () => readonly unknown[];
-        readonly singularTuple: () => [readonly unknown[]];
-        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
-        readonly emptyObject: () => Record<never, unknown>;
-        readonly undefined: () => undefined;
-        readonly unknown: () => unknown;
-        readonly nothing: () => null | undefined;
-        readonly something: () => {};
-    }) => string]];
-    readonly Includes: [string, "must be a string literal that includes the substring '[[0]]'", [(t: {
-        readonly boolean: () => boolean;
-        readonly string: () => string;
-        readonly number: () => number;
-        readonly symbol: () => symbol;
-        readonly null: () => null;
-        readonly function: () => (...args: unknown[]) => unknown;
-        readonly tuple: () => readonly unknown[];
-        readonly singularTuple: () => [readonly unknown[]];
-        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
-        readonly emptyObject: () => Record<never, unknown>;
-        readonly undefined: () => undefined;
-        readonly unknown: () => unknown;
-        readonly nothing: () => null | undefined;
-        readonly something: () => {};
-    }) => string]];
-    readonly ReturnsSomething: [(...args: unknown[]) => unknown, "must be a function which returns 'something' (aka, not null or undefined)", []];
-    readonly ReturnsNothing: [(...args: unknown[]) => unknown, "must be a function which returns 'nothing' (aka, null or undefined)", []];
-    readonly ReturnsTrue: [(...args: unknown[]) => unknown, "must be a function which returns 'true'", []];
-    readonly ReturnsFalse: [(...args: unknown[]) => unknown, "must be a function which returns 'false'", []];
-    readonly ReturnsTruthy: [(...args: unknown[]) => unknown, "must be a function which returns a 'truthy' value", []];
-    readonly ReturnsFalsy: [(...args: unknown[]) => unknown, "must be a function which returns a 'falsy' value", []];
-    readonly ReturnsExtends: [unknown, "must be a function which returns a value which extends [[0]]", [(t: {
-        readonly boolean: () => boolean;
-        readonly string: () => string;
-        readonly number: () => number;
-        readonly symbol: () => symbol;
-        readonly null: () => null;
-        readonly function: () => (...args: unknown[]) => unknown;
-        readonly tuple: () => readonly unknown[];
-        readonly singularTuple: () => [readonly unknown[]];
-        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
-        readonly emptyObject: () => Record<never, unknown>;
-        readonly undefined: () => undefined;
-        readonly unknown: () => unknown;
-        readonly nothing: () => null | undefined;
-        readonly something: () => {};
-    }) => unknown]];
-    readonly ReturnsEquals: [unknown, "must be a function which returns a value which equals [[0]]", [(t: {
-        readonly boolean: () => boolean;
-        readonly string: () => string;
-        readonly number: () => number;
-        readonly symbol: () => symbol;
-        readonly null: () => null;
-        readonly function: () => (...args: unknown[]) => unknown;
-        readonly tuple: () => readonly unknown[];
-        readonly singularTuple: () => [readonly unknown[]];
-        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
-        readonly emptyObject: () => Record<never, unknown>;
-        readonly undefined: () => undefined;
-        readonly unknown: () => unknown;
-        readonly nothing: () => null | undefined;
-        readonly something: () => {};
-    }) => unknown]];
-    readonly Contains: [readonly unknown[], "must be a tuple and have elements that extends the value [[0]]", [(t: {
-        readonly boolean: () => boolean;
-        readonly string: () => string;
-        readonly number: () => number;
-        readonly symbol: () => symbol;
-        readonly null: () => null;
-        readonly function: () => (...args: unknown[]) => unknown;
-        readonly tuple: () => readonly unknown[];
-        readonly singularTuple: () => [readonly unknown[]];
-        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
-        readonly emptyObject: () => Record<never, unknown>;
-        readonly undefined: () => undefined;
-        readonly unknown: () => unknown;
-        readonly nothing: () => null | undefined;
-        readonly something: () => {};
-    }) => unknown]];
-    readonly ContainsSome: [readonly unknown[], "must be a tuple and have elements that extends the value [[0]]", [(t: {
-        readonly boolean: () => boolean;
-        readonly string: () => string;
-        readonly number: () => number;
-        readonly symbol: () => symbol;
-        readonly null: () => null;
-        readonly function: () => (...args: unknown[]) => unknown;
-        readonly tuple: () => readonly unknown[];
-        readonly singularTuple: () => [readonly unknown[]];
-        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
-        readonly emptyObject: () => Record<never, unknown>;
-        readonly undefined: () => undefined;
-        readonly unknown: () => unknown;
-        readonly nothing: () => null | undefined;
-        readonly something: () => {};
-    }) => [readonly unknown[]]]];
-};
-//# sourceMappingURL=TypeComparisons.d.ts.map

package/dist/constants/TypeComparisons.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TypeComparisons.d.ts","sourceRoot":"","sources":["../../src/constants/TypeComparisons.ts"],"names":[],"mappings":"AAuBA;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCnB,CAAC"}

package/dist/constants/TypeComparisons.js

@@ -1,47 +0,0 @@
-import { WideAssignment } from "./Wide";
-const wide = WideAssignment;
-const entry = (refType, desc, ...params) => [
-    refType(wide),
-    desc,
-    params.map(i => typeof (i) === "function"
-        ? i(wide)
-        : i),
-];
-/**
- * **TYPE_COMPARISONS**
- *
- * A dictionary of all _comparison_ operations along with their `RefType`, description,
- * and `Params`.
- */
-export const TYPE_COMPARISONS = {
-    "Extends": entry(t => t.unknown(), "extends the type", t => t.unknown()),
-    "NotExtends": entry(t => t.unknown(), "does not extent the type", t => t.unknown()),
-    "Equals": entry(t => t.unknown(), "equals the type", t => t.unknown()),
-    "NotEqual": entry(t => t.unknown(), "does not equal the type", t => t.unknown()),
-    "Truthy": entry(t => t.unknown(), "must be a truthy value"),
-    "Falsy": entry(t => t.unknown(), "must be a falsy value"),
-    "IsSomething": entry(t => t.unknown(), "must be 'something' (aka, not null or undefined)"),
-    "IsNothing": entry(t => t.unknown(), "must be 'nothing' (aka, null or undefined)"),
-    "IsString": entry(t => t.string(), "must extend a string type"),
-    "IsNumber": entry(t => t.number(), "must extend a number type"),
-    "IsBoolean": entry(t => t.boolean(), "must extend a boolean type"),
-    // numeric
-    "GreaterThan": entry(t => t.number(), "must be a numeric literal greater than [[0]]", t => t.number()),
-    "LessThan": entry(t => t.number(), "must be a numeric literal less than [[0]]", t => t.number()),
-    // string
-    "StartsWith": entry(t => t.string(), "must be a string literal that starts with '[[0]]'", t => t.string()),
-    "EndsWith": entry(t => t.string(), "must be a string literal that ends with '[[0]]'", t => t.string()),
-    "Includes": entry(t => t.string(), "must be a string literal that includes the substring '[[0]]'", t => t.string()),
-    // function
-    "ReturnsSomething": entry(t => t.function(), "must be a function which returns 'something' (aka, not null or undefined)"),
-    "ReturnsNothing": entry(t => t.function(), "must be a function which returns 'nothing' (aka, null or undefined)"),
-    "ReturnsTrue": entry(t => t.function(), "must be a function which returns 'true'"),
-    "ReturnsFalse": entry(t => t.function(), "must be a function which returns 'false'"),
-    "ReturnsTruthy": entry(t => t.function(), "must be a function which returns a 'truthy' value"),
-    "ReturnsFalsy": entry(t => t.function(), "must be a function which returns a 'falsy' value"),
-    "ReturnsExtends": entry(t => t.unknown(), "must be a function which returns a value which extends [[0]]", t => t.unknown()),
-    "ReturnsEquals": entry(t => t.unknown(), "must be a function which returns a value which equals [[0]]", t => t.unknown()),
-    "Contains": entry(t => t.tuple(), "must be a tuple and have elements that extends the value [[0]]", t => t.unknown()),
-    // TODO: get the below working`
-    "ContainsSome": entry(t => t.tuple(), "must be a tuple and have elements that extends the value [[0]]", t => t.singularTuple()),
-};

package/dist/constants/TypeOf.d.ts

@@ -1,7 +0,0 @@
-/**
- * **TYPE_OF**
- *
- * The set of values which are possible results of the `typeof` command in Javascript.
- */
-export declare const TYPE_OF: readonly ["string", "number", "boolean", "undefined", "symbol", "bigint", "function", "object"];
-//# sourceMappingURL=TypeOf.d.ts.map

package/dist/constants/TypeOf.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TypeOf.d.ts","sourceRoot":"","sources":["../../src/constants/TypeOf.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,OAAO,iGAAkG,CAAC"}

package/dist/constants/TypeOf.js

@@ -1,6 +0,0 @@
-/**
- * **TYPE_OF**
- *
- * The set of values which are possible results of the `typeof` command in Javascript.
- */
-export const TYPE_OF = ["string", "number", "boolean", "undefined", "symbol", "bigint", "function", "object"];

package/dist/constants/TypeTokens.d.ts

@@ -1,68 +0,0 @@
-export declare const SIMPLE_DICT_VALUES: readonly ["string", "number", "boolean", "unknown", "Opt<string>", "Opt<number>", "Opt<boolean>", "Opt<unknown>"];
-export declare const SIMPLE_SET_TYPES: readonly ["string", "number", "boolean", "unknown", "Opt<string>", "Opt<number>", "Opt<boolean>", "Opt<unknown>"];
-export declare const SIMPLE_SCALAR_TOKENS: readonly ["string", "number", `string(${string})`, `number(${number})` | `number(${number},${string})`, "boolean", "true", "false", "null", "undefined", "unknown", "any", "never"];
-export 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>"];
-export declare const SIMPLE_FN_TOKENS: readonly ["Fn<none> => Unknown", "Fn<string> => Unknown", "Fn<number> => Unknown", "Fn<boolean> => Unknown"];
-export declare const SIMPLE_UNION_TOKENS: readonly [`union(${string})` | `union(${string},${string})`];
-export 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>>"];
-export 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>>"];
-export 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}: null}>` | `Dict<{${string}: true}>` | `Dict<{${string}: false}>` | `Dict<{${string}: never}>` | `Dict<{${string}: unknown}>` | `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}: null, ${string}: ${string}}` | `Dict<{${string}: true, ${string}: ${string}}` | `Dict<{${string}: false, ${string}: ${string}}` | `Dict<{${string}: never, ${string}: ${string}}` | `Dict<{${string}: unknown, ${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}}`];
-export 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>"];
-export 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"];
-export 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>>"];
-export declare const SIMPLE_CONTAINER_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}: null}>` | `Dict<{${string}: true}>` | `Dict<{${string}: false}>` | `Dict<{${string}: never}>` | `Dict<{${string}: unknown}>` | `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}: null, ${string}: ${string}}` | `Dict<{${string}: true, ${string}: ${string}}` | `Dict<{${string}: false, ${string}: ${string}}` | `Dict<{${string}: never, ${string}: ${string}}` | `Dict<{${string}: unknown, ${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}}`, "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>", "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", "Set", "Set<string>" | "Set<number>" | "Set<boolean>" | "Set<unknown>" | "Set<Opt<string>>" | "Set<Opt<number>>" | "Set<Opt<boolean>>" | "Set<Opt<unknown>>"];
-/**
- * **SIMPLE_TOKENS**
- *
- * A list of strings literals which can be used
- * to express the type of a variable or token
- * in relatively course granularity
- */
-export declare const SIMPLE_TOKENS: readonly ["string", "number", `string(${string})`, `number(${number})` | `number(${number},${string})`, "boolean", "true", "false", "null", "undefined", "unknown", "any", "never", "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>", "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}: null}>` | `Dict<{${string}: true}>` | `Dict<{${string}: false}>` | `Dict<{${string}: never}>` | `Dict<{${string}: unknown}>` | `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}: null, ${string}: ${string}}` | `Dict<{${string}: true, ${string}: ${string}}` | `Dict<{${string}: false, ${string}: ${string}}` | `Dict<{${string}: never, ${string}: ${string}}` | `Dict<{${string}: unknown, ${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}}`, "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>", "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", "Set", "Set<string>" | "Set<number>" | "Set<boolean>" | "Set<unknown>" | "Set<Opt<string>>" | "Set<Opt<number>>" | "Set<Opt<boolean>>" | "Set<Opt<unknown>>", `union(${string})` | `union(${string},${string})`];
-/**
- * **Type Tokens** which have zero configuration elements.
- */
-export 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.
- */
-export declare const TT_Singletons: readonly ["string", "number"];
-export declare const TT_Sets: readonly ["string-set", "numeric-set", "union-set"];
-/**
- * **Type Tokens** which represent _functions_ (either the typical
- * variety or Generator functions).
- */
-export declare const TT_Functions: readonly ["fn", "gen"];
-/**
- * **Type Tokens** which _contain_ other **Type Tokens** to make up their
- * identity.
- */
-export declare const TT_Containers: readonly ["rec", "arr", "set", "map", "union", "obj", "tuple"];
-export declare const TT_START: "<<";
-export declare const TT_STOP: ">>";
-export declare const TT_SEP: "::";
-/**
- * `TypeToken` names whose name provides the full definition
- * for the type.
- */
-export declare const TYPE_TOKEN_IDENTITIES: readonly ["string", "number", "numericString", "booleanString", "null", "undefined", "boolean", "true", "false", "space", "whitespace", "object", "emptyObject", "function", "array"];
-/**
- * `TypeToken` names which need a _string_ parameter to fully qualify
- */
-export declare const TYPE_TOKEN_PARAM_STR: readonly ["explicitClass", "startsWith", "endsWith", "ensureLeading", "stripLeading", "ensureTrailing", "stripTrailing", "camelCase", "pascalCase", "snakeCase", "kebabCase", "explicitType"];
-/**
- * `TypeToken` names which need a _CSV_ parameter to fully qualify
- */
-export declare const TYPE_TOKEN_PARAM_CSV: readonly ["stringLiteral", "numericLiteral", "objectLiteral", "tuple", "union"];
-/**
- * `TypeToken` names which need a _datetime_ parameter to fully qualify
- */
-export declare const TYPE_TOKEN_PARAM_DATETIME: readonly ["datetime"];
-/**
- * `TypeToken` names which need a _datetime_ parameter to fully qualify
- */
-export declare const TYPE_TOKEN_PARAM_DATE: readonly ["ymd", "monthThenDate", "dateThenMonth"];
-export declare const TYPE_TOKEN_PARAM_TIME: readonly ["timeInMinutes", "timeInSeconds", "militaryTimeInMinutes", "militaryTimeInSeconds", "militaryTimeInMilliseconds", "civilianTimeInMinutes"];
-export declare const TYPE_TOKEN_ALL: readonly ["string", "number", "numericString", "booleanString", "null", "undefined", "boolean", "true", "false", "space", "whitespace", "object", "emptyObject", "function", "array", "stringLiteral", "numericLiteral", "objectLiteral", "tuple", "union", "ymd", "monthThenDate", "dateThenMonth", "datetime", "explicitClass", "startsWith", "endsWith", "ensureLeading", "stripLeading", "ensureTrailing", "stripTrailing", "camelCase", "pascalCase", "snakeCase", "kebabCase", "explicitType", "timeInMinutes", "timeInSeconds", "militaryTimeInMinutes", "militaryTimeInSeconds", "militaryTimeInMilliseconds", "civilianTimeInMinutes"];
-//# sourceMappingURL=TypeTokens.d.ts.map

package/dist/constants/TypeTokens.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TypeTokens.d.ts","sourceRoot":"","sources":["../../src/constants/TypeTokens.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,mHAGrB,CAAC;AAEX,eAAO,MAAM,gBAAgB,mHAGnB,CAAC;AAGX,eAAO,MAAM,oBAAoB,qLAavB,CAAC;AAEX,eAAO,MAAM,wBAAwB,6RAa3B,CAAC;AAGX,eAAO,MAAM,gBAAgB,8GAKnB,CAAC;AAIX,eAAO,MAAM,mBAAmB,8DAEtB,CAAC;AAGX,eAAO,MAAM,eAAe,iOAWlB,CAAC;AAEX,eAAO,MAAM,iBAAiB,2YAWpB,CAAC;AASX,eAAO,MAAM,kBAAkB,ymFAYrB,CAAC;AAGX,eAAO,MAAM,mBAAmB,oOAWtB,CAAC;AAEX,eAAO,MAAM,iBAAiB,8jNAIpB,CAAC;AAEX,eAAO,MAAM,iBAAiB,yKAGpB,CAAC;AAEX,eAAO,MAAM,uBAAuB,mhTAK1B,CAAC;AAKX;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,kgUAKhB,CAAC;AAGX;;GAEG;AACH,eAAO,MAAM,UAAU,4DAMb,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,aAAa,+BAGhB,CAAC;AAEX,eAAO,MAAM,OAAO,qDAIV,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,YAAY,wBAGf,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,aAAa,gEAQhB,CAAC;AAEX,eAAO,MAAM,QAAQ,MAAgB,CAAC;AACtC,eAAO,MAAM,OAAO,MAAgB,CAAC;AACrC,eAAO,MAAM,MAAM,MAAgB,CAAC;AAEpC;;;GAGG;AACH,eAAO,MAAM,qBAAqB,uLAgBxB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,oBAAoB,+LAavB,CAAC;AAGX;;GAEG;AACH,eAAO,MAAM,oBAAoB,iFAMvB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,yBAAyB,uBAE5B,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,qBAAqB,oDAIxB,CAAC;AAEX,eAAO,MAAM,qBAAqB,sJAOxB,CAAC;AAEX,eAAO,MAAM,cAAc,inBAOjB,CAAC"}