inferred-types 0.33.1 → 0.33.2

package/dist/index.d.ts

@@ -1,95 +1,11 @@
-/**
- * **MutationIdentity**
- *
- * Defines a function which is passed a state `T` and returns a function with
- * an arbitrary -- but strongly typed -- set of parameters `P` which _must_ return
- * the same state `T` back.
- *
- * This allows `T` to be mutated by a relatively unconstrained set of mutation functions with the
- * sole guarentee that the form `T` is preserved.
- */
-declare type MutationIdentity<T, P extends any[]> = (state: T) => (...args: P) => T;
-/**
- * **MutationIdentity**
- *
- * A function which strongly types the construction of a `MutationIdentity`
- * higher-order function to be built. Usage:
- *
- * - The structure of the _state_ is defined in the first call as `T`
- * - The interior function than defines a mutation function which implicitly
- * defines the calling signature as `P` but is required to return the identity state
- * structure `T`.
- *
- * ```ts
- * type State = { foo: number, bar: number };
- * const incr = MutationIdentity<State>()(
- *    s => () => {...s, foo: s.foo++}
- * );
- * ```
- */
-declare function MutationIdentity<T>(): <M extends MutationIdentity<T, P>, P extends any[]>(m: M) => M;
-
-declare type MutationFunction<T extends any, P extends any[]> = (...args: P) => T;
-/**
- * **MutationFunction**
- *
- * Given a `MutationIdentity` higher-order function to work with, _this_ higher order expression
- * allows you to specify the structure of "state" `T` with the first function call; the
- * remaining function then serves as a strongly typed way to do partial application and get
- * back just the _mutation function_ responsible for changing the state. The mutation function
- * will take the form of:
- *
- * ```ts
- * const fn: (...args: P) => T = MutationFunction<T>()(mutationIdentity);
- * ```
- */
-declare function createMutationFunction<T extends any>(state: T): <M extends MutationIdentity<T, P>, P extends any[]>(mutationIdentity: M) => (...args: P) => T;
-
-declare function randomString(): string;
-
-declare function uuid(): string;
-
-/**
- * A union of types used in conjunction with the `literalValues()` function
- * to produce a _narrow_ type definition of a passed in dictionary object.
- */
-declare type Narrowable = string | number | boolean | symbol | object | undefined | void | null | {};
-
-declare type ValueTuple = [type: any, narrowable: boolean];
-/**
- * An API surface for choosing a **type** which is defined for run-time
- * use but is translatable to the type system as well.
- */
-declare type ValueTypes = {
-    string: [string, false];
-    boolean: [];
-};
-declare const valueTypes: {
-    string: [string, false];
-    boolean: [boolean, false];
-    number: [number, false];
-    function: [Function, false];
-    object: [Record<string, any>, false];
-    array: <T extends unknown>(arr?: T[]) => [T[], false];
-    null: [null, false];
-    symbol: [Symbol, false];
-    undefined: [undefined, false];
-    true: [true, true];
-    false: [false, true];
-    /** pass in a literal type */
-    literal: <N extends Narrowable, T_1 extends string | number | boolean | symbol | Record<any, N> | null | undefined>(v: T_1) => [T_1, true];
-    literalArray: <N_1 extends Narrowable, T_2 extends string | number | boolean | symbol | Record<any, N_1> | null | undefined>(arr: T_2[]) => (boolean | T_2[])[];
-};
-declare type ValueTypeFunc<N extends Narrowable, T extends Record<any, N> | number | string | boolean | symbol | null | Function> = (v: ValueTypes) => [T, boolean];
-
-declare type ApiFunction<P extends any[], R extends any> = (...args: P) => R;
-declare type FluentFunction<P extends any[], R extends any> = (...args: P) => R;
-declare type ApiValue<V extends any> = V;
+type ApiFunction<P extends any[], R extends any> = (...args: P) => R;
+type FluentFunction<P extends any[], R extends any> = (...args: P) => R;
+type ApiValue<V extends any> = V;
 /**
  * Expresses the API in a structured manner while making distinction
  * between a function endpoint and a _fluent_ function endpoint.
  */
-declare type Api<T extends object> = {
+type Api<T extends object> = {
     [K in keyof T]: T[K] extends (...args: any) => T ? FluentFunction<Parameters<T[K]>, ReturnType<T[K]>> : T[K] extends (...args: any) => any ? ApiFunction<Parameters<T[K]>, ReturnType<T[K]>> : ApiValue<T[K]>;
 };
 
@@ -97,7 +13,7 @@ declare type Api<T extends object> = {
  * Define a class constructor; allowing strong typing for constructor's parameters
  * and the returned class structure.
  */
-declare type Constructor<Ctor extends any[], Klass extends any> = new (...props: Ctor) => Klass;
+type Constructor<Ctor extends any[], Klass extends any> = new (...props: Ctor) => Klass;
 
 /**
  * Provides the values of an Typescript **enum**:
@@ -112,30 +28,40 @@ declare type Constructor<Ctor extends any[], Klass extends any> = new (...props:
  *
  * **Note:** combine with `Numeric` to get number based indexes
  */
-declare type EnumValues<T extends string | number> = `${T}`;
+type EnumValues<T extends string | number> = `${T}`;
 
 /**
  * Recursively goes over an object based structure and tries to reduce
  * it down to just a simple key/value type.
  */
-declare type ExpandRecursively<T> = T extends object ? T extends (...args: any[]) => any ? T : {
+type ExpandRecursively<T> = T extends object ? T extends (...args: any[]) => any ? T : {
     [K in keyof T]: ExpandRecursively<T[K]>;
 } : T;
 
 /**
  * Returns the first values type in an array of values
  */
-declare type First<T extends any[]> = T[0] extends T[number] ? T[0] : never;
+type First<T extends readonly any[]> = T[0] extends T[number] ? T[0] : never;
+type FirstOrUndefined<T extends unknown> = T extends [unknown, ...[unknown]] ? First<T> : undefined;
 
 /**
- * Defines a function type.
+ * **FunctionType**
+ *
+ * Provides a way to correctly match for regular functions _and_ functions which
+ * also have a dictionary hash alongside the root function.
  *
  * - without the generic `T` specified it simply matches correctly on both plain functions as well as functions which also have properties on them (this is consistent to how runtime's `typeof` operator works)
  * - with the generic you can specify the shape of the key/values
  */
-declare type FunctionType<T extends {} = {}> = {} extends T ? Function | (Function & {
+type FunctionType<T extends {} = {}> = {} extends T ? Function | (Function & {
     [key: string]: any;
 }) : Function | (Function & T);
+/**
+ * **FnShape**
+ *
+ * Simple way to express the shape of a function's arguments and return type.
+ */
+type FnShape<A extends any[] = any[], R extends any = any> = (...args: A) => R;
 
 /**
  * Provides a unary condition for the type system:
@@ -146,7 +72,7 @@ declare type FunctionType<T extends {} = {}> = {} extends T ? Function | (Functi
  * type F = If<false, "a", "b">;
  * ```
  */
-declare type If<C extends boolean, T, F> = C extends T ? C | F : never;
+type If<C extends boolean, T, F> = C extends T ? C | F : never;
 
 /**
  * **Include<T, U, L>**
@@ -163,7 +89,7 @@ declare type If<C extends boolean, T, F> = C extends T ? C | F : never;
  * type L2 = Include<typeof foo, "foo", true>;
  * ```
  */
-declare type Include<T, U, L extends boolean = false> = L extends true ? T extends U ? U extends T ? T : never : never : T extends U ? T : never;
+type Include<T, U, L extends boolean = false> = L extends true ? T extends U ? U extends T ? T : never : never : T extends U ? T : never;
 
 /**
  * A "KeyedRecord" is intended to store a value without
@@ -178,7 +104,7 @@ declare type Include<T, U, L extends boolean = false> = L extends true ? T exten
  * const song: KeyedRecord = { __key: "song", song: XXX }
  * ```
  */
-declare type KeyedRecord<K extends string, V extends any, T extends {
+type KeyedRecord<K extends string, V extends any, T extends {
     __key: K;
 } = {
     __key: K;
@@ -204,7 +130,7 @@ declare type KeyedRecord<K extends string, V extends any, T extends {
  * type K = Keys<typeof t2>;
  * ```
  */
-declare type Keys<T extends Record<string, any> | readonly string[], W extends string | undefined = undefined> = T extends readonly string[] ? W extends string ? Exclude<T[number], W> : T[number] : W extends string ? Exclude<keyof T & string, W> : keyof T & string;
+type Keys<T extends Record<string, any> | readonly string[], W extends string | undefined = undefined> = T extends readonly string[] ? W extends string ? Exclude<T[number], W> : T[number] : W extends string ? Exclude<keyof T & string, W> : keyof T & string;
 
 /**
  * Utility type which returns the length of an array literal
@@ -213,7 +139,7 @@ declare type Keys<T extends Record<string, any> | readonly string[], W extends s
  * type Three = Length<[ "a", "b", "c" ]>;
  * ```
  */
-declare type Length<T extends readonly any[]> = T["length"];
+type Length<T extends readonly any[]> = T["length"];
 
 /**
  * Converts a Tuple type into a _union_ of the tuple elements
@@ -223,24 +149,24 @@ declare type Length<T extends readonly any[]> = T["length"];
  * type U = TupleToUnion<typeof arr>;
  * ```
  */
-declare type TupleToUnion<T> = Mutable<T> extends any[] ? Mutable<T>[number] : never;
+type TupleToUnion<T> = T extends readonly any[] ? T[number] : never;
 
 /**
  * UnionToIntersection<{ foo: string } | { bar: string }> =
  *  { foo: string } & { bar: string }.
  */
-declare type UnionToIntersection<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
+type UnionToIntersection<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
 
 /**
  * LastInUnion<1 | 2> = 2.
  */
-declare type LastInUnion<U> = UnionToIntersection<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
+type LastInUnion<U> = UnionToIntersection<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
 /**
  * UnionToTuple<1 | 2> = [1, 2].
  */
-declare type UnionToTuple<U, Last = LastInUnion<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, Last>>, Last];
+type UnionToTuple<U, Last = LastInUnion<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, Last>>, Last];
 
-declare type Widen<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T;
+type Widen<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T;
 
 /**
  * **IsBooleanLiteral**
@@ -248,13 +174,13 @@ declare type Widen<T> = T extends string ? string : T extends number ? number :
  * Type utility which returns true/false if the boolean value is a _boolean literal_ versus
  * just the wider _boolean_ type.
  */
-declare type IsBooleanLiteral<T extends boolean> = boolean extends T ? false : true;
+type IsBooleanLiteral<T extends boolean> = boolean extends T ? false : true;
 /**
  * **IfBooleanLiteral**
  *
  * Branch utility which returns `IF` type when `T` is a boolean literal and `ELSE` otherwise
  */
-declare type IfBooleanLiteral<T extends boolean, IF, ELSE> = IsBooleanLiteral<T> extends true ? IF : ELSE;
+type IfBooleanLiteral<T extends boolean, IF, ELSE> = IsBooleanLiteral<T> extends true ? IF : ELSE;
 
 /**
  * **IsStringLiteral**
@@ -262,13 +188,13 @@ declare type IfBooleanLiteral<T extends boolean, IF, ELSE> = IsBooleanLiteral<T>
  * Type utility which returns true/false if the string a _string literal_ versus
  * just the _string_ type.
  */
-declare type IsStringLiteral<T> = T extends string ? string extends T ? false : true : false;
+type IsStringLiteral<T> = [T] extends [string] ? (string extends T ? false : true) : false;
 /**
  * **IfStringLiteral**
  *
  * Branch utility which returns `IF` type when `T` is a string literal and `ELSE` otherwise
  */
-declare type IfStringLiteral<T extends string, IF, ELSE> = IsStringLiteral<T> extends true ? IF : ELSE;
+type IfStringLiteral<T, IF, ELSE> = [IsStringLiteral<T>] extends [true] ? IF : ELSE;
 
 /**
  * **IsNumericLiteral**
@@ -276,13 +202,13 @@ declare type IfStringLiteral<T extends string, IF, ELSE> = IsStringLiteral<T> ex
  * Type utility which returns true/false if the numeric value a _numeric literal_ versus
  * just the _number_ type.
  */
-declare type IsNumericLiteral<T extends number> = number extends T ? false : true;
+type IsNumericLiteral<T extends number> = number extends T ? false : true;
 /**
  * **IfNumericLiteral**
  *
  * Branch utility which returns `IF` type when `T` is a numeric literal and `ELSE` otherwise
  */
-declare type IfNumericLiteral<T extends number, IF, ELSE> = IsNumericLiteral<T> extends true ? IF : ELSE;
+type IfNumericLiteral<T extends number, IF, ELSE> = IsNumericLiteral<T> extends true ? IF : ELSE;
 
 /**
  * **IsLiteral**
@@ -291,7 +217,7 @@ declare type IfNumericLiteral<T extends number, IF, ELSE> = IsNumericLiteral<T>
  * string, number, or boolean -- is a _literal_ value of that type (true) or
  * the more generic wide type (false).
  */
-declare type IsLiteral<T> = [T] extends [string] ? IsStringLiteral<T> : [T] extends [boolean] ? IsBooleanLiteral<T> : [T] extends [number] ? IsNumericLiteral<T> : false;
+type IsLiteral<T> = [T] extends [string] ? IsStringLiteral<T> : [T] extends [boolean] ? IsBooleanLiteral<T> : [T] extends [number] ? IsNumericLiteral<T> : false;
 /**
  * **IsOptionalLiteral**
  *
@@ -303,20 +229,20 @@ declare type IsLiteral<T> = [T] extends [string] ? IsStringLiteral<T> : [T] exte
  * to `true` even when a literal value is in union with _undefined_. If you don't
  * want to test for the union with _undefined_ use the `IsOptional` utility instead.
  */
-declare type IsOptionalLiteral<T> = [Exclude<T, undefined>] extends [string] ? IsStringLiteral<Exclude<T, undefined>> : [Exclude<T, undefined>] extends [boolean] ? IsBooleanLiteral<Exclude<T, undefined>> : [Exclude<T, undefined>] extends [number] ? IsNumericLiteral<Exclude<T, undefined>> : false;
+type IsOptionalLiteral<T> = [Exclude<T, undefined>] extends [string] ? IsStringLiteral<Exclude<T, undefined>> : [Exclude<T, undefined>] extends [boolean] ? IsBooleanLiteral<Exclude<T, undefined>> : [Exclude<T, undefined>] extends [number] ? IsNumericLiteral<Exclude<T, undefined>> : false;
 /**
  * **IfLiteral**
  *
  * Branch type utility with return `IF` when `T` is a _literal_ value and `ELSE` otherwise
  */
-declare type IfLiteral<T, IF, ELSE> = IsLiteral<T> extends true ? IF : ELSE;
+type IfLiteral<T, IF, ELSE> = IsLiteral<T> extends true ? IF : ELSE;
 /**
  * **IfOptionalLiteral**
  *
  * Branch type utility with return `IF` when `T` is a _literal_ value (with possibly
  * the inclusion of _undefined_); otherwise returns the type `ELSE`
  */
-declare type IfOptionalLiteral<T, IF, ELSE> = IsOptionalLiteral<T> extends true ? IF : ELSE;
+type IfOptionalLiteral<T, IF, ELSE> = IsOptionalLiteral<T> extends true ? IF : ELSE;
 
 /**
  * **Includes<TSource, TValue>**
@@ -328,29 +254,29 @@ declare type IfOptionalLiteral<T, IF, ELSE> = IsOptionalLiteral<T> extends true
  * no way to know at design-time whether the value includes `TValue` and so it will return
  * a type of `boolean`.
  */
-declare type Includes<TSource extends string | string[], TValue extends string> = TSource extends string[] ? IsStringLiteral<TupleToUnion<TSource>> extends true ? IsLiteral<TValue> extends true ? TValue extends TupleToUnion<TSource> ? true : false : boolean : boolean : TSource extends string ? IsLiteral<TSource> extends true ? IsLiteral<TValue> extends true ? TSource extends `${string}${TValue}${string}` ? true : false : boolean : boolean : boolean;
+type Includes<TSource extends string | string[], TValue extends string> = TSource extends string[] ? IsStringLiteral<TupleToUnion<TSource>> extends true ? IsLiteral<TValue> extends true ? TValue extends TupleToUnion<TSource> ? true : false : boolean : boolean : TSource extends string ? IsLiteral<TSource> extends true ? IsLiteral<TValue> extends true ? TSource extends `${string}${TValue}${string}` ? true : false : boolean : boolean : boolean;
 
-declare type IsScalar<T> = [T] extends [string] ? true : [T] extends [number] ? true : [T] extends [boolean] ? true : false;
+type IsScalar<T> = [T] extends [string] ? true : [T] extends [number] ? true : [T] extends [boolean] ? true : false;
 /**
  * **IfScalar**
  *
  * Branch type utility which returns `IF` when `T` is a scalar value and `ELSE` otherwise
  */
-declare type IfScalar<T, IF, ELSE> = IsScalar<T> extends true ? IF : ELSE;
+type IfScalar<T, IF, ELSE> = IsScalar<T> extends true ? IF : ELSE;
 
 /**
  * **Extends**
  *
  * Boolean type utility which returns `true` if `E` _extends_ `T`.
  */
-declare type Extends<E, T> = E extends T ? true : false;
+type Extends<E, T> = E extends T ? true : false;
 /**
  * **IfExtends**
  *
  * Branching type utility which returns type `IF` when `E` _extends_ `T`; otherwise
  * it will return the type `ELSE`.
  */
-declare type IfExtends<E, T, IF, ELSE> = Extends<E, T> extends true ? IF : ELSE;
+type IfExtends<E, T, IF, ELSE> = Extends<E, T> extends true ? IF : ELSE;
 
 /**
  * Often when mutating the shape of an object you will end up with the union of a number of
@@ -358,21 +284,27 @@ declare type IfExtends<E, T, IF, ELSE> = Extends<E, T> extends true ? IF : ELSE;
  *
  * This type utility will cleanup an object and return a simple dictionary definition for it.
  */
-declare type SimplifyObject<T extends {}> = ExpandRecursively<UnionToIntersection<ExpandRecursively<T>>>;
+type SimplifyObject<T extends {}> = ExpandRecursively<UnionToIntersection<ExpandRecursively<T>>>;
+
+/**
+ * A union of types used in conjunction with the `literalValues()` function
+ * to produce a _narrow_ type definition of a passed in dictionary object.
+ */
+type Narrowable = string | number | boolean | symbol | object | undefined | void | null | {};
 
 /**
  * **IsUndefined**
  *
  * Boolean type utility returns `true` if `T` is undefined; `false` otherwise
  */
-declare type IsUndefined<T extends Narrowable> = T extends undefined ? true : false;
+type IsUndefined<T extends Narrowable> = T extends undefined ? true : false;
 /**
  * **IfUndefined**
  *
  * Branch utility which returns `IF` type when `T` is an _undefined_ value
  * otherwise returns `ELSE` type
  */
-declare type IfUndefined<T, IF, ELSE> = IsUndefined<T> extends true ? IF : ELSE;
+type IfUndefined<T, IF, ELSE> = IsUndefined<T> extends true ? IF : ELSE;
 
 /**
  * **TypeDefault**
@@ -393,7 +325,7 @@ declare type IfUndefined<T, IF, ELSE> = IsUndefined<T> extends true ? IF : ELSE;
  * type DF2 = TypeDefault<typeof i, D>; // `{ foo: "foo"; bar: 99 }`
  * ```
  */
-declare type TypeDefault<T, D> = IsObject<D> extends true ? IsObject<T> extends true ? SimplifyObject<{
+type TypeDefault<T, D> = IsObject<D> extends true ? IsObject<T> extends true ? SimplifyObject<{
     [K in keyof D]: K extends keyof T ? TypeDefault<T[K], D[K]> : D[K];
 }> : IfUndefined<T, // check if T is undefined
 D, // use D as the type
@@ -408,19 +340,54 @@ Exclude<T, undefined>>, Exclude<T, undefined>>>;
  *
  * Boolean type utility used to check whether a type `T` is an object
  */
-declare type IsObject<T> = Mutable<T> extends Record<string, any> ? T extends FunctionType ? false : Mutable<T> extends any[] ? false : true : false;
+type IsObject<T> = Mutable<T> extends Record<string, any> ? T extends FunctionType ? false : Mutable<T> extends any[] ? false : true : false;
 /**
  * **IfObject**
  *
  * Branch type utility with return `IF` when `T` extends an object type
  * and `ELSE` otherwise
  */
-declare type IfObject<T, IF, ELSE> = IsObject<T> extends true ? IF : ELSE;
+type IfObject<T, IF, ELSE> = IsObject<T> extends true ? IF : ELSE;
+
+/**
+ * **StartsWith**<TValue, TStartsWith>
+ *
+ * A type utility which checks whether `T` _starts with_ the string literal `U`.
+ *
+ * If both `T` and `U` are string literals then the type system will resolve
+ * to a literal `true` or `false` but if either is not a literal that it will
+ * just resolve to `boolean` as the value can not be known at design time..
+ */
+type StartsWith<TValue extends unknown, TStartsWith extends unknown> = TValue extends string ? TStartsWith extends string ? TValue extends `${TStartsWith}${string}` ? IfStringLiteral<TValue, //
+IfStringLiteral<TStartsWith, true, boolean>, boolean> : IfStringLiteral<TValue, false, boolean> : false : false;
+/**
+ * **IfStartsWith**<TValue, TStartsWith, IF, ELSE, MAYBE>
+ *
+ * Type utility which converts type to `IF` type _if_ TValue _starts with_ `TStartsWith` but
+ * otherwise converts type to `ELSE`.
+ *
+ * Note, that there is also an optional `MAYBE` type
+ * which can be stated for cases where TValue or TStartsWith _might_ be the wider `string`
+ * type and therefore the type is unknown at design time.
+ */
+type IfStartsWith<TValue extends unknown, TStartsWith extends unknown, IF extends Narrowable, ELSE extends Narrowable> = StartsWith<TValue, TStartsWith> extends true ? IF : StartsWith<TValue, TStartsWith> extends false ? ELSE : IF | ELSE;
+
+/**
+ * **EndsWith**<T,U>
+ *
+ * A type utility which checks whether `T` _ends with_ the string literal `U`.
+ *
+ * If both `T` and `U` are string literals then the type system will resolve
+ * to a literal `true` or `false` but if either is not a literal that it will
+ * just resolve to `boolean` as the value can not be known at design time..
+ */
+type EndsWith<T extends unknown, U extends unknown> = T extends string ? U extends string ? T extends `${string}${U}` ? IfStringLiteral<T, //
+IfStringLiteral<U, true, boolean>, boolean> : IfStringLiteral<T, false, boolean> : false : false;
 
 /**
  * Makes a readonly structure mutable
  */
-declare type Mutable<T> = {
+type Mutable<T> = {
     -readonly [K in keyof T]: IsObject<T[K]> extends true ? Mutable<T[K]> : T[K];
 };
 
@@ -436,11 +403,11 @@ declare type Mutable<T> = {
  *
  * Note: same as `Exclude`
  */
-declare type Not<T, U> = T extends U ? never : T;
+type Not<T, U> = T extends U ? never : T;
 
-declare type Digital = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
-declare type MakeArray<S extends string, T extends any[] = []> = S extends `${T["length"]}` ? T : MakeArray<S, [...T, 0]>;
-declare type Multiply10<T extends any[]> = [...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T];
+type Digital = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
+type MakeArray<S extends string, T extends any[] = []> = S extends `${T["length"]}` ? T : MakeArray<S, [...T, 0]>;
+type Multiply10<T extends any[]> = [...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T];
 /**
  * Converts a string literal to a numeric literal
  * ```ts
@@ -450,7 +417,7 @@ declare type Multiply10<T extends any[]> = [...T, ...T, ...T, ...T, ...T, ...T,
  * type Ten = Numeric<"10">;
  * ```
  */
-declare type Numeric<S extends string, T extends any[] = []> = S extends `${infer S1}${infer S2}` ? S1 extends Digital ? Numeric<S2, [...Multiply10<T>, ...MakeArray<S1>]> : never : T["length"];
+type Numeric<S extends string, T extends any[] = []> = S extends `${infer S1}${infer S2}` ? S1 extends Digital ? Numeric<S2, [...Multiply10<T>, ...MakeArray<S1>]> : never : T["length"];
 
 /**
  * **Opaque**
@@ -461,7 +428,7 @@ declare type Numeric<S extends string, T extends any[] = []> = S extends `${infe
  * Note: taken from [type-fest](https://github.com/sindresorhus/type-fest/blob/main/source/opaque.d.ts)
  * repo.
  */
-declare type Opaque<Type, Token = unknown> = Type & {
+type Opaque<Type, Token = unknown> = Type & {
     readonly __opaque__: Token;
 };
 
@@ -479,7 +446,7 @@ declare type Opaque<Type, Token = unknown> = Type & {
  *
  * **Note:** in essence this is the _opposite_ of `Exclude<T,K>`
  */
-declare type Retain<T, K extends keyof T> = Pick<T, Include<keyof T, K>>;
+type Retain<T, K extends keyof T> = Pick<T, Include<keyof T, K>>;
 
 /**
  * **SameKeys**
@@ -489,7 +456,7 @@ declare type Retain<T, K extends keyof T> = Pick<T, Include<keyof T, K>>;
  *
  * Note: meant to be used as part of an _extends_ clause in most cases.
  */
-declare type SameKeys<T extends object, A extends any = any> = {
+type SameKeys<T extends object, A extends any = any> = {
     [P in keyof T]: A;
 };
 
@@ -502,7 +469,7 @@ declare type SameKeys<T extends object, A extends any = any> = {
  * This type utility assumes that _keys_ of both dictionaries
  * are the same.
  */
-declare type Transformer<I extends object, O extends SameKeys<I>, K extends keyof I = keyof I> = (input: I, key: K) => O[K];
+type Transformer<I extends object, O extends SameKeys<I>, K extends keyof I = keyof I> = (input: I, key: K) => O[K];
 
 /**
  * **TypeGuard**
@@ -510,7 +477,7 @@ declare type Transformer<I extends object, O extends SameKeys<I>, K extends keyo
  * a typing for a **TS** type-guard which evaluates an _unknown_ input
  * and determines if it is of type `T`.
  */
-declare type TypeGuard<T> = (thing: unknown) => thing is T;
+type TypeGuard<T> = (thing: unknown) => thing is T;
 
 /**
  * Allows filtering down `T` to those which extend a given type `U`.
@@ -523,7 +490,7 @@ declare type TypeGuard<T> = (thing: unknown) => thing is T;
  * type BA = Where<typeof arr, `ba${string}`>;
  * ```
  */
-declare type Where<T extends Record<string, any> | readonly string[], U> = T extends readonly string[] ? Include<T[number], U> : {
+type Where<T extends Record<string, any> | readonly string[], U> = T extends readonly string[] ? Include<T[number], U> : {
     [K in keyof T]: K extends U ? K : never;
 }[keyof T];
 /**
@@ -537,40 +504,37 @@ declare type Where<T extends Record<string, any> | readonly string[], U> = T ext
  * type F = WhereNot<typeof arr, `ba${string}`>;
  * ```
  */
-declare type WhereNot<T extends Record<string, any> | readonly string[], U> = T extends readonly string[] ? Exclude<T[number], U> : {
+type WhereNot<T extends Record<string, any> | readonly string[], U> = T extends readonly string[] ? Exclude<T[number], U> : {
     [K in keyof T]: K extends U ? never : K;
 }[keyof T];
 
-declare type AppendToObject<T, U extends keyof any, V> = {
+type AppendToObject<T, U extends keyof any, V> = {
     [K in keyof T | U]: K extends keyof T ? T[K] : V;
 };
 /**
  * Appends a new Key/Value to an existing dictionary <T>
  */
-declare type AppendToDictionary<TDict, TKey extends string, TValue> = {
+type AppendToDictionary<TDict, TKey extends string, TValue> = {
     [K in keyof TDict | TKey]: K extends keyof TDict ? TDict[K] : TValue;
 };
 
 /**
  * Accepts the `true` literal or _undefined_.
  */
-declare type MaybeTrue = true | undefined;
+type MaybeTrue = true | undefined;
 /**
  * Accepts the `false` literal or _undefined_.
  */
-declare type MaybeFalse = false | undefined;
-
-declare type Condition<TInput extends Narrowable, TResult extends boolean> = (input: TInput) => TResult;
-declare const condition: <TInput extends Narrowable, C extends Condition<Narrowable, boolean>>(c: C, input: TInput) => boolean;
+type MaybeFalse = false | undefined;
 
 /**
  * A conditional clause used in the application of the `ifTypeOf` utility
  */
-declare type ExtendsClause<N extends Narrowable, TValue extends Record<keyof TValue, N> | number | string | boolean | symbol> = <TBase extends any>(base: TBase) => TValue extends TBase ? true : false;
+type ExtendsClause<N extends Narrowable, TValue extends Record<keyof TValue, N> | number | string | boolean | symbol> = <TBase extends any>(base: TBase) => TValue extends TBase ? true : false;
 /**
  * A conditional clause used in the application of the `ifTypeOf` utility
  */
-declare type ExtendsNarrowlyClause<N extends Narrowable, TValue extends Record<keyof TValue, N> | number | string | boolean | symbol> = <NB extends Narrowable, TBase extends Record<keyof TBase, NB> | number | string | boolean | symbol>(base: TBase) => TValue extends TBase ? true : false;
+type ExtendsNarrowlyClause<N extends Narrowable, TValue extends Record<keyof TValue, N> | number | string | boolean | symbol> = <NB extends Narrowable, TBase extends Record<keyof TBase, NB> | number | string | boolean | symbol>(base: TBase) => TValue extends TBase ? true : false;
 /**
  * **TypeCondition**
  *
@@ -580,1126 +544,962 @@ declare type ExtendsNarrowlyClause<N extends Narrowable, TValue extends Record<k
  * - `extends` - compares with _wide_ types
  * - `narrowlyExtends` - compares with _narrow_ / _literal_ types
  */
-declare type TypeCondition<N extends Narrowable, TValue extends Record<keyof TValue, N> | number | string | boolean | symbol> = {
+type TypeCondition<N extends Narrowable, TValue extends Record<keyof TValue, N> | number | string | boolean | symbol> = {
     extends: ExtendsClause<N, TValue>;
     narrowlyExtends: ExtendsNarrowlyClause<N, TValue>;
 };
-declare const ifTypeOf: <N extends Narrowable, TValue extends string | number | boolean | symbol | Record<keyof TValue, N>>(val: TValue) => TypeCondition<N, TValue>;
-
-declare type IsArray<T> = T extends any[] ? true : false;
-declare function isArray<T>(i: T): IsArray<T>;
 
-declare type IsBoolean<T> = T extends boolean ? true : false;
+type LowerAlpha = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z";
+/** Uppercase alphabetic character */
+type UpperAlpha = Uppercase<LowerAlpha>;
 /**
- * Runtime and type checks whether a variable is a boolean value.
+ * Alphabetical characters (upper and lower)
  */
-declare function isBoolean<T extends any>(i: T): IsBoolean<T>;
+type Alpha = UpperAlpha | LowerAlpha;
+type Whitespace = " " | "\n" | "\t";
+type Punctuation = "." | "," | ";" | "!" | "?";
 /**
- * **ifBoolean**
- *
- * Strongly type-aware conditional statement which checks whether a value is
- * a _boolean_ and returns one of two values (strongly typed) based on the evaluation
- * of this criteria.
- *
- * @param val the value being tested
- * @param ifVal the value (strongly typed) returned if val is _boolean_
- * @param elseVal the value (strongly typed) returned if val is NOT a _boolean
+ * Characters which typically are used to separate words (but not including a space)
  */
-declare function ifBoolean<T, IF, ELSE>(val: T, ifVal: IF, elseVal: ELSE): IsBoolean<T> extends true ? IF : ELSE;
-
-declare type IsFalse<T extends Narrowable> = IsBoolean<T> extends true ? T extends false ? true : true extends T ? false : unknown : false;
-declare function isFalse<T>(i: T): IsFalse<T>;
+type StringDelimiter = "_" | "-" | "/" | "\\";
+type OpeningBracket = "(" | "[" | "{";
+type ClosingBracket = ")" | "]" | "}";
+/**
+ * Opening and closing parenthesis
+ */
+type Parenthesis = "(" | ")";
+/**
+ * Opening and closing brackets
+ */
+type Bracket = OpeningBracket | ClosingBracket;
+/**
+ * Numeric string characters
+ */
+type NumericString = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
+/**
+ * Any alphabetic or numeric string character
+ */
+type AlphaNumeric = Alpha | NumericString;
+/**
+ * Allows alphanumeric characters and some special characters typically allowed
+ * in variable names.
+ */
+type VariableName = AlphaNumeric | "_" | "." | "-";
+type SpecialCharacters = "@" | "~" | "^" | "#" | "&" | "*";
+/**
+ * Non-alphabetic characters including whitespace, string numerals, and
+ */
+type NonAlpha = Whitespace | Punctuation | NumericString | Bracket | SpecialCharacters;
+type Ipv4 = `${number}.${number}.${number}.${number}`;
 
-declare type IsFunction<T> = T extends FunctionType ? true : false;
 /**
- * Checks whether a passed in value is a function and ensures run-time and types
- * are consistent.
+ * Extracts the _required_ keys in the object's type. You also may
+ * optionally filter by the _value_ of the key.
+ */
+type RequiredKeys<T extends object, V extends any = any> = {
+    [K in keyof T]-?: {} extends {
+        [P in K]: T[K];
+    } ? never : T[K] extends V ? K : never;
+}[keyof T];
+/**
+ * Extracts the intersecting/common keys to two objects
+ */
+type IntersectingKeys<T extends Record<string, any> | readonly string[], U extends Record<string, any> | readonly string[]> = {
+    [K in keyof T]: K extends Keys<U> ? K : never;
+}[keyof T];
+/**
+ * Extracts the _optional_ keys in the object's type. You also may
+ * optionally filter by the _value_ of the key.
+ */
+type OptionalKeys<T extends object, V extends any = any> = {
+    [K in keyof T]-?: {} extends {
+        [P in K]: T[K];
+    } ? V extends T[K] ? K : never : never;
+}[keyof T];
+/**
+ * The _keys_ on a given object `T` which have a literal value of `W`.
+ *
+ * Optionally, you may provide a generic `E` to exclude certain keys in
+ * result set.
  * ```ts
- * // true
- * const yup = isFunction(() => "hello world");
+ * // "foo"
+ * type Str = KeysWithValue<{ foo: "hi"; bar: 5 }>;
  * ```
- *
- * Note: the runtime `typeof [variable]` will correctly say "function" when a function is
- * encountered but if that function also has object types defined then the type will be a big
- * and ugly union type. This function will give you a proper boolean value in both cases.
  */
-declare function isFunction<T extends unknown>(input: T): IsFunction<T>;
-
-declare type IsNull<T> = T extends null ? true : false;
-declare function isNull<T extends Narrowable>(i: T): T extends null ? true : false;
+type KeysWithValue<W extends any, T extends object> = {
+    [K in keyof T]: T[K] extends W ? Readonly<K> : never;
+}[keyof T];
 /**
- * **ifNull**
- *
- * Strongly type-aware conditional statement which checks whether a value is
- * Null and returns one of two values (strongly typed) based on the evaluation
- * of this criteria.
- *
- * @param val the value being tested
- * @param ifVal the value (strongly typed) returned if val is `null`
- * @param elseVal the value (strongly typed) returned if val is NOT `null`
+ * A `PrivateKey` must start with a `_` character and then follow with
+ * an alphabetic character
  */
-declare function ifNull<T extends Narrowable, IF extends Narrowable, ELSE extends Narrowable>(val: T, ifVal: IF, elseVal: ELSE): IsNull<T> extends true ? IF : ELSE;
-
-declare type IsNumber<T> = T extends number ? true : false;
-declare function isNumber<T>(i: T): T extends number ? true : false;
+type PrivateKey = `_${Alpha}${string}`;
 /**
- * **ifNumber**
- *
- * Strongly type-aware conditional statement which checks whether a value is
- * a _number_ and returns one of two values (strongly typed) based on the evaluation
- * of this criteria.
+ * Keys on an object which have a `_` character as first part of the
+ * name are considered private and this utility will create a union
+ * of all the keys in this category.
+ */
+type PrivateKeys<T extends object> = {
+    [K in keyof T]: K extends `_${string}` ? K : never;
+}[keyof T];
+/**
+ * **PublicKeys**
  *
- * @param val the value being tested
- * @param ifVal the value (strongly typed) returned if val is number
- * @param elseVal the value (strongly typed) returned if val is NOT a number
+ * Builds a union type of all keys which are "public" where a public
+ * key is any key which _does not_ start with the `_` character.
  */
-declare function ifNumber<T, IF, ELSE>(val: T, ifVal: IF, elseVal: ELSE): IsNumber<T> extends true ? IF : ELSE;
-
-declare type ObjectType = Not<Record<string, Narrowable>, FunctionType>;
+type PublicKeys<T extends object> = {
+    [K in keyof T]: K extends `_${string}` ? never : K;
+}[keyof T];
+type StringKeys<T extends object> = {
+    [K in keyof T]: K extends string ? Readonly<K> : never;
+}[keyof T];
 /**
- * Detects whether the passed in `v` is of type "object" where an object
- * is defined to be a string keyed dictionary style object. This means that
- * arrays are excluded, as well as functions which also have properties hanging
- * off of them.
+ * The keys of an object which _are not_ a string type
  */
-declare function isObject<T extends unknown>(i: T): IsObject<T>;
-
-declare type IsString<T> = T extends string ? true : false;
-declare function isString<T>(i: T): IsString<T>;
+type NonStringKeys<T extends object> = {
+    [K in keyof T]: K extends string ? never : Readonly<K>;
+}[keyof T];
+type NumericKeys<T extends object> = {
+    [K in keyof T]: K extends number ? Readonly<K> : never;
+}[keyof T];
+type NonNumericKeys<T extends object> = {
+    [K in keyof T]: K extends number ? never : Readonly<K>;
+}[keyof T];
 /**
- * **ifString**
+ * **RequiredProps**
  *
- * Strongly type-aware conditional statement which checks whether a value is
- * a _string_ and returns one of two values (strongly typed) based on the evaluation
- * of this criteria.
+ * Reduces an object type to only key/value pairs where the key is required
+ */
+type RequiredProps<T extends object> = Pick<T, RequiredKeys<T>>;
+/**
+ * **OptionalProps**
  *
- * @param val the value being tested
- * @param ifVal the value (strongly typed) returned if val is _string_
- * @param elseVal the value (strongly typed) returned if val is NOT a _string
+ * Reduces an object to only key/value pairs where the key is optional
  */
-declare function ifString<T extends Narrowable, IF extends Narrowable, ELSE extends Narrowable>(val: T, ifVal: IF, elseVal: ELSE): IsString<T> extends true ? IF : ELSE;
-
-declare function isSymbol<T>(i: T): T extends symbol ? true : false;
-
+type OptionalProps<T extends object> = Pick<T, OptionalKeys<T>>;
 /**
- * Type utility which returns `true` or `false` based on
- * whether the type holds the narrow "true" type.
+ * **WithValue**
+ *
+ * Reduces an object's type down to only those key/value pairs where the
+ * value is of type `W`.
  * ```ts
- * // true
- * type T = IsTrue<true>;
- * // unknown
- * type U = IsTrue<boolean>;
- * // false
- * type F = IsTrue<false>;
- * type F2 = IsTrue<"false">;
+ * const foo = { a: 1, b: "hi", c: () => "hello" }
+ * // { c: () => "hello" }
+ * type W = WithValue<Function, typeof foo>
  * ```
  */
-declare type IsTrue<T> = IsBoolean<T> extends true ? T extends true ? true : T extends false ? false : unknown : false;
+type WithValue<W extends any, T extends object, E extends any = undefined> = undefined extends E ? Pick<T, KeysWithValue<W, T>> : Omit<Pick<T, KeysWithValue<W, T>>, KeysWithValue<E, T>>;
 /**
- * Run-time and type checking of whether a variable is `true`.
+ * Reduces an object to only the key/value pairs where the key is a
+ * string.
  */
-declare function isTrue<T extends Narrowable>(i: T): IsTrue<T>;
+type WithStringKeys<T extends object> = Omit<T, NonStringKeys<T>>;
 /**
- * **ifTrue**
- *
- * Strongly type-aware conditional statement which checks whether a value is
- * a _true_ and returns one of two values (strongly typed) based on the evaluation
- * of this criteria.
- *
- * @param val the value being tested
- * @param ifVal the value (strongly typed) returned if val is _true_ value
- * @param elseVal the value (strongly typed) returned if val is NOT a _true_ value
+ * Reduces an object to only the key/value pairs where the key is numeric.
  */
-declare function ifTrue<T, IF, ELSE>(val: T, ifVal: IF, elseVal: ELSE): IsTrue<T> extends true ? IF : ELSE;
+type WithNumericKeys<T extends object> = Omit<T, NonNumericKeys<T>>;
 
-declare function isUndefined<T extends Narrowable>(i: T): undefined extends T ? true : false;
 /**
- * **ifUndefined**
- *
- * Strongly type-aware conditional statement which checks whether a value is
- * _undefined_ and returns one of two values (strongly typed) based on the evaluation
- * of this criteria.
+ * **RuleDefinition**
  *
- * @param val the value being tested
- * @param ifVal the value (strongly typed) returned if val is `undefined`
- * @param elseVal the value (strongly typed) returned if val is NOT `undefined`
+ * A rule definition is the typing for the fluent API surface that is built up
+ * with the **ruleset** utility.
  */
-declare function ifUndefined<T extends Narrowable, IF extends Narrowable, ELSE extends Narrowable>(val: T, ifVal: IF, elseVal: ELSE): IsUndefined<T> extends true ? IF : ELSE;
-
-declare type Type<T extends any, V extends Function> = {
-    name: string;
-    type: T;
-    typeGuard: TypeGuard<T>;
-    is: V;
-};
-declare const typeApi: () => {
-    readonly string: Type<string, typeof isString>;
-    readonly boolean: Type<boolean, typeof isBoolean>;
-    readonly number: Type<number, typeof isNumber>;
-    readonly function: Type<Function | (Function & {
-        [key: string]: any;
-    }), typeof isFunction>;
-    readonly null: Type<null, typeof isNull>;
-    readonly symbol: Type<symbol, typeof isSymbol>;
-    readonly undefined: Type<undefined, typeof isUndefined>;
-    readonly true: Type<true, typeof isTrue>;
-    readonly false: Type<false, typeof isFalse>;
-    readonly object: Type<Record<string, Narrowable>, typeof isObject>;
-    readonly array: Type<any[], typeof isArray>;
+type RuleDefinition<
+/** the data which will be evaluated on rule execution */
+T extends object, 
+/** the optional props -- as a union type -- which must be defined per the rule */
+H extends string = "", 
+/** the key/values which will be evaluated on execution (wide type) */
+E extends Partial<SameKeys<T>> = {}, 
+/** the key/values which will be evaluated on execution (narrow type) */
+N extends Partial<SameKeys<T>> = {}> = {
+    /**
+     * sets up a true/false check that a given property is defined; this
+     * condition can only be applied to _optional_ properties.
+     */
+    has(optProp: OptionalKeys<T>): RuleDefinition<T, H & typeof optProp, E, N>;
+    /**
+     * Validates that a given property extends a certain value's type; comparison
+     * is made assuming "wide types".
+     */
+    equals<K extends keyof T, V extends Pick<T, K>>(prop: K, value: V): RuleDefinition<T, H, E & Record<K, V>, N>;
+    /**
+     * Validates that a given property extends a certain value's type; comparison
+     * is made assuming "narrow types". This is only available for props which
+     * expose a
+     */
+    narrowlyEquals<K extends keyof T, V extends Pick<T, K>>(prop: K, value: V): RuleDefinition<T, H, E, N & Record<K, V>>;
 };
-declare type TypeApi = ReturnType<typeof typeApi>;
-declare function isType<T extends any, V extends Function>(t: unknown): t is Type<T, V>;
-declare type TypeDefinition<T extends any, V extends Function> = (defn: TypeApi) => Type<T, V>;
-declare function type<T extends any, V extends Function>(fn: TypeDefinition<T, V>): Type<T, V>;
+/**
+ * **DynamicRule**
+ *
+ * A dynamic rule allows type and runtime validation of a data structure
+ * which extends a known `State`. It then returns the literal type `true`
+ * or `false`.
+ *
+ * ```ts
+ * type State = { id?: string; favorite: boolean; color: string };
+ * // type-safe way to check whether optional prop is actually set
+ * const rule: DynamicRule<State> = s => s
+ *  .has("id")
+ *  .equals("favorite", true)
+ *  .equals("color", "red");
+ * ```
+ */
+type DynamicRule<TState extends any, TResult extends true | false> = (rule: TypeCondition<any, TState>) => TResult;
+/**
+ * **DynamicRuleSet**
+ *
+ * A function which accepts the agreed `TState` generic as input and returns a discrete
+ * `true` or `false` value.
+ */
+type DynamicRuleSet<TState extends any, TRules extends Record<string, TypeCondition<any, TState>>> = (rules: TRules) => true | false;
+
+type RuntimeType<T> = {
+    __kind: "type";
+    type: T;
+    is: TypeGuard<T>;
+};
+type RuntimeProp<P extends Readonly<PropertyKey>, T extends RuntimeType<any>> = {
+    __kind: "prop";
+    key: Readonly<P>;
+    valueType: Readonly<T["type"]>;
+    /**
+     * Provides the _type_ to the type system when used with `typeof`.
+     *
+     * ```ts
+     * const t = number();
+     * // number
+     * type T = typeof t.type;
+     * ```
+     *
+     * **Note:** _the runtime system will get a string equivalent name:_
+     * ```ts
+     * const t = number();
+     * // "number"
+     * console.log(t.type);
+     * ```
+     */
+    type: Record<P, T["type"]>;
+    is: TypeGuard<Record<P, T["type"]>>;
+};
+type TypeOptions<T extends Partial<object> = {}> = {
+    /** each type has a default type guard but you can override if you need to be more specific */
+    typeGuard?: TypeGuard<T>;
+} & T;
 
 /**
- * Given a dictionary of key/values, where the value is a function, this
- * type utility will maintain the keys but change the values to whatever
- * the `ReturnType` of the function was.
+ * Validates that a given type extends another and returns `true` or `false` type
+ */
+type ExpectExtends<VALUE, EXPECTED> = EXPECTED extends VALUE ? true : false;
+/**
+ * Validates that a given type extends another and returns `any` or `never` as a type
+ */
+type AssertExtends<VALUE, EXPECTED> = EXPECTED extends VALUE ? any : never;
+/**
+ * Give a type `TValue` and a comparison type `TExtends`
+ */
+type IfExtendsThen<VALUE, EXPECTED, THEN> = EXPECTED extends VALUE ? THEN : never;
+
+/**
+ * Indicates whether `T` has _all_ uppercase characters in it.
  * ```ts
- * const api = {
- *    val: 42,
- *    hi: (name: string) => `hi ${name}`,
- *    bye: (name: string) => `bye ${name}`
- * };
- * // { hi: string; bye: string }
- * type Test = UnwrapValue<typeof api>
- * // { val: number; foo: string; bar: string }
- * type Test2 = UnwrapValue<typeof api, false>
+ * // true
+ * type T = AllCaps<"FOOBAR">;
+ * // false
+ * type T = AllCaps<"FooBar">;
+ * // "unknown"
+ * type T = AllCaps<string>;
  * ```
  */
-declare type DictPartialApplication<T extends Record<string, any>, I extends boolean = true> = SimplifyObject<{
-    [K in keyof T]: T[K] extends (...args: any[]) => any ? Record<K, ReturnType<T[K]>> : true extends I ? never : Record<K, T[K]>;
-}[keyof T]>;
+type AllCaps<T extends string> = string extends T ? "unknown" : T extends Uppercase<T> ? true : false;
 
 /**
- * Allow a dictionary have it's value's type changed to `T` while maintaining the keys in
- * the original object `I` so long as the original value for the KV pair extends `V`.
- *
- * If `V` is not specified then it defaults to _any_ and therefore all KVs are preserved.
+ * **Break<T,D>**
  *
+ * Takes a string `T`, and splits it into a tuple of the form `[F, R]`.
  * ```ts
- * type Obj = { foo: "hello", bar: 42, baz: () => "world" };
- * // { foo: number, bar: number, baz: number };
- * type AllNumbers = DictChangeValue<Obj, number>;
- * // { foo: number }
- * type StringToBool = DictChangeValue<Obj, boolean, string>
+ * // ["the", " long and winding road"]
+ * type T1 = Break<"the long and winding road", " ">;
+ * // ["there", " I was, there I was"]
+ * type T2 = Break<"there I was, there I was", " ">;
  * ```
  */
-declare type DictChangeValue<
-/** the object who's value-type we're changing */
-I extends Record<string, any>, 
-/** the return type that functions should be modified to have */
-T extends any, 
+type Break<T extends string, D extends string> = (string extends T ? [string, string] : (T extends `${infer F}${D}${infer _R}` ? (F extends `${infer _X}${D}${infer _Y}` ? never : (T extends `${F}${infer R}` ? [F, R] : never)) : [T, ""]));
+
 /**
- *The type we expect in the value; if the value extends type `V` then the value will
- * be converted to type `O`; if not then the KV pair will be discarded
+ * Concatenates two arrays (of literals).
+ * ```ts
+ * // [ "foo", "bar", "baz" ]
+ * type T = ArrConcat<["foo"], ["bar", "baz"]>;
+ * ```
  */
-V extends any = any> = SimplifyObject<{
-    [K in keyof I]: I[K] extends V ? Record<K, T> : never;
-}[keyof I]>;
+type ArrConcat<A extends any[], B extends any[]> = [...A, ...B];
 
 /**
- * **DictPrependWithFn**
- *
- * Given a strongly typed object `<T>`, this utility will inject a function call with
- * arguments `<A>` and then return what had subsequently been the value of the property.
+ * Type utility which takes a string `S` and replaces the substring `W` with `P`.
+ * ```ts
+ * const fooy = "fooy";
+ * // "Foo"
+ * type Foo = Replace<typeof fooy, "y", "">;
+ * ```
  *
- * Should you only want to apply this treatment to _some_ of the properties you can
- * pass in a value `<E>` which will ensure that only properties which _extend_ `E` will be
- * modified.
+ * Note: _the first match is replaced and all subsequent matches are ignored_
  */
-declare type DictPrependWithFn<T extends Record<string, any>, A extends any[], E extends any = any> = SimplifyObject<{
-    [K in keyof T]: T[K] extends E ? Record<K, (...args: A) => T[K]> : Record<K, T[K]>;
-}[keyof T]>;
+type Replace<S extends string, W extends string, P extends string> = S extends "" ? "" : W extends "" ? S : S extends `${infer F}${W}${infer E}` ? `${F}${P}${E}` : S;
 
 /**
- * **DictReturnValues**
- *
- * A type utility which receives an object `<T>` and then modifies
- * the return type of any properties which are a function to have this
- * new **ReturnType** `<R>`. Optionally you can specify a particular return type which
- * you are targeting and then
+ * Trims off whitespace on left of string
+ * ```ts
+ * // "foobar "
+ * type T = TrimLeft<"\n\t  foobar ">;
+ * // string
+ * type T = TrimLeft<string>;
+ * ```
  */
-declare type DictReturnValues<
-/** the object which we expect to have props with function values */
-T extends Record<string, any>, 
-/** the return type that functions should be modified to have */
-R extends any, 
-/** optionally this utility can target only functions with a certain existing return value */
-O extends (...args: any[]) => any = (...args: any[]) => any> = SimplifyObject<{
-    [K in keyof T]: T[K] extends O ? T[K] extends (...args: infer A) => any ? Record<K, (...args: A) => R> : Record<K, T[K]> : Record<K, T[K]>;
-}[keyof T]>;
+type TrimLeft<S extends string> = string extends S ? string : S extends `${Whitespace}${infer Right}` ? TrimLeft<Right> : S;
 
 /**
- * Get the type of a property of an object:
+ * Provides the _left_ whitespace of a string
  * ```ts
- * const car = { make: "Chevy", model: "Malibu", }
+ * // "\n\t "
+ * type T = LeftWhitespace<"\n\t foobar">;
  * ```
  */
-declare type Get<T, K> = K extends `${infer FK}.${infer L}` ? FK extends keyof T ? Get<T[FK], L> : never : K extends keyof T ? T[K] : never;
+type LeftWhitespace<S extends string> = string extends S ? string : Replace<S, TrimLeft<S>, "">;
 
 /**
- * Expresses whether an option is "opt" (optional) or "req" (required)
+ * Trims off whitespace on left of string
+ * ```ts
+ * // "\n foobar"
+ * type T = TrimRight<"\n foobar \t">;
+ * // string
+ * type T = TrimRight<string>;
+ * ```
  */
-declare type OptRequired = "opt" | "req";
+type TrimRight<S extends string> = string extends S ? string : S extends `${infer Right}${Whitespace}` ? TrimRight<Right> : S;
 
-declare const DEFAULT_ONE_TO_MANY_MAPPING: FinalizedMapConfig<"req", "I -> O[]", "opt">;
-declare const DEFAULT_ONE_TO_ONE_MAPPING: FinalizedMapConfig<"req", "I -> O", "req">;
-declare const DEFAULT_MANY_TO_ONE_MAPPING: FinalizedMapConfig<"req", "I[] -> O", "req">;
-declare type DefaultOneToManyMapping = typeof DEFAULT_ONE_TO_MANY_MAPPING;
-declare type DefaultOneToOneMapping = typeof DEFAULT_ONE_TO_ONE_MAPPING;
-declare type DefaultManyToOneMapping = typeof DEFAULT_MANY_TO_ONE_MAPPING;
 /**
- * **mapTo** _utility_
- *
- * This utility -- by default -- creates a strongly typed 1:M data mapper which maps from one
- * known source `I` to any array of another `O[]`:
+ * Provides the _left_ whitespace of a string
  * ```ts
- * const mapper = mapTo<I, O>(i => [{
- *    foo: i.bar
- * }]);
+ * // "\n\t "
+ * type T = LeftWhitespace<"\n\t foobar">;
  * ```
  */
-declare const mapToFn: ConfiguredMap<DefaultOneToManyMapping>["map"];
+type RightWhitespace<S extends string> = string extends S ? string : Replace<S, TrimRight<S>, "">;
+
 /**
- * Provides a `config` method which allows the relationships between _inputs_
- * and _outputs_ to be configured.
+ * Type utility that provides the _length_ of a given string type in a way which
+ * is _not_ limited to TS's recursive string length of roughly 48.
+ *
+ * ```ts
+ * // 3
+ * type Three = StringLength<"foo">;
+ * ```
  */
-declare const mapToDict: MapperApi;
+type StringLength<S extends string, R extends number[] = []> = S extends `${infer _First}${infer _Second}${infer _Third}${infer _Fourth}${infer _Fifth}${infer _Sixth}${infer _Sevebnth}${infer _Eighth}${infer _Ninth}${infer _Tenth}${infer Rest}` ? StringLength<Rest, [...R, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]> : S extends `${infer _First}${infer _Second}${infer _Third}${infer _Fourth}${infer _Fifth}${infer _Sixth}${infer _Sevebnth}${infer _Eighth}${infer _Ninth}${infer Rest}` ? StringLength<Rest, [...R, 1, 1, 1, 1, 1, 1, 1, 1, 1]> : S extends `${infer _First}${infer _Second}${infer _Third}${infer _Fourth}${infer _Fifth}${infer _Sixth}${infer _Sevebnth}${infer _Eighth}${infer Rest}` ? StringLength<Rest, [...R, 1, 1, 1, 1, 1, 1, 1, 1]> : S extends `${infer _First}${infer _Second}${infer _Third}${infer _Fourth}${infer _Fifth}${infer _Sixth}${infer _Sevebnth}${infer Rest}` ? StringLength<Rest, [...R, 1, 1, 1, 1, 1, 1, 1]> : S extends `${infer _First}${infer _Second}${infer _Third}${infer _Fourth}${infer _Fifth}${infer _Sixth}${infer Rest}` ? StringLength<Rest, [...R, 1, 1, 1, 1, 1, 1]> : S extends `${infer _First}${infer _Second}${infer _Third}${infer _Fourth}${infer _Fifth}}${infer Rest}` ? StringLength<Rest, [...R, 1, 1, 1, 1, 1]> : S extends `${infer _First}${infer _Second}${infer _Third}${infer _Fourth}${infer Rest}` ? StringLength<Rest, [...R, 1, 1, 1, 1]> : S extends `${infer _First}${infer _Second}${infer _Third}${infer Rest}` ? StringLength<Rest, [...R, 1, 1, 1]> : S extends `${infer _First}${infer _Second}${infer Rest}` ? StringLength<Rest, [...R, 1, 1]> : S extends `${infer _First}${infer Rest}` ? StringLength<Rest, [...R, 1]> : [...R]["length"];
+
 /**
- * **mapTo** _utility_
- *
- * This utility creates a strongly typed data mapper which maps from one
- * known source `I` to another `O`.
- *
- * Signatures:
+ * Trims off blank spaces, `\n` and `\t` characters from both sides of a _string literal_.
  * ```ts
- * const defMap = mapTo<I,O>( ... );
- * const configured = mapTo.config({ output: "req" }).map<I,O>( ... );
- * const one2one = mapTo.oneToOne().map<I,O>( ... );
- * const many2one = mapTo.manyToOne().map<I,O>( ... );
+ * // "foobar"
+ * type T = Trim<"\n\t  foobar ">;
+ * // string
+ * type T = Trim<string>;
  * ```
  */
-declare const mapTo: (<I, O>(map: (source: I) => O[]) => Mapper<I, O, FinalizedMapConfig<"req", "I -> O[]", "opt">>) & MapperApi;
+type Trim<S extends string> = string extends S ? string : S extends `${Whitespace}${infer Right}` ? Trim<Right> : S extends `${infer Left}${Whitespace}` ? Trim<Left> : S;
 
 /**
- * Expresses relationship between inputs/outputs:
+ * An email address
  */
-declare enum MapCardinality {
-    /** every input results in 0:M outputs */
-    OneToMany = "I -> O[]",
-    /** every input results in 0:1 outputs */
-    OneToOne = "I -> O",
-    /** every input is an array of type I and reduced to a single O  */
-    ManyToOne = "I[] -> O"
-}
-declare type MapCardinalityIllustrated = EnumValues<MapCardinality>;
+type Email = `${string}@${string}.${string}`;
+type Zip5 = `${NumericString}${NumericString}${string}${NumericString}`;
+type Zip4 = `${NumericString}${string}`;
 /**
- * The _user_ configuration of a **mapTo** mapper function
- * which will be finalized by merging it with the appropriate
- * default mapping type.
+ * A relatively strong type for Zip5 or Zip5+4 zip codes
  */
-interface MapConfig<IR extends OptRequired | undefined = undefined, D extends MapCardinalityIllustrated | undefined = undefined, OR extends OptRequired | undefined = undefined> {
-    input?: IR;
-    output?: OR;
-    cardinality?: D;
-    /**
-     * Whether calls to the final `MapFn` will be logged to stderr
-     * for debugging purposes. Defaults to false; if you specify
-     * a _string_ for a value that will be sent to stderr along
-     * with other debugging info.
-     */
-    debug?: boolean | string;
-}
+type ZipCode = Zip5 | `${Zip5}-${Zip4}`;
+
 /**
- * A finalized configuration of a **mapTo** mapper functions cardinality
- * relationships between _inputs_ and _outputs_.
- *
- * Note: _this configuration does _not_ yet include the actual mapping
- * configuration between the input and output._
- */
-declare type FinalizedMapConfig<IR extends OptRequired = MapIR<DefaultOneToManyMapping>, D extends MapCardinalityIllustrated = MapCard<DefaultOneToManyMapping>, OR extends OptRequired = MapOR<DefaultOneToManyMapping>> = Required<Omit<MapConfig<IR, D, OR>, "debug">> & {
-    finalized: true;
-    debug: boolean | string;
-};
+ * If **ALL CAPS** it converts to all lowercase; if not then it does nothing */
+type LowerAllCaps<T extends string> = AllCaps<T> extends true ? Lowercase<T> : T;
+
+type Delimiter = "_" | "-" | " ";
+/** 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;
 /**
- * User configuration exposed by a config function which specifies the
- * cardinality already (e.g., `oneToMany()`, `manyToOne()`)
+ * Converts a string literal type to a **PascalCase** representation.
+ * ```ts
+ * // "FooBar"
+ * type T = PascalCase<"fooBar">;
+ * type T = PascalCase<"foo-bar">;
+ * type T = PascalCase<"foo_bar">;
+ * type T = PascalCase<"\n foo_bar \t">;
+ * ```
  */
-declare type MapCardinalityConfig<IR extends OptRequired | undefined, OR extends OptRequired | undefined> = {
-    /** whether we the input can _optionally_ be an `undefined` value or not */
-    input?: IR;
-    /** whether we the output can _optionally_ be an `undefined` value or not */
-    output?: OR;
-    /**
-     * Whether calls to the final `MapFn` will be logged to stderr
-     * for debugging purposes. Defaults to false; if you set to a string
-     * value than this will be echoed out with stderr.
-     */
-    debug?: boolean | string;
-};
+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 CamelCase<S extends string> = string extends S ? string : Uncapitalize<PascalCase<S>>;
+
 /**
- * **ConfiguredMap**
- *
- * A partial application of the mapTo() utility which has expressed the
- * configuration of the _inputs_ and _outputs_ and provides a `.map()`
- * method which allows the user configure the specifics of the mapping.
+ * Capitalize all words in a string
  */
-declare type ConfiguredMap<C extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>> = {
-    map: <I, O>(map: MapTo<I, O, C>) => Mapper<I, O, C>;
-    input: MapIR<C>;
-    cardinality: MapCard<C>;
-    output: MapOR<C>;
-    debug: boolean | string;
-};
+type CapitalizeWords<S extends string> = S extends `${infer L} ${infer R}` ? `${CapitalizeWords<L>} ${CapitalizeWords<R>}` : S extends `${infer L},${infer R}` ? `${CapitalizeWords<L>},${CapitalizeWords<R>}` : S extends `${infer L}.${infer R}` ? `${CapitalizeWords<L>}.${CapitalizeWords<R>}` : Capitalize<S>;
+
+type DashToSnake<T extends string> = T extends `${infer HEAD}-${infer TAIL}` ? DashToSnake<`${HEAD}_${TAIL}`> : T;
+
 /**
- * Extracts the IR, Cardinality, and OR generics from a FinalizedMapConfig
+ * Indicates whether `T` has uppercase characters in it.
+ * ```ts
+ * // true
+ * type T = HasUppercase<"Foobar">;
+ * // false
+ * type T = HasUppercase<"foobar">;
+ * // "unknown"
+ * type T = HasUppercase<string>;
+ * ```
  */
-declare type DecomposeMapConfig<M extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>> = M extends MapConfig<infer IR, infer D, infer OR> ? IR extends OptRequired | undefined ? D extends MapCardinalityIllustrated | undefined ? OR extends OptRequired | undefined ? [IR, D, OR] : never : never : never : M extends FinalizedMapConfig<infer IR, infer D, infer OR> ? IR extends OptRequired ? D extends MapCardinalityIllustrated ? OR extends OptRequired ? [IR, D, OR] : never : never : never : never;
-/** extracts IR from a `FinalizedMapConfig` */
-declare type MapIR<T extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>> = DecomposeMapConfig<T>[0];
+type HasUppercase<T extends string> = string extends T ? "unknown" : T extends `${string}${UpperAlpha}${string}` ? true : false;
+
+type _DU<T extends string> = T extends Lowercase<T> ? T : `-${Lowercase<T>}`;
 /**
- * extracts the MapCardinality from a `FinalizedMapConfig`
+ * Converts uppercase characters to a dash and then the lowercase equivalent
+ * ```ts
+ * // "one-two-three"
+ * type T = DashUppercase<"oneTwoThree">;
+ * ```
+ *
+ * _Intended to be used as a lower level utility; prefer `Dasherize<T>` for more full-fledged
+ * dash solution_.
  */
-declare type MapCard<T extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>> = DecomposeMapConfig<T>[1];
-/** extracts OR from a `FinalizedMapConfig` */
-declare type MapOR<T extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>> = DecomposeMapConfig<T>[2];
+type DashUppercase<T extends string> = HasUppercase<T> extends false ? T : T extends `${infer C0}${infer C1}${infer R}` ? `${_DU<C0>}${_DU<C1>}${DashUppercase<R>}` : T extends `${infer C0}${infer R}` ? `${_DU<C0>}${DashUppercase<R>}` : "";
+
+type OneToOne = `1:1`;
+type OneToMany = `1:M`;
+type OneToZero = `1:0`;
+type ZeroToOne = `0:1`;
+type ZeroToMany = `0:M`;
+type ZeroToZero = `0:0`;
+type ManyToMany = "M:M";
+type ManyToOne = "M:1";
+type ManyToZero = "M:0";
+type CardinalityNode = "0" | "1" | "M";
 /**
- * Merges the types of a userland configuration with a default configuration
+ * Cardinality which expects a singular input and requires
+ * 1 or many outputs.
+ *
+ * Note: choose `CardinalityFilter1` if you want to allow output
+ * to have no outputs.
  */
-declare type AsFinalizedConfig<U extends MapConfig<OptRequired | undefined, MapCardinalityIllustrated | undefined, OptRequired | undefined>, D extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>> = TypeDefault<U, D> extends FinalizedMapConfig<infer IR, infer C, infer OR> ? FinalizedMapConfig<IR, C, OR> : never;
-declare type MapperApi = {
-    /**
-     * Provides opportunity to configure _input_, _output_, and _cardinality_
-     * prior to providing a mapping function.
-     *
-     * Note: _the defaults for configuration are defined by the_ `DEFAULT_ONE_TO_MANY_MAPPING`
-     * _constant made available as a symbol from this library._
-     */
-    config: <C extends MapConfig<OptRequired, //
-    MapCardinalityIllustrated, OptRequired>>(config: C) => ConfiguredMap<AsFinalizedConfig<C, //
-    DefaultOneToManyMapping>>;
-    /**
-     * Provides a nice 1:1 ratio between the input and output.
-     *
-     * By default the input and output are considered to be _required_
-     * properties but this can be changed with the options hash provided.
-     * ```ts
-     * const mapper = mapTo.oneToOne().map(...);
-     * // add in ability to filter out some inputs
-     * const mapAndFilter = mapTo.oneToOne({ output: "opt" })
-     * ```
-     */
-    oneToOne: <C extends MapCardinalityConfig<OptRequired, OptRequired>>(config?: C) => ConfiguredMap<AsFinalizedConfig<C, //
-    DefaultOneToOneMapping>>;
-    /**
-     * **manyToOne** _mapping_
-     *
-     * Provides a configuration where multiple inputs `I[]` will be mapped to a
-     * single output `O`.
-     *
-     * Choosing this configuration will, by default, set both input and output
-     * to be "required" but you can change this default if you so choose.
-     */
-    manyToOne: <C extends MapCardinalityConfig<OptRequired | undefined, //
-    //
-    OptRequired | undefined>>(config?: C) => ConfiguredMap<AsFinalizedConfig<C, //
-    DefaultManyToOneMapping>>;
-    oneToMany: <C extends MapCardinalityConfig<OptRequired | undefined, //
-    //
-    OptRequired | undefined>>(config?: C) => ConfiguredMap<AsFinalizedConfig<C, //
-    DefaultOneToManyMapping>>;
-};
-declare type MapInput<I, //
-IR extends OptRequired, C extends MapCardinalityIllustrated> = C extends MapCardinality.OneToMany | "I -> O[]" ? IR extends "opt" ? I | undefined : I : C extends MapCardinality.OneToOne | "I -> O" ? IR extends "opt" ? I | undefined : I : C extends MapCardinality.ManyToOne | "I[] -> O" ? IR extends "opt" ? I[] | undefined : I[] : never;
-declare type MapOutput<O, //
-OR extends OptRequired, C extends MapCardinalityIllustrated> = C extends MapCardinality.OneToMany | "I -> O[]" ? OR extends "opt" ? O[] : [O, ...O[]] : C extends MapCardinality.OneToOne | "I -> O" ? OR extends "opt" ? O | null : O : C extends MapCardinality.ManyToOne | "I[] -> O" ? OR extends "opt" ? O | null : O : never;
+type Cardinality1 = OneToOne | OneToMany;
 /**
- * **MapTo<I, O>**
- *
- * A mapping function between an input type `I` and output type `O`. Defaults to using
- * the _default_ OneToMany mapping config.
- *
- * **Note:** this type is designed to guide the userland mapping; refer
- * to `MapFn` if you want the type output by the `mapFn()` utility.
+ * Cardinality which expects a singular input and maps to 0,
+ * 1, or many outputs.
  */
-declare type MapTo<I, O, C extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired> = DefaultOneToManyMapping> = MapIR<C> extends "opt" ? (source?: MapInput<I, MapIR<C>, MapCard<C>>) => MapOutput<O, MapOR<C>, MapCard<C>> : (source: MapInput<I, MapIR<C>, MapCard<C>>) => MapOutput<O, MapOR<C>, MapCard<C>>;
-declare type MapFnOutput<I, O, S, OR extends OptRequired, C extends MapCardinalityIllustrated> = C extends "I -> O[]" | MapCardinality.OneToMany ? S extends I[] ? OR extends "opt" ? O[] : [O, ...O[]] : OR extends "opt" ? O[] | null : O[] : C extends MapCardinality.OneToOne | "I -> O" ? S extends I[] ? OR extends "opt" ? O[] : [O, ...O[]] : OR extends "opt" ? O | null : O : C extends MapCardinality.ManyToOne | "I[] -> O" ? S extends I[][] ? OR extends "opt" ? O[] : [O, ...O[]] : OR extends "opt" ? O | null : O : never;
-declare type MapFnInput<I, IR extends OptRequired, D extends MapCardinalityIllustrated> = D extends "I -> O[]" | MapCardinality.OneToMany ? IR extends "opt" ? I | I[] | undefined : I | I[] : D extends MapCardinality.OneToOne | "I -> O" ? IR extends "opt" ? I | I[] | undefined : I | I[] : D extends MapCardinality.ManyToOne | "I[] -> O" ? IR extends "opt" ? I[] | I[][] | undefined : I[] | I[][] : never;
+type CardinalityFilter1 = OneToOne | OneToMany | OneToZero;
 /**
- * The mapping function provided by the `mapFn()` utility. This _fn_
- * is intended to be used in two ways:
- *
- * 1. Iterative:
- *    ```ts
- *    const m = mapTo<I,O>(i => [ ... ]);
- *    // maps inputs to outputs
- *    const out = inputs.map(m);
- *    ```
- * 2. Block:
- *    ```ts
- *    // maps inputs to outputs (filtering or splitting where appr.)
- *    const out2 = m(inputs);
- *    ```
+ * Cardinality which expects a singular input which is allowed to be
+ * _undefined_ or the expected type.
  */
-declare type MapFn<I, O, C extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>> = MapIR<C> extends "opt" ? <S extends MapFnInput<I, MapIR<C>, MapCard<C>>>(source?: S) => MapFnOutput<I, O, S, MapOR<C>, MapCard<C>> : <S extends MapFnInput<I, MapIR<C>, MapCard<C>>>(source: S) => MapFnOutput<I, O, S, MapOR<C>, MapCard<C>>;
+type Cardinality0 = ZeroToOne | ZeroToMany | OneToOne | OneToMany;
 /**
- * **Mapper**
- *
- * A fully configured _mapper_ stemming from the **mapTo()** utility. It is both a mapping
- * function and a dictionary which describes the mapper's properties.
- * ```ts
- * const m = mapTo.oneToOne().map( ... );
- * const mapped = m(inputs);
- * const mappedOver = inputs.map(m);
- * ```
- *
- * Note: the root of a `Mapper` is the mapper function but
- * this is combined with a dictionary of settings and types
- * which you can use. For instance, look at the `fnSignature`
- * property to get the _type_ signature of the map function.
+ * Cardinality which expects a singular input -- which is allowed to be
+ * _undefined_ -- and maps to 0,
+ * 1, or many outputs.
  */
-declare type Mapper<I = unknown, O = unknown, C extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired> = FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>> = {
-    input: MapIR<C>;
-    output: MapOR<C>;
-    cardinality: MapCard<C>;
-    debug: boolean | string;
-    inputType: I;
-    outputType: O;
-    /**
-     * Provides the _type_ information for mapper function.
-     *
-     * Note: _this is just a **type**_ not the actual function which positioned
-     * at the root of the Mapper type
-     */
-    fnSignature: MapFn<I, O, C>;
-} & MapFn<I, O, C>;
+type CardinalityFilter0 = ZeroToOne | ZeroToMany | OneToOne | OneToMany | OneToZero | ZeroToZero;
+type CardinalityExplicit = `${number}:${number}`;
 /**
- * **MapInputFrom**
- *
- * Type utility which extracts the `I` type from a fully configured `Mapper`
+ * Cardinality of any sort between two types
  */
-declare type MapInputFrom<T extends Mapper> = T extends Mapper<infer I> ? I : never;
+type Cardinality = CardinalityFilter0 | CardinalityFilter1 | ManyToMany | ManyToOne | ManyToZero | CardinalityExplicit;
+type CardinalityTuple<T extends Cardinality> = UnionToTuple<T>;
 /**
- * **MapOutputFrom**
- *
- * Type utility which extracts the output [`O`] type from a fully configured `Mapper`
+ * The first or _input_ part of the Cardinality relationship
  */
-declare type MapOutputFrom<T extends Mapper> = T extends Mapper<any, infer O> ? O : never;
+type CardinalityIn<T extends Cardinality> = T extends `${infer IN}:${string}` ? IN : never;
 /**
- * **MapCardinalityFrom**
- *
- * Type utility which extracts _cardinality_ of a `Mapper`'s inputs to outputs
+ * The second or _output_ part of the Cardinality relationship
  */
-declare type MapCardinalityFrom<T extends Mapper> = T extends Mapper<any, any, infer C> ? C extends FinalizedMapConfig<OptRequired, infer Cardinality, OptRequired> ? Cardinality : never : never;
+type CardinalityOut<T extends Cardinality> = T extends `${string}:${infer OUT}` ? OUT : never;
+type CardinalityInput<T, C extends Cardinality> = CardinalityTuple<C>[0] extends 0 ? T | undefined : CardinalityTuple<C>[0] extends 1 ? T : T[];
 
 /**
- * Given a dictionary of type `<T>`, this utility function will
- * make the `<M>` generic property _mutable_ and all other _read-only_.
+ * Converts a string literal into a _dasherized_ format while ignoring _exterior_ whitespace.
  *
  * ```ts
- * // { foo: string, bar?: Readonly<number> }
- * type Example = MutableProps<{
- *    foo: Readonly<string>,
- *    bar?: number
- * }, "foo">;
+ * // "foo-bar"
+ * type Dash = Dasherize<"foo_bar">;
+ * type Dash = Dasherize<"fooBar">;
+ * type Dash = Dasherize<"FooBar">;
+ * // "\n  foo-bar \t"
+ * type Dash = Dasherize<"\n  foo bar \t">;
  * ```
  */
-declare type MutableProps<T extends {}, M extends keyof T & string> = ExpandRecursively<Mutable<Pick<T, M>> & Readonly<Pick<T, Keys<T, M>>>>;
+type Dasherize<S extends string> = string extends S ? string : DashUppercase<Trim<LowerAllCaps<S>>> extends `${infer Begin}${"_" | " "}${infer Rest}` ? Dasherize<`${Lowercase<Begin>}-${Rest}`> : Lowercase<DashUppercase<Uncapitalize<Trim<LowerAllCaps<S>>>>>;
 
 /**
- * Given a dictionary of type `<T>`, this utility function will
- * make the `<R>` generic property _required_ (use a union to make
- * more than one prop required).
- *
+ * Returns true or false value based on whether the string literal is capitalized.
  * ```ts
- * // { foo: string, bar?: number }
- * type Example = RequireProps<{foo?: string, bar?: number}, "foo">;
+ * // true
+ * type T2 = IsCapitalized<"One">;
+ * // false
+ * type T1 = IsCapitalized<"one">;
+ * // "unknown"
+ * const a: string = "Hi";
+ * type T3 = IsCapitalized<typeof a>;
  * ```
+ *
+ * Note: _if the value passed in is a "string" then the result will be "unknown"_
  */
-declare type RequireProps<T extends {}, R extends keyof T> = ExpandRecursively<Required<Pick<T, R>> & T>;
+type IsCapitalized<T extends string> = string extends T ? "unknown" : T extends Capitalize<T> ? true : false;
 
-declare type LowerAlpha = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z";
-/** Uppercase alphabetic character */
-declare type UpperAlpha = Uppercase<LowerAlpha>;
 /**
- * Alphabetical characters (upper and lower)
- */
-declare type Alpha = UpperAlpha | LowerAlpha;
-declare type Whitespace = " " | "\n" | "\t";
-declare type Punctuation = "." | "," | ";" | "!" | "?";
+ * **KebabCase<T>** is an _alias_ for **Dasherize<T>**.
+ * ```ts
+ * // "foo-bar"
+ * type Kebab = KebabCase<"foo_bar">;
+ * type Kebab = KebabCase<"fooBar">;
+ * type Kebab = KebabCase<"FooBar">;
+ * // "\n  foo-bar \t"
+ * type Kebab = KebabCase<"\n  foo bar \t">;
+ * ``` */
+type KebabCase<T extends string> = Dasherize<T>;
+
+type Consonant = "b" | "c" | "d" | "f" | "g" | "h" | "j" | "k" | "l" | "m" | "n" | "p" | "q" | "r" | "s" | "t" | "v" | "w" | "x" | "z" | "y";
+type Exceptions = "photo => photos" | "piano => pianos" | "halo => halos" | "foot => feet" | "man => men" | "woman => women" | "person => people" | "mouse => mice" | "series => series" | "sheep => sheep" | "money => monies" | "deer => deer";
+type SingularException<T = Exceptions> = T extends `${infer SINGULAR} => ${infer PLURAL}` ? SINGULAR : never;
+type PluralException<T extends SingularException, E extends Exceptions = Exceptions> = E extends `${T} => ${infer PLURAL}` ? PLURAL : never;
+type SingularNoun = "s" | "sh" | "ch" | "x" | "z" | "o";
+type F = "f" | "fe";
+type Y = `${Consonant}y`;
+type RemoveTrailingY<T> = T extends `${infer HEAD}y` ? HEAD : T;
+/** validates that a word ends with a pluralization exception */
+type isException<T extends string> = T extends SingularException ? T : never;
+/** validates that a string literal ends in "is" */
+type EndsIn_IS<T extends string> = T extends `${infer HEAD}is` ? T : never;
+/** validates that a string literal is a singular noun */
+type EndsInSingularNoun<T extends string> = T extends `${infer HEAD}${SingularNoun}` ? T : never;
+/** validates that a string literal ends in "f" or "fe" */
+type EndsIn_F<T extends string> = T extends `${infer HEAD}${F}` ? T : never;
+/** validates that a string literal ends a consonant followed by "y" */
+type EndsIn_Y<T extends string> = T extends `${infer HEAD}${Y}` ? T : never;
 /**
- * Characters which typically are used to separate words (but not including a space)
+ * strings which end in the letters "is" should have an "es" added to the end
  */
-declare type StringDelimiter = "_" | "-" | "/" | "\\";
-declare type OpeningBracket = "(" | "[" | "{";
-declare type ClosingBracket = ")" | "]" | "}";
+type PluralizeEndingIn_IS<T extends string> = T extends `${infer HEAD}is` ? `${HEAD}ises` : T;
 /**
- * Opening and closing parenthesis
+ * singular nouns should have "es" added to the end
  */
-declare type Parenthesis = "(" | ")";
+type PluralizeEndingSingularNoun<T extends string> = T extends `${infer HEAD}${SingularNoun}` ? `${T}es` : T;
 /**
- * Opening and closing brackets
+ * strings which end in the letters "f" or "fe" should have "ves" replace the ending
  */
-declare type Bracket = OpeningBracket | ClosingBracket;
+type PluralizeEnding_F<T extends string> = T extends `${infer HEAD}${F}` ? `${HEAD}ves` : T;
 /**
- * Numeric string characters
+ * singular nouns should have "es" added to the end
  */
-declare type NumericString = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
+type PluralizeEndingIn_Y<T extends string> = T extends `${infer HEAD}${Y}` ? `${RemoveTrailingY<T>}ies` : T;
+type Pluralize<T extends string> = T extends isException<T> ? PluralException<T> : T extends EndsIn_IS<T> ? PluralizeEndingIn_IS<T> : T extends EndsInSingularNoun<T> ? PluralizeEndingSingularNoun<T> : T extends EndsIn_F<T> ? PluralizeEnding_F<T> : T extends EndsIn_Y<T> ? PluralizeEndingIn_Y<T> : `${T}s`;
+
+/** convert space to dash */
+type SpaceToDash<T extends string> = T extends `${infer Begin}${" "}${infer Rest}` ? SpaceToDash<`${Begin}-${Rest}`> : T;
 /**
- * Any alphabetic or numeric string character
- */
-declare type AlphaNumeric = Alpha | NumericString;
-declare type SpecialCharacters = "@" | "~" | "^" | "#" | "&" | "*";
-/**
- * Non-alphabetic characters including whitespace, string numerals, and
- */
-declare type NonAlpha = Whitespace | Punctuation | NumericString | Bracket | SpecialCharacters;
+ * Converts a string literal type to _snake_case_.
+ * ```ts
+ * // "foo_bar"
+ * type T = SnakeCase<"fooBar">;
+ * type T = SnakeCase<"FooBar">;
+ * type T = SnakeCase<"foo-bar">;
+ * type T = SnakeCase<"\n foo bar \t">;
+ * ``` */
+type SnakeCase<S extends string> = string extends S ? string : DashUppercase<Uncapitalize<SpaceToDash<Trim<LowerAllCaps<S>>>>> extends `${infer Begin}${"-"}${infer Rest}` ? SnakeCase<`${Lowercase<Begin>}_${Rest}`> : Lowercase<DashUppercase<Uncapitalize<Trim<LowerAllCaps<S>>>>>;
 
+type NetworkProtocol = "http" | "https" | "file" | "ws" | "wss";
 /**
- * Extracts the _required_ keys in the object's type. You also may
- * optionally filter by the _value_ of the key.
+ * A literal variant of _string_ which is meant to represent a domain name
+ * (e.g., `www.someplace.com`, etc.)
  */
-declare type RequiredKeys<T extends object, V extends any = any> = {
-    [K in keyof T]-?: {} extends {
-        [P in K]: T[K];
-    } ? never : T[K] extends V ? K : never;
-}[keyof T];
+type DomainName = `${AlphaNumeric}${string}.${AlphaNumeric}${string}` | `${AlphaNumeric}${string}.${AlphaNumeric}${string}.${string}` | `${AlphaNumeric}${string}.${AlphaNumeric}${string}.${string}.${string}`;
+type RelativeUrl = `${VariableName | "/"}`;
 /**
- * Extracts the intersecting/common keys to two objects
+ * A literal variant of _string_ which forces a string to follow conventions
+ * for a fully qualified URL like `https://google.com`. It can't ensure the
+ * type is fully valid but does help to avoid some typos.
  */
-declare type IntersectingKeys<T extends Record<string, any> | readonly string[], U extends Record<string, any> | readonly string[]> = {
-    [K in keyof T]: K extends Keys<U> ? K : never;
-}[keyof T];
+type FullyQualifiedUrl = `${NetworkProtocol}://${Ipv4 | DomainName}/${string}`;
+type UrlBuilder = (<P extends NetworkProtocol, D extends DomainName, B extends RelativeUrl>(protocol: P, domain: D, basePath: B) => `${P}://${D}/${B}`) | (<U extends RelativeUrl>(url: U) => U);
+
 /**
- * Extracts the _optional_ keys in the object's type. You also may
- * optionally filter by the _value_ of the key.
+ * Given a dictionary of key/values, where the value is a function, this
+ * type utility will maintain the keys but change the values to whatever
+ * the `ReturnType` of the function was.
+ * ```ts
+ * const api = {
+ *    val: 42,
+ *    hi: (name: string) => `hi ${name}`,
+ *    bye: (name: string) => `bye ${name}`
+ * };
+ * // { hi: string; bye: string }
+ * type Test = UnwrapValue<typeof api>
+ * // { val: number; foo: string; bar: string }
+ * type Test2 = UnwrapValue<typeof api, false>
+ * ```
  */
-declare type OptionalKeys<T extends object, V extends any = any> = {
-    [K in keyof T]-?: {} extends {
-        [P in K]: T[K];
-    } ? V extends T[K] ? K : never : never;
-}[keyof T];
+type DictPartialApplication<T extends Record<string, any>, I extends boolean = true> = SimplifyObject<{
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? Record<K, ReturnType<T[K]>> : true extends I ? never : Record<K, T[K]>;
+}[keyof T]>;
+
 /**
- * The _keys_ on a given object `T` which have a literal value of `W`.
+ * Allow a dictionary have it's value's type changed to `T` while maintaining the keys in
+ * the original object `I` so long as the original value for the KV pair extends `V`.
+ *
+ * If `V` is not specified then it defaults to _any_ and therefore all KVs are preserved.
  *
- * Optionally, you may provide a generic `E` to exclude certain keys in
- * result set.
  * ```ts
- * // "foo"
- * type Str = KeysWithValue<{ foo: "hi"; bar: 5 }>;
+ * type Obj = { foo: "hello", bar: 42, baz: () => "world" };
+ * // { foo: number, bar: number, baz: number };
+ * type AllNumbers = DictChangeValue<Obj, number>;
+ * // { foo: number }
+ * type StringToBool = DictChangeValue<Obj, boolean, string>
  * ```
  */
-declare type KeysWithValue<W extends any, T extends object> = {
-    [K in keyof T]: T[K] extends W ? Readonly<K> : never;
-}[keyof T];
-/**
- * A `PrivateKey` must start with a `_` character and then follow with
- * an alphabetic character
- */
-declare type PrivateKey = `_${Alpha}${string}`;
+type DictChangeValue<
+/** the object who's value-type we're changing */
+I extends Record<string, any>, 
+/** the return type that functions should be modified to have */
+T extends any, 
 /**
- * Keys on an object which have a `_` character as first part of the
- * name are considered private and this utility will create a union
- * of all the keys in this category.
+ *The type we expect in the value; if the value extends type `V` then the value will
+ * be converted to type `O`; if not then the KV pair will be discarded
  */
-declare type PrivateKeys<T extends object> = {
-    [K in keyof T]: K extends `_${string}` ? K : never;
-}[keyof T];
+V extends any = any> = SimplifyObject<{
+    [K in keyof I]: I[K] extends V ? Record<K, T> : never;
+}[keyof I]>;
+
 /**
- * **PublicKeys**
+ * **DictPrependWithFn**
  *
- * Builds a union type of all keys which are "public" where a public
- * key is any key which _does not_ start with the `_` character.
+ * Given a strongly typed object `<T>`, this utility will inject a function call with
+ * arguments `<A>` and then return what had subsequently been the value of the property.
+ *
+ * Should you only want to apply this treatment to _some_ of the properties you can
+ * pass in a value `<E>` which will ensure that only properties which _extend_ `E` will be
+ * modified.
  */
-declare type PublicKeys<T extends object> = {
-    [K in keyof T]: K extends `_${string}` ? never : K;
-}[keyof T];
-declare type StringKeys<T extends object> = {
-    [K in keyof T]: K extends string ? Readonly<K> : never;
-}[keyof T];
+type DictPrependWithFn<T extends Record<string, any>, A extends any[], E extends any = any> = SimplifyObject<{
+    [K in keyof T]: T[K] extends E ? Record<K, (...args: A) => T[K]> : Record<K, T[K]>;
+}[keyof T]>;
+
 /**
- * The keys of an object which _are not_ a string type
+ * **DictReturnValues**
+ *
+ * A type utility which receives an object `<T>` and then modifies
+ * the return type of any properties which are a function to have this
+ * new **ReturnType** `<R>`. Optionally you can specify a particular return type which
+ * you are targeting and then
  */
-declare type NonStringKeys<T extends object> = {
-    [K in keyof T]: K extends string ? never : Readonly<K>;
-}[keyof T];
-declare type NumericKeys<T extends object> = {
-    [K in keyof T]: K extends number ? Readonly<K> : never;
-}[keyof T];
-declare type NonNumericKeys<T extends object> = {
-    [K in keyof T]: K extends number ? never : Readonly<K>;
-}[keyof T];
+type DictReturnValues<
+/** the object which we expect to have props with function values */
+T extends Record<string, any>, 
+/** the return type that functions should be modified to have */
+R extends any, 
+/** optionally this utility can target only functions with a certain existing return value */
+O extends (...args: any[]) => any = (...args: any[]) => any> = SimplifyObject<{
+    [K in keyof T]: T[K] extends O ? T[K] extends (...args: infer A) => any ? Record<K, (...args: A) => R> : Record<K, T[K]> : Record<K, T[K]>;
+}[keyof T]>;
+
 /**
- * **RequiredProps**
- *
- * Reduces an object type to only key/value pairs where the key is required
+ * Get the type of a property of an object:
+ * ```ts
+ * const car = { make: "Chevy", model: "Malibu", }
+ * ```
  */
-declare type RequiredProps<T extends object> = Pick<T, RequiredKeys<T>>;
+type Get<T, K> = K extends `${infer FK}.${infer L}` ? FK extends keyof T ? Get<T[FK], L> : never : K extends keyof T ? T[K] : never;
+
 /**
- * **OptionalProps**
- *
- * Reduces an object to only key/value pairs where the key is optional
+ * Expresses whether an option is "opt" (optional) or "req" (required)
  */
-declare type OptionalProps<T extends object> = Pick<T, OptionalKeys<T>>;
+type OptRequired = "opt" | "req";
+
+declare const DEFAULT_ONE_TO_MANY_MAPPING: FinalizedMapConfig<"req", "I -> O[]", "opt">;
+declare const DEFAULT_ONE_TO_ONE_MAPPING: FinalizedMapConfig<"req", "I -> O", "req">;
+declare const DEFAULT_MANY_TO_ONE_MAPPING: FinalizedMapConfig<"req", "I[] -> O", "req">;
+type DefaultOneToManyMapping = typeof DEFAULT_ONE_TO_MANY_MAPPING;
+type DefaultOneToOneMapping = typeof DEFAULT_ONE_TO_ONE_MAPPING;
+type DefaultManyToOneMapping = typeof DEFAULT_MANY_TO_ONE_MAPPING;
 /**
- * **WithValue**
+ * **mapTo** _utility_
  *
- * Reduces an object's type down to only those key/value pairs where the
- * value is of type `W`.
+ * This utility -- by default -- creates a strongly typed 1:M data mapper which maps from one
+ * known source `I` to any array of another `O[]`:
  * ```ts
- * const foo = { a: 1, b: "hi", c: () => "hello" }
- * // { c: () => "hello" }
- * type W = WithValue<Function, typeof foo>
+ * const mapper = mapTo<I, O>(i => [{
+ *    foo: i.bar
+ * }]);
  * ```
  */
-declare type WithValue<W extends any, T extends object, E extends any = undefined> = undefined extends E ? Pick<T, KeysWithValue<W, T>> : Omit<Pick<T, KeysWithValue<W, T>>, KeysWithValue<E, T>>;
-/**
- * Reduces an object to only the key/value pairs where the key is a
- * string.
- */
-declare type WithStringKeys<T extends object> = Omit<T, NonStringKeys<T>>;
+declare const mapToFn: ConfiguredMap<DefaultOneToManyMapping>["map"];
 /**
- * Reduces an object to only the key/value pairs where the key is numeric.
+ * Provides a `config` method which allows the relationships between _inputs_
+ * and _outputs_ to be configured.
  */
-declare type WithNumericKeys<T extends object> = Omit<T, NonNumericKeys<T>>;
-
+declare const mapToDict: MapperApi;
 /**
- * **withValue**
+ * **mapTo** _utility_
  *
- * Reduces a dictionary object -- in both _type_ and _run-time_ structure -- to only those
- * key/value pairs which have a specified value. For instance:
+ * This utility creates a strongly typed data mapper which maps from one
+ * known source `I` to another `O`.
  *
+ * Signatures:
  * ```ts
- * const obj = { foo: 1, bar: 2, message: "hi there" };
- * // { message: "hi there" }
- * const onlyStrings = withValue(t => t.string)(obj);
- * // { foo: 1 }
- * const justOne = withValue(t => t.literal(1))(obj);
+ * const defMap = mapTo<I,O>( ... );
+ * const configured = mapTo.config({ output: "req" }).map<I,O>( ... );
+ * const one2one = mapTo.oneToOne().map<I,O>( ... );
+ * const many2one = mapTo.manyToOne().map<I,O>( ... );
  * ```
- *
- * Note: _often useful to provide run-time type profiles with the_ `inferredType` _utility_
  */
-declare function withValue<T extends any, V extends Function>(td: TypeDefinition<T, V>): <N extends Narrowable, R extends Record<string, N>>(obj: R) => ExpandRecursively<Pick<R, KeysWithValue<T, R>>>;
+declare const mapTo: (<I, O>(map: (source: I) => O[]) => Mapper<I, O, FinalizedMapConfig<"req", "I -> O[]", "opt">>) & MapperApi;
 
 /**
- * **RuleDefinition**
- *
- * A rule definition is the typing for the fluent API surface that is built up
- * with the **ruleset** utility.
+ * Expresses relationship between inputs/outputs:
  */
-declare type RuleDefinition<
-/** the data which will be evaluated on rule execution */
-T extends object, 
-/** the optional props -- as a union type -- which must be defined per the rule */
-H extends string = "", 
-/** the key/values which will be evaluated on execution (wide type) */
-E extends Partial<SameKeys<T>> = {}, 
-/** the key/values which will be evaluated on execution (narrow type) */
-N extends Partial<SameKeys<T>> = {}> = {
-    /**
-     * sets up a true/false check that a given property is defined; this
-     * condition can only be applied to _optional_ properties.
-     */
-    has(optProp: OptionalKeys<T>): RuleDefinition<T, H & typeof optProp, E, N>;
-    /**
-     * Validates that a given property extends a certain value's type; comparison
-     * is made assuming "wide types".
-     */
-    equals<K extends keyof T, V extends Pick<T, K>>(prop: K, value: V): RuleDefinition<T, H, E & Record<K, V>, N>;
+declare enum MapCardinality {
+    /** every input results in 0:M outputs */
+    OneToMany = "I -> O[]",
+    /** every input results in 0:1 outputs */
+    OneToOne = "I -> O",
+    /** every input is an array of type I and reduced to a single O  */
+    ManyToOne = "I[] -> O"
+}
+type MapCardinalityIllustrated = EnumValues<MapCardinality>;
+/**
+ * The _user_ configuration of a **mapTo** mapper function
+ * which will be finalized by merging it with the appropriate
+ * default mapping type.
+ */
+interface MapConfig<IR extends OptRequired | undefined = undefined, D extends MapCardinalityIllustrated | undefined = undefined, OR extends OptRequired | undefined = undefined> {
+    input?: IR;
+    output?: OR;
+    cardinality?: D;
     /**
-     * Validates that a given property extends a certain value's type; comparison
-     * is made assuming "narrow types". This is only available for props which
-     * expose a
+     * Whether calls to the final `MapFn` will be logged to stderr
+     * for debugging purposes. Defaults to false; if you specify
+     * a _string_ for a value that will be sent to stderr along
+     * with other debugging info.
      */
-    narrowlyEquals<K extends keyof T, V extends Pick<T, K>>(prop: K, value: V): RuleDefinition<T, H, E, N & Record<K, V>>;
-};
+    debug?: boolean | string;
+}
 /**
- * **DynamicRule**
- *
- * A dynamic rule allows type and runtime validation of a data structure
- * which extends a known `State`. It then returns the literal type `true`
- * or `false`.
+ * A finalized configuration of a **mapTo** mapper functions cardinality
+ * relationships between _inputs_ and _outputs_.
  *
- * ```ts
- * type State = { id?: string; favorite: boolean; color: string };
- * // type-safe way to check whether optional prop is actually set
- * const rule: DynamicRule<State> = s => s
- *  .has("id")
- *  .equals("favorite", true)
- *  .equals("color", "red");
- * ```
+ * Note: _this configuration does _not_ yet include the actual mapping
+ * configuration between the input and output._
  */
-declare type DynamicRule<TState extends any, TResult extends true | false> = (rule: TypeCondition<any, TState>) => TResult;
+type FinalizedMapConfig<IR extends OptRequired = MapIR<DefaultOneToManyMapping>, D extends MapCardinalityIllustrated = MapCard<DefaultOneToManyMapping>, OR extends OptRequired = MapOR<DefaultOneToManyMapping>> = Required<Omit<MapConfig<IR, D, OR>, "debug">> & {
+    finalized: true;
+    debug: boolean | string;
+};
 /**
- * **DynamicRuleSet**
- *
- * A function which accepts the agreed `TState` generic as input and returns a discrete
- * `true` or `false` value.
+ * User configuration exposed by a config function which specifies the
+ * cardinality already (e.g., `oneToMany()`, `manyToOne()`)
  */
-declare type DynamicRuleSet<TState extends any, TRules extends Record<string, TypeCondition<any, TState>>> = (rules: TRules) => true | false;
-
-declare type RuntimeType<T> = {
-    __kind: "type";
-    type: T;
-    is: TypeGuard<T>;
-};
-declare type RuntimeProp<P extends Readonly<PropertyKey>, T extends RuntimeType<any>> = {
-    __kind: "prop";
-    key: Readonly<P>;
-    valueType: Readonly<T["type"]>;
+type MapCardinalityConfig<IR extends OptRequired | undefined, OR extends OptRequired | undefined> = {
+    /** whether we the input can _optionally_ be an `undefined` value or not */
+    input?: IR;
+    /** whether we the output can _optionally_ be an `undefined` value or not */
+    output?: OR;
     /**
-     * Provides the _type_ to the type system when used with `typeof`.
-     *
-     * ```ts
-     * const t = number();
-     * // number
-     * type T = typeof t.type;
-     * ```
-     *
-     * **Note:** _the runtime system will get a string equivalent name:_
-     * ```ts
-     * const t = number();
-     * // "number"
-     * console.log(t.type);
-     * ```
+     * Whether calls to the final `MapFn` will be logged to stderr
+     * for debugging purposes. Defaults to false; if you set to a string
+     * value than this will be echoed out with stderr.
      */
-    type: Record<P, T["type"]>;
-    is: TypeGuard<Record<P, T["type"]>>;
+    debug?: boolean | string;
 };
-declare type TypeOptions<T extends Partial<object> = {}> = {
-    /** each type has a default type guard but you can override if you need to be more specific */
-    typeGuard?: TypeGuard<T>;
-} & T;
-
-/**
- * Validates that a given type extends another and returns `true` or `false` type
- */
-declare type ExpectExtends<VALUE, EXPECTED> = EXPECTED extends VALUE ? true : false;
-/**
- * Validates that a given type extends another and returns `any` or `never` as a type
- */
-declare type AssertExtends<VALUE, EXPECTED> = EXPECTED extends VALUE ? any : never;
 /**
- * Give a type `TValue` and a comparison type `TExtends`
- */
-declare type IfExtendsThen<VALUE, EXPECTED, THEN> = EXPECTED extends VALUE ? THEN : never;
-
-/**
- * Indicates whether `T` has _all_ uppercase characters in it.
- * ```ts
- * // true
- * type T = AllCaps<"FOOBAR">;
- * // false
- * type T = AllCaps<"FooBar">;
- * // "unknown"
- * type T = AllCaps<string>;
- * ```
- */
-declare type AllCaps<T extends string> = string extends T ? "unknown" : T extends Uppercase<T> ? true : false;
-
-/**
- * **Break<T,D>**
- *
- * Takes a string `T`, and splits it into a tuple of the form `[F, R]`.
- * ```ts
- * // ["the", " long and winding road"]
- * type T1 = Break<"the long and winding road", " ">;
- * // ["there", " I was, there I was"]
- * type T2 = Break<"there I was, there I was", " ">;
- * ```
- */
-declare type Break<T extends string, D extends string> = (string extends T ? [string, string] : (T extends `${infer F}${D}${infer _R}` ? (F extends `${infer _X}${D}${infer _Y}` ? never : (T extends `${F}${infer R}` ? [F, R] : never)) : [T, ""]));
-
-/**
- * Concatenates two arrays (of literals).
- * ```ts
- * // [ "foo", "bar", "baz" ]
- * type T = ArrConcat<["foo"], ["bar", "baz"]>;
- * ```
- */
-declare type ArrConcat<A extends any[], B extends any[]> = [...A, ...B];
-
-/**
- * Type utility which takes a string `S` and replaces the substring `W` with `P`.
- * ```ts
- * const fooy = "fooy";
- * // "Foo"
- * type Foo = Replace<typeof fooy, "y", "">;
- * ```
+ * **ConfiguredMap**
  *
- * Note: _the first match is replaced and all subsequent matches are ignored_
- */
-declare type Replace<S extends string, W extends string, P extends string> = S extends "" ? "" : W extends "" ? S : S extends `${infer F}${W}${infer E}` ? `${F}${P}${E}` : S;
-
-/**
- * Trims off whitespace on left of string
- * ```ts
- * // "foobar "
- * type T = TrimLeft<"\n\t  foobar ">;
- * // string
- * type T = TrimLeft<string>;
- * ```
+ * A partial application of the mapTo() utility which has expressed the
+ * configuration of the _inputs_ and _outputs_ and provides a `.map()`
+ * method which allows the user configure the specifics of the mapping.
  */
-declare type TrimLeft<S extends string> = string extends S ? string : S extends `${Whitespace}${infer Right}` ? TrimLeft<Right> : S;
-
+type ConfiguredMap<C extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>> = {
+    map: <I, O>(map: MapTo<I, O, C>) => Mapper<I, O, C>;
+    input: MapIR<C>;
+    cardinality: MapCard<C>;
+    output: MapOR<C>;
+    debug: boolean | string;
+};
 /**
- * Provides the _left_ whitespace of a string
- * ```ts
- * // "\n\t "
- * type T = LeftWhitespace<"\n\t foobar">;
- * ```
+ * Extracts the IR, Cardinality, and OR generics from a FinalizedMapConfig
  */
-declare type LeftWhitespace<S extends string> = string extends S ? string : Replace<S, TrimLeft<S>, "">;
-
+type DecomposeMapConfig<M extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>> = M extends MapConfig<infer IR, infer D, infer OR> ? IR extends OptRequired | undefined ? D extends MapCardinalityIllustrated | undefined ? OR extends OptRequired | undefined ? [IR, D, OR] : never : never : never : M extends FinalizedMapConfig<infer IR, infer D, infer OR> ? IR extends OptRequired ? D extends MapCardinalityIllustrated ? OR extends OptRequired ? [IR, D, OR] : never : never : never : never;
+/** extracts IR from a `FinalizedMapConfig` */
+type MapIR<T extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>> = DecomposeMapConfig<T>[0];
 /**
- * Trims off whitespace on left of string
- * ```ts
- * // "\n foobar"
- * type T = TrimRight<"\n foobar \t">;
- * // string
- * type T = TrimRight<string>;
- * ```
+ * extracts the MapCardinality from a `FinalizedMapConfig`
  */
-declare type TrimRight<S extends string> = string extends S ? string : S extends `${infer Right}${Whitespace}` ? TrimRight<Right> : S;
-
+type MapCard<T extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>> = DecomposeMapConfig<T>[1];
+/** extracts OR from a `FinalizedMapConfig` */
+type MapOR<T extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>> = DecomposeMapConfig<T>[2];
 /**
- * Provides the _left_ whitespace of a string
- * ```ts
- * // "\n\t "
- * type T = LeftWhitespace<"\n\t foobar">;
- * ```
+ * Merges the types of a userland configuration with a default configuration
  */
-declare type RightWhitespace<S extends string> = string extends S ? string : Replace<S, TrimRight<S>, "">;
-
+type AsFinalizedConfig<U extends MapConfig<OptRequired | undefined, MapCardinalityIllustrated | undefined, OptRequired | undefined>, D extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>> = TypeDefault<U, D> extends FinalizedMapConfig<infer IR, infer C, infer OR> ? FinalizedMapConfig<IR, C, OR> : never;
+type MapperApi = {
+    /**
+     * Provides opportunity to configure _input_, _output_, and _cardinality_
+     * prior to providing a mapping function.
+     *
+     * Note: _the defaults for configuration are defined by the_ `DEFAULT_ONE_TO_MANY_MAPPING`
+     * _constant made available as a symbol from this library._
+     */
+    config: <C extends MapConfig<OptRequired, //
+    MapCardinalityIllustrated, OptRequired>>(config: C) => ConfiguredMap<AsFinalizedConfig<C, //
+    DefaultOneToManyMapping>>;
+    /**
+     * Provides a nice 1:1 ratio between the input and output.
+     *
+     * By default the input and output are considered to be _required_
+     * properties but this can be changed with the options hash provided.
+     * ```ts
+     * const mapper = mapTo.oneToOne().map(...);
+     * // add in ability to filter out some inputs
+     * const mapAndFilter = mapTo.oneToOne({ output: "opt" })
+     * ```
+     */
+    oneToOne: <C extends MapCardinalityConfig<OptRequired, OptRequired>>(config?: C) => ConfiguredMap<AsFinalizedConfig<C, //
+    DefaultOneToOneMapping>>;
+    /**
+     * **manyToOne** _mapping_
+     *
+     * Provides a configuration where multiple inputs `I[]` will be mapped to a
+     * single output `O`.
+     *
+     * Choosing this configuration will, by default, set both input and output
+     * to be "required" but you can change this default if you so choose.
+     */
+    manyToOne: <C extends MapCardinalityConfig<OptRequired | undefined, //
+    //
+    OptRequired | undefined>>(config?: C) => ConfiguredMap<AsFinalizedConfig<C, //
+    DefaultManyToOneMapping>>;
+    oneToMany: <C extends MapCardinalityConfig<OptRequired | undefined, //
+    //
+    OptRequired | undefined>>(config?: C) => ConfiguredMap<AsFinalizedConfig<C, //
+    DefaultOneToManyMapping>>;
+};
+type MapInput<I, //
+IR extends OptRequired, C extends MapCardinalityIllustrated> = C extends MapCardinality.OneToMany | "I -> O[]" ? IR extends "opt" ? I | undefined : I : C extends MapCardinality.OneToOne | "I -> O" ? IR extends "opt" ? I | undefined : I : C extends MapCardinality.ManyToOne | "I[] -> O" ? IR extends "opt" ? I[] | undefined : I[] : never;
+type MapOutput<O, //
+OR extends OptRequired, C extends MapCardinalityIllustrated> = C extends MapCardinality.OneToMany | "I -> O[]" ? OR extends "opt" ? O[] : [O, ...O[]] : C extends MapCardinality.OneToOne | "I -> O" ? OR extends "opt" ? O | null : O : C extends MapCardinality.ManyToOne | "I[] -> O" ? OR extends "opt" ? O | null : O : never;
 /**
- * Type utility that provides the _length_ of a given string type in a way which
- * is _not_ limited to TS's recursive string length of roughly 48.
+ * **MapTo<I, O>**
  *
- * ```ts
- * // 3
- * type Three = StringLength<"foo">;
- * ```
- */
-declare type StringLength<S extends string, R extends number[] = []> = S extends `${infer _First}${infer _Second}${infer _Third}${infer _Fourth}${infer _Fifth}${infer _Sixth}${infer _Sevebnth}${infer _Eighth}${infer _Ninth}${infer _Tenth}${infer Rest}` ? StringLength<Rest, [...R, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]> : S extends `${infer _First}${infer _Second}${infer _Third}${infer _Fourth}${infer _Fifth}${infer _Sixth}${infer _Sevebnth}${infer _Eighth}${infer _Ninth}${infer Rest}` ? StringLength<Rest, [...R, 1, 1, 1, 1, 1, 1, 1, 1, 1]> : S extends `${infer _First}${infer _Second}${infer _Third}${infer _Fourth}${infer _Fifth}${infer _Sixth}${infer _Sevebnth}${infer _Eighth}${infer Rest}` ? StringLength<Rest, [...R, 1, 1, 1, 1, 1, 1, 1, 1]> : S extends `${infer _First}${infer _Second}${infer _Third}${infer _Fourth}${infer _Fifth}${infer _Sixth}${infer _Sevebnth}${infer Rest}` ? StringLength<Rest, [...R, 1, 1, 1, 1, 1, 1, 1]> : S extends `${infer _First}${infer _Second}${infer _Third}${infer _Fourth}${infer _Fifth}${infer _Sixth}${infer Rest}` ? StringLength<Rest, [...R, 1, 1, 1, 1, 1, 1]> : S extends `${infer _First}${infer _Second}${infer _Third}${infer _Fourth}${infer _Fifth}}${infer Rest}` ? StringLength<Rest, [...R, 1, 1, 1, 1, 1]> : S extends `${infer _First}${infer _Second}${infer _Third}${infer _Fourth}${infer Rest}` ? StringLength<Rest, [...R, 1, 1, 1, 1]> : S extends `${infer _First}${infer _Second}${infer _Third}${infer Rest}` ? StringLength<Rest, [...R, 1, 1, 1]> : S extends `${infer _First}${infer _Second}${infer Rest}` ? StringLength<Rest, [...R, 1, 1]> : S extends `${infer _First}${infer Rest}` ? StringLength<Rest, [...R, 1]> : [...R]["length"];
-
-/**
- * Trims off blank spaces, `\n` and `\t` characters from both sides of a _string literal_.
- * ```ts
- * // "foobar"
- * type T = Trim<"\n\t  foobar ">;
- * // string
- * type T = Trim<string>;
- * ```
- */
-declare type Trim<S extends string> = string extends S ? string : S extends `${Whitespace}${infer Right}` ? Trim<Right> : S extends `${infer Left}${Whitespace}` ? Trim<Left> : S;
-
-/**
- * An email address
- */
-declare type Email = `${string}@${string}.${string}`;
-declare type Zip5 = `${NumericString}${NumericString}${string}${NumericString}`;
-declare type Zip4 = `${NumericString}${string}`;
-/**
- * A relatively strong type for Zip5 or Zip5+4 zip codes
- */
-declare type ZipCode = Zip5 | `${Zip5}-${Zip4}`;
-
-/**
- * If **ALL CAPS** it converts to all lowercase; if not then it does nothing */
-declare type LowerAllCaps<T extends string> = AllCaps<T> extends true ? Lowercase<T> : T;
-
-declare type Delimiter = "_" | "-" | " ";
-/** convert all delimiters to dashes */
-declare type DashDelim<T extends string> = T extends `${infer Begin}${" "}${infer Rest}` ? DashDelim<`${Begin}-${Rest}`> : T extends `${infer Begin}${"_"}${infer Rest}` ? DashDelim<`${Begin}-${Rest}`> : T;
-/**
- * Converts a string literal type to a **PascalCase** representation.
- * ```ts
- * // "FooBar"
- * type T = PascalCase<"fooBar">;
- * type T = PascalCase<"foo-bar">;
- * type T = PascalCase<"foo_bar">;
- * type T = PascalCase<"\n foo_bar \t">;
- * ```
- */
-declare 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>>>;
-
-declare type CamelCase<S extends string> = string extends S ? string : Uncapitalize<PascalCase<S>>;
-
-/**
- * Capitalize all words in a string
- */
-declare type CapitalizeWords<S extends string> = S extends `${infer L} ${infer R}` ? `${CapitalizeWords<L>} ${CapitalizeWords<R>}` : S extends `${infer L},${infer R}` ? `${CapitalizeWords<L>},${CapitalizeWords<R>}` : S extends `${infer L}.${infer R}` ? `${CapitalizeWords<L>}.${CapitalizeWords<R>}` : Capitalize<S>;
-
-declare type DashToSnake<T extends string> = T extends `${infer HEAD}-${infer TAIL}` ? DashToSnake<`${HEAD}_${TAIL}`> : T;
-
-/**
- * Indicates whether `T` has uppercase characters in it.
- * ```ts
- * // true
- * type T = HasUppercase<"Foobar">;
- * // false
- * type T = HasUppercase<"foobar">;
- * // "unknown"
- * type T = HasUppercase<string>;
- * ```
- */
-declare type HasUppercase<T extends string> = string extends T ? "unknown" : T extends `${string}${UpperAlpha}${string}` ? true : false;
-
-declare type _DU<T extends string> = T extends Lowercase<T> ? T : `-${Lowercase<T>}`;
-/**
- * Converts uppercase characters to a dash and then the lowercase equivalent
- * ```ts
- * // "one-two-three"
- * type T = DashUppercase<"oneTwoThree">;
- * ```
+ * A mapping function between an input type `I` and output type `O`. Defaults to using
+ * the _default_ OneToMany mapping config.
  *
- * _Intended to be used as a lower level utility; prefer `Dasherize<T>` for more full-fledged
- * dash solution_.
+ * **Note:** this type is designed to guide the userland mapping; refer
+ * to `MapFn` if you want the type output by the `mapFn()` utility.
  */
-declare type DashUppercase<T extends string> = HasUppercase<T> extends false ? T : T extends `${infer C0}${infer C1}${infer R}` ? `${_DU<C0>}${_DU<C1>}${DashUppercase<R>}` : T extends `${infer C0}${infer R}` ? `${_DU<C0>}${DashUppercase<R>}` : "";
-
-declare type OneToOne = `1:1`;
-declare type OneToMany = `1:M`;
-declare type OneToZero = `1:0`;
-declare type ZeroToOne = `0:1`;
-declare type ZeroToMany = `0:M`;
-declare type ZeroToZero = `0:0`;
-declare type ManyToMany = "M:M";
-declare type ManyToOne = "M:1";
-declare type ManyToZero = "M:0";
-declare type CardinalityNode = "0" | "1" | "M";
+type MapTo<I, O, C extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired> = DefaultOneToManyMapping> = MapIR<C> extends "opt" ? (source?: MapInput<I, MapIR<C>, MapCard<C>>) => MapOutput<O, MapOR<C>, MapCard<C>> : (source: MapInput<I, MapIR<C>, MapCard<C>>) => MapOutput<O, MapOR<C>, MapCard<C>>;
+type MapFnOutput<I, O, S, OR extends OptRequired, C extends MapCardinalityIllustrated> = C extends "I -> O[]" | MapCardinality.OneToMany ? S extends I[] ? OR extends "opt" ? O[] : [O, ...O[]] : OR extends "opt" ? O[] | null : O[] : C extends MapCardinality.OneToOne | "I -> O" ? S extends I[] ? OR extends "opt" ? O[] : [O, ...O[]] : OR extends "opt" ? O | null : O : C extends MapCardinality.ManyToOne | "I[] -> O" ? S extends I[][] ? OR extends "opt" ? O[] : [O, ...O[]] : OR extends "opt" ? O | null : O : never;
+type MapFnInput<I, IR extends OptRequired, D extends MapCardinalityIllustrated> = D extends "I -> O[]" | MapCardinality.OneToMany ? IR extends "opt" ? I | I[] | undefined : I | I[] : D extends MapCardinality.OneToOne | "I -> O" ? IR extends "opt" ? I | I[] | undefined : I | I[] : D extends MapCardinality.ManyToOne | "I[] -> O" ? IR extends "opt" ? I[] | I[][] | undefined : I[] | I[][] : never;
 /**
- * Cardinality which expects a singular input and requires
- * 1 or many outputs.
+ * The mapping function provided by the `mapFn()` utility. This _fn_
+ * is intended to be used in two ways:
  *
- * Note: choose `CardinalityFilter1` if you want to allow output
- * to have no outputs.
- */
-declare type Cardinality1 = OneToOne | OneToMany;
-/**
- * Cardinality which expects a singular input and maps to 0,
- * 1, or many outputs.
- */
-declare type CardinalityFilter1 = OneToOne | OneToMany | OneToZero;
-/**
- * Cardinality which expects a singular input which is allowed to be
- * _undefined_ or the expected type.
- */
-declare type Cardinality0 = ZeroToOne | ZeroToMany | OneToOne | OneToMany;
-/**
- * Cardinality which expects a singular input -- which is allowed to be
- * _undefined_ -- and maps to 0,
- * 1, or many outputs.
- */
-declare type CardinalityFilter0 = ZeroToOne | ZeroToMany | OneToOne | OneToMany | OneToZero | ZeroToZero;
-declare type CardinalityExplicit = `${number}:${number}`;
-/**
- * Cardinality of any sort between two types
- */
-declare type Cardinality = CardinalityFilter0 | CardinalityFilter1 | ManyToMany | ManyToOne | ManyToZero | CardinalityExplicit;
-declare type CardinalityTuple<T extends Cardinality> = UnionToTuple<T>;
-/**
- * The first or _input_ part of the Cardinality relationship
- */
-declare type CardinalityIn<T extends Cardinality> = T extends `${infer IN}:${string}` ? IN : never;
-/**
- * The second or _output_ part of the Cardinality relationship
+ * 1. Iterative:
+ *    ```ts
+ *    const m = mapTo<I,O>(i => [ ... ]);
+ *    // maps inputs to outputs
+ *    const out = inputs.map(m);
+ *    ```
+ * 2. Block:
+ *    ```ts
+ *    // maps inputs to outputs (filtering or splitting where appr.)
+ *    const out2 = m(inputs);
+ *    ```
  */
-declare type CardinalityOut<T extends Cardinality> = T extends `${string}:${infer OUT}` ? OUT : never;
-declare type CardinalityInput<T, C extends Cardinality> = CardinalityTuple<C>[0] extends 0 ? T | undefined : CardinalityTuple<C>[0] extends 1 ? T : T[];
-
+type MapFn<I, O, C extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>> = MapIR<C> extends "opt" ? <S extends MapFnInput<I, MapIR<C>, MapCard<C>>>(source?: S) => MapFnOutput<I, O, S, MapOR<C>, MapCard<C>> : <S extends MapFnInput<I, MapIR<C>, MapCard<C>>>(source: S) => MapFnOutput<I, O, S, MapOR<C>, MapCard<C>>;
 /**
- * Converts a string literal into a _dasherized_ format while ignoring _exterior_ whitespace.
+ * **Mapper**
  *
+ * A fully configured _mapper_ stemming from the **mapTo()** utility. It is both a mapping
+ * function and a dictionary which describes the mapper's properties.
  * ```ts
- * // "foo-bar"
- * type Dash = Dasherize<"foo_bar">;
- * type Dash = Dasherize<"fooBar">;
- * type Dash = Dasherize<"FooBar">;
- * // "\n  foo-bar \t"
- * type Dash = Dasherize<"\n  foo bar \t">;
- * ```
- */
-declare type Dasherize<S extends string> = string extends S ? string : DashUppercase<Trim<LowerAllCaps<S>>> extends `${infer Begin}${"_" | " "}${infer Rest}` ? Dasherize<`${Lowercase<Begin>}-${Rest}`> : Lowercase<DashUppercase<Uncapitalize<Trim<LowerAllCaps<S>>>>>;
-
-/**
- * Returns true or false value based on whether the string literal is capitalized.
- * ```ts
- * // true
- * type T2 = IsCapitalized<"One">;
- * // false
- * type T1 = IsCapitalized<"one">;
- * // "unknown"
- * const a: string = "Hi";
- * type T3 = IsCapitalized<typeof a>;
+ * const m = mapTo.oneToOne().map( ... );
+ * const mapped = m(inputs);
+ * const mappedOver = inputs.map(m);
  * ```
  *
- * Note: _if the value passed in is a "string" then the result will be "unknown"_
+ * Note: the root of a `Mapper` is the mapper function but
+ * this is combined with a dictionary of settings and types
+ * which you can use. For instance, look at the `fnSignature`
+ * property to get the _type_ signature of the map function.
  */
-declare type IsCapitalized<T extends string> = string extends T ? "unknown" : T extends Capitalize<T> ? true : false;
-
-/**
- * **KebabCase<T>** is an _alias_ for **Dasherize<T>**.
- * ```ts
- * // "foo-bar"
- * type Kebab = KebabCase<"foo_bar">;
- * type Kebab = KebabCase<"fooBar">;
- * type Kebab = KebabCase<"FooBar">;
- * // "\n  foo-bar \t"
- * type Kebab = KebabCase<"\n  foo bar \t">;
- * ``` */
-declare type KebabCase<T extends string> = Dasherize<T>;
-
-declare type Consonant = "b" | "c" | "d" | "f" | "g" | "h" | "j" | "k" | "l" | "m" | "n" | "p" | "q" | "r" | "s" | "t" | "v" | "w" | "x" | "z" | "y";
-declare type Exceptions = "photo => photos" | "piano => pianos" | "halo => halos" | "foot => feet" | "man => men" | "woman => women" | "person => people" | "mouse => mice" | "series => series" | "sheep => sheep" | "money => monies" | "deer => deer";
-declare type SingularException<T = Exceptions> = T extends `${infer SINGULAR} => ${infer PLURAL}` ? SINGULAR : never;
-declare type PluralException<T extends SingularException, E extends Exceptions = Exceptions> = E extends `${T} => ${infer PLURAL}` ? PLURAL : never;
-declare type SingularNoun = "s" | "sh" | "ch" | "x" | "z" | "o";
-declare type F = "f" | "fe";
-declare type Y = `${Consonant}y`;
-declare type RemoveTrailingY<T> = T extends `${infer HEAD}y` ? HEAD : T;
-/** validates that a word ends with a pluralization exception */
-declare type isException<T extends string> = T extends SingularException ? T : never;
-/** validates that a string literal ends in "is" */
-declare type EndsIn_IS<T extends string> = T extends `${infer HEAD}is` ? T : never;
-/** validates that a string literal is a singular noun */
-declare type EndsInSingularNoun<T extends string> = T extends `${infer HEAD}${SingularNoun}` ? T : never;
-/** validates that a string literal ends in "f" or "fe" */
-declare type EndsIn_F<T extends string> = T extends `${infer HEAD}${F}` ? T : never;
-/** validates that a string literal ends a consonant followed by "y" */
-declare type EndsIn_Y<T extends string> = T extends `${infer HEAD}${Y}` ? T : never;
+type Mapper<I = unknown, O = unknown, C extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired> = FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>> = {
+    input: MapIR<C>;
+    output: MapOR<C>;
+    cardinality: MapCard<C>;
+    debug: boolean | string;
+    inputType: I;
+    outputType: O;
+    /**
+     * Provides the _type_ information for mapper function.
+     *
+     * Note: _this is just a **type**_ not the actual function which positioned
+     * at the root of the Mapper type
+     */
+    fnSignature: MapFn<I, O, C>;
+} & MapFn<I, O, C>;
 /**
- * strings which end in the letters "is" should have an "es" added to the end
+ * **MapInputFrom**
+ *
+ * Type utility which extracts the `I` type from a fully configured `Mapper`
  */
-declare type PluralizeEndingIn_IS<T extends string> = T extends `${infer HEAD}is` ? `${HEAD}ises` : T;
+type MapInputFrom<T extends Mapper> = T extends Mapper<infer I> ? I : never;
 /**
- * singular nouns should have "es" added to the end
+ * **MapOutputFrom**
+ *
+ * Type utility which extracts the output [`O`] type from a fully configured `Mapper`
  */
-declare type PluralizeEndingSingularNoun<T extends string> = T extends `${infer HEAD}${SingularNoun}` ? `${T}es` : T;
+type MapOutputFrom<T extends Mapper> = T extends Mapper<any, infer O> ? O : never;
 /**
- * strings which end in the letters "f" or "fe" should have "ves" replace the ending
+ * **MapCardinalityFrom**
+ *
+ * Type utility which extracts _cardinality_ of a `Mapper`'s inputs to outputs
  */
-declare type PluralizeEnding_F<T extends string> = T extends `${infer HEAD}${F}` ? `${HEAD}ves` : T;
+type MapCardinalityFrom<T extends Mapper> = T extends Mapper<any, any, infer C> ? C extends FinalizedMapConfig<OptRequired, infer Cardinality, OptRequired> ? Cardinality : never : never;
+
 /**
- * singular nouns should have "es" added to the end
+ * Given a dictionary of type `<T>`, this utility function will
+ * make the `<M>` generic property _mutable_ and all other _read-only_.
+ *
+ * ```ts
+ * // { foo: string, bar?: Readonly<number> }
+ * type Example = MutableProps<{
+ *    foo: Readonly<string>,
+ *    bar?: number
+ * }, "foo">;
+ * ```
  */
-declare type PluralizeEndingIn_Y<T extends string> = T extends `${infer HEAD}${Y}` ? `${RemoveTrailingY<T>}ies` : T;
-declare type Pluralize<T extends string> = T extends isException<T> ? PluralException<T> : T extends EndsIn_IS<T> ? PluralizeEndingIn_IS<T> : T extends EndsInSingularNoun<T> ? PluralizeEndingSingularNoun<T> : T extends EndsIn_F<T> ? PluralizeEnding_F<T> : T extends EndsIn_Y<T> ? PluralizeEndingIn_Y<T> : `${T}s`;
+type MutableProps<T extends {}, M extends keyof T & string> = ExpandRecursively<Mutable<Pick<T, M>> & Readonly<Pick<T, Keys<T, M>>>>;
 
-/** convert space to dash */
-declare type SpaceToDash<T extends string> = T extends `${infer Begin}${" "}${infer Rest}` ? SpaceToDash<`${Begin}-${Rest}`> : T;
 /**
- * Converts a string literal type to _snake_case_.
+ * Given a dictionary of type `<T>`, this utility function will
+ * make the `<R>` generic property _required_ (use a union to make
+ * more than one prop required).
+ *
  * ```ts
- * // "foo_bar"
- * type T = SnakeCase<"fooBar">;
- * type T = SnakeCase<"FooBar">;
- * type T = SnakeCase<"foo-bar">;
- * type T = SnakeCase<"\n foo bar \t">;
- * ``` */
-declare type SnakeCase<S extends string> = string extends S ? string : DashUppercase<Uncapitalize<SpaceToDash<Trim<LowerAllCaps<S>>>>> extends `${infer Begin}${"-"}${infer Rest}` ? SnakeCase<`${Lowercase<Begin>}_${Rest}`> : Lowercase<DashUppercase<Uncapitalize<Trim<LowerAllCaps<S>>>>>;
+ * // { foo: string, bar?: number }
+ * type Example = RequireProps<{foo?: string, bar?: number}, "foo">;
+ * ```
+ */
+type RequireProps<T extends {}, R extends keyof T> = ExpandRecursively<Required<Pick<T, R>> & T>;
 
 /**
  * **ToFluent**
@@ -1710,7 +1510,7 @@ declare type SnakeCase<S extends string> = string extends S ? string : DashUpper
  * **Note:** this utility also allows a non-fluent API surface `X` to be included as
  * part of the API surface if this is desired.
  */
-declare type ToFluent<T extends {
+type ToFluent<T extends {
     [key: string]: (...args: any[]) => any;
 }, X extends object = {}> = {
     [K in keyof T]: (...args: Parameters<T[K]>) => ToFluent<T, X> & X;
@@ -1726,7 +1526,7 @@ declare type ToFluent<T extends {
  * **Note:** _if you prefer a Fluent API with means to _escape_ with an internally managed state then
  * you should prefer the use of the `FluentApi` type._
  */
-declare type PureFluentApi<TApi extends Record<string, (...args: any[]) => PureFluentApi<TApi, any>>, TExclude extends string = ""> = {
+type PureFluentApi<TApi extends Record<string, (...args: any[]) => PureFluentApi<TApi, any>>, TExclude extends string = ""> = {
     [P in keyof TApi]: (...args: Parameters<TApi[P]>) => PureFluentApi<Omit<TApi, TExclude>>;
 };
 
@@ -1739,14 +1539,14 @@ declare type PureFluentApi<TApi extends Record<string, (...args: any[]) => PureF
  * type T = FinalReturn<() => (foo: string) => (bar: string) => () => number>;
  * ```
  */
-declare type FinalReturn<T extends any> = T extends (...args: any[]) => any ? FinalReturn<ReturnType<T>> : T;
+type FinalReturn<T extends any> = T extends (...args: any[]) => any ? FinalReturn<ReturnType<T>> : T;
 
 /**
  * A function which returns a boolean value
  */
-declare type LogicFunction<T extends any[]> = (...args: T) => boolean;
+type LogicFunction<T extends any[]> = (...args: T) => boolean;
 
-declare type DictFromKv<T extends readonly {
+type DictFromKv<T extends readonly {
     key: string;
     value: unknown;
 }[]> = {
@@ -1762,7 +1562,7 @@ declare type DictFromKv<T extends readonly {
  * type Foo = KeyValue<Obj, "foo">;
  * ```
  */
-declare type KeyValue<T extends object, K extends keyof T> = [K & keyof T, ExpandRecursively<T[K]>];
+type KeyValue<T extends object, K extends keyof T> = [K & keyof T, ExpandRecursively<T[K]>];
 
 /**
  * Type utility which takes an object type and converts to an array of KV objects:
@@ -1771,7 +1571,7 @@ declare type KeyValue<T extends object, K extends keyof T> = [K & keyof T, Expan
  * type Arr = KvFrom<{ id: 123, foo: "bar" }>;
  * ```
  */
-declare type KvFrom<T extends object> = Array<{
+type KvFrom<T extends object> = Array<{
     [K in keyof T]: {
         key: K;
         value: T[K];
@@ -1791,7 +1591,27 @@ declare type KvFrom<T extends object> = Array<{
  *
  * **Note:** _consider use of `KeyValue<T,K>` as an alternate representation_
  */
-declare type KvTuple<T, K extends keyof T> = [K, Record<K, T[K]>];
+type KvTuple<T, K extends keyof T> = [K, Record<K, T[K]>];
+
+/**
+ * **AfterFirst**`<T>`
+ *
+ * returns the elements in an array _after_ the first element
+ */
+type AfterFirst<T extends readonly any[]> = T extends readonly [any, ...any[]] ? T extends readonly [any, ...infer Rest] ? Rest : never : T;
+
+/**
+ * returns the first `string` value from an array of values
+ */
+type FirstString<T> = T extends [infer S extends string, ...unknown[]] ? S : never;
+
+/**
+ * **Split**`<T, SEP>`
+ *
+ * Splits a string literal `T` by string literal _separator_ `SEP`. The result is an array
+ * of string literals.
+ */
+type Split<T extends string, SEP extends string, ANSWER extends string[] = []> = string extends T ? string[] : T extends SEP ? ANSWER : T extends `${infer HEAD}${SEP}${infer TAIL}` ? Split<TAIL, SEP, [...ANSWER, HEAD]> : [...ANSWER, T];
 
 /**
  * Create a union type based on a given property in an array of objects
@@ -1804,14 +1624,14 @@ declare type KvTuple<T, K extends keyof T> = [K, Record<K, T[K]>];
  * type U = UniqueForProp<typeof data, "id">;
  * ```
  */
-declare type UniqueForProp<T extends readonly Record<string, Narrowable>[], P extends string> = Readonly<Get<T[number], P>>;
+type UniqueForProp<T extends readonly Record<string, Narrowable>[], P extends string> = Readonly<Get<T[number], P>>;
 
-declare type DictArrayFilterCallback<K extends keyof T, T extends object, R extends true | false> = (key: K, value: Pick<T, K>) => R;
+type DictArrayFilterCallback<K extends keyof T, T extends object, R extends true | false> = (key: K, value: Pick<T, K>) => R;
 /**
  * An element in a `DictArray` shaped as a two element tuple: `[key, kv]`.
  */
-declare type DictArrayKv<K extends keyof T, T> = [K, Pick<T, K>];
-declare type DictKvTuple<K extends string> = [K, Record<K, unknown>];
+type DictArrayKv<K extends keyof T, T> = [K, Pick<T, K>];
+type DictKvTuple<K extends string> = [K, Record<K, unknown>];
 /**
  * A an array of `DictArrayKv` tuples which can be reconstructed
  * to a strongly typed dictionary object.
@@ -1822,7 +1642,7 @@ declare type DictKvTuple<K extends string> = [K, Record<K, unknown>];
  * ]
  * ```
  */
-declare type DictArray<T> = Array<{
+type DictArray<T> = Array<{
     [K in keyof T]: DictArrayKv<K, T>;
 }[keyof T]>;
 
@@ -1832,7 +1652,7 @@ declare type DictArray<T> = Array<{
  * **Note:** key order is not guarenteed so typically this is used
  * for a key/value pair where only one key is expected
  */
-declare type FirstKey<T extends object> = UnionToTuple<Keys<T>>[0];
+type FirstKey<T extends object> = UnionToTuple<Keys<T>>[0];
 
 /**
  * Utility type which operates on a dictionary and provides the **value** of the
@@ -1840,7 +1660,7 @@ declare type FirstKey<T extends object> = UnionToTuple<Keys<T>>[0];
  * about key order, this is typically only used in cases where it's known there is
  * a single key on the object.
  */
-declare type FirstKeyValue<T extends object> = FirstKey<T> extends keyof T ? T[FirstKey<T>] : never;
+type FirstKeyValue<T extends object> = FirstKey<T> extends keyof T ? T[FirstKey<T>] : never;
 
 /**
  * For a two-dimensional array, returns a _union type_ which combines the first element of the interior
@@ -1852,7 +1672,7 @@ declare type FirstKeyValue<T extends object> = FirstKey<T> extends keyof T ? T[F
  * type F = FirstOfEach<typeof test>;
  * ```
  */
-declare type FirstOfEach<T extends readonly any[][]> = T[number][0] extends T[number][number] ? T[number][0] : never;
+type FirstOfEach<T extends readonly any[][]> = T[number][0] extends T[number][number] ? T[number][0] : never;
 
 /**
  * Typescript utility which receives `T` as shape which resembles `DictArray<D>`
@@ -1862,7 +1682,7 @@ declare type FirstOfEach<T extends readonly any[][]> = T[number][0] extends T[nu
  * type Dict = FromDictArray<[["foo", { foo: 1 }], ["bar", { bar: "hi" }]]>;
  * ```
  */
-declare type FromDictArray<T extends [string, Record<string, unknown>][]> = ExpandRecursively<UnionToIntersection<T[number][1]>>;
+type FromDictArray<T extends [string, Record<string, unknown>][]> = ExpandRecursively<UnionToIntersection<T[number][1]>>;
 
 /**
  * For a two-dimensional array, returns a _union type_ which combines the first element of the interior
@@ -1873,7 +1693,7 @@ declare type FromDictArray<T extends [string, Record<string, unknown>][]> = Expa
  * type F = SecondOfEach<[ ["foo", 1], ["bar", 2] ]>;
  * ```
  */
-declare type SecondOfEach<T extends any[][]> = T[number][1] extends T[number][number] ? T[number][1] : never;
+type SecondOfEach<T extends any[][]> = T[number][1] extends T[number][number] ? T[number][1] : never;
 
 declare function createFnWithProps<F extends Function, P extends {}>(fn: F, props: P): F & P;
 /**
@@ -1934,41 +1754,41 @@ declare const or: <T extends any[]>(...ops: LogicFunction<T>[]) => LogicFunction
  */
 declare const not: <T extends any[]>(op: LogicFunction<T>) => LogicFunction<T>;
 
-declare type FilterStarts = {
+type FilterStarts = {
     /** one or more string which the value is allowed to start with */
     startsWith: string | string[];
 };
-declare type FilterIs = {
+type FilterIs = {
     /** whether a string _**is**_ of a particular value */
     is: string | string[];
 };
-declare type FilterEnds = {
+type FilterEnds = {
     endsWith: string | string[];
 };
-declare type FilterContains = {
+type FilterContains = {
     /** whether any of the strings specified are _contained_ in the value */
     contains: string | string[];
 };
-declare type FilterEquals = {
+type FilterEquals = {
     /** one or more values which _equal_ the value passed in */
     equals: number | number[];
 };
-declare type FilterNotEqual = {
+type FilterNotEqual = {
     /** one or more values which ALL _do not equal_ the value passed in */
     notEqual: number | number[];
 };
-declare type FilterGreaterThan = {
+type FilterGreaterThan = {
     /** the incoming value is greater than this value */
     greaterThan: number;
 };
-declare type FilterLessThan = {
+type FilterLessThan = {
     /** the incoming value is less than this value */
     lessThan: number;
 };
-declare type StringFilter = FilterIs | FilterStarts | FilterEnds | FilterContains | (FilterStarts & FilterEnds) | (FilterStarts & FilterContains) | (FilterEnds & FilterContains) | (FilterStarts & FilterEnds & FilterContains);
-declare type NumericFilter = FilterEquals | FilterNotEqual | FilterGreaterThan | FilterLessThan | (FilterEquals & FilterNotEqual) | (FilterEquals & FilterGreaterThan) | (FilterEquals & FilterLessThan) | (FilterNotEqual & FilterGreaterThan) | (FilterNotEqual & FilterLessThan) | (FilterGreaterThan & FilterLessThan) | (FilterEquals & FilterGreaterThan & FilterLessThan) | (FilterNotEqual & FilterGreaterThan & FilterLessThan) | (FilterEquals & FilterNotEqual & FilterGreaterThan & FilterLessThan);
-declare type FilterDefn = StringFilter | NumericFilter;
-declare type NotFilter = {
+type StringFilter = FilterIs | FilterStarts | FilterEnds | FilterContains | (FilterStarts & FilterEnds) | (FilterStarts & FilterContains) | (FilterEnds & FilterContains) | (FilterStarts & FilterEnds & FilterContains);
+type NumericFilter = FilterEquals | FilterNotEqual | FilterGreaterThan | FilterLessThan | (FilterEquals & FilterNotEqual) | (FilterEquals & FilterGreaterThan) | (FilterEquals & FilterLessThan) | (FilterNotEqual & FilterGreaterThan) | (FilterNotEqual & FilterLessThan) | (FilterGreaterThan & FilterLessThan) | (FilterEquals & FilterGreaterThan & FilterLessThan) | (FilterNotEqual & FilterGreaterThan & FilterLessThan) | (FilterEquals & FilterNotEqual & FilterGreaterThan & FilterLessThan);
+type FilterDefn = StringFilter | NumericFilter;
+type NotFilter = {
     /**
      * **not**
      *
@@ -1978,11 +1798,11 @@ declare type NotFilter = {
     not: FilterDefn;
 };
 declare function isNotFilter(f: FilterDefn | NotFilter): f is NotFilter;
-declare type UnwrapNot<T extends FilterDefn | NotFilter> = T extends NotFilter ? T["not"] extends StringFilter ? StringFilter : NumericFilter : T;
+type UnwrapNot<T extends FilterDefn | NotFilter> = T extends NotFilter ? T["not"] extends StringFilter ? StringFilter : NumericFilter : T;
 declare function isNumericFilter(filter: FilterDefn): filter is NumericFilter;
-declare type UndefinedValue<U extends boolean> = true extends U ? "undefined treated as 'true'" : U extends "no-impact" ? "undefined treated in no-impact fashion" : "undefined treated as 'false'";
-declare type UndefinedTreatment = "undefined treated as 'true'" | "undefined treated as 'false'";
-declare type LogicalCombinator = "AND" | "OR";
+type UndefinedValue<U extends boolean> = true extends U ? "undefined treated as 'true'" : U extends "no-impact" ? "undefined treated in no-impact fashion" : "undefined treated as 'false'";
+type UndefinedTreatment = "undefined treated as 'true'" | "undefined treated as 'false'";
+type LogicalCombinator = "AND" | "OR";
 /**
  * **FilterFn**
  *
@@ -1994,11 +1814,11 @@ declare type LogicalCombinator = "AND" | "OR";
  * ```
  *
  */
-declare type FilterFn<T extends StringFilter | NumericFilter> = T extends StringFilter ? <V extends string | undefined>(input: V) => boolean : <V extends number | undefined>(input: V) => boolean;
+type FilterFn<T extends StringFilter | NumericFilter> = T extends StringFilter ? <V extends string | undefined>(input: V) => boolean : <V extends number | undefined>(input: V) => boolean;
 /**
  * Defines a logical function for each condition type
  */
-declare type ConditionFilter<T extends StringFilter | NumericFilter> = T extends StringFilter ? (input: string) => boolean : (input: number) => boolean;
+type ConditionFilter<T extends StringFilter | NumericFilter> = T extends StringFilter ? (input: string) => boolean : (input: number) => boolean;
 /**
  * **filter**
  *
@@ -2064,7 +1884,7 @@ interface Uniqueness<T> {
     /** the unique values for the property across all records */
     values: readonly T[];
 }
-declare type DictArrApi<T extends Record<string, Narrowable>, A extends readonly T[]> = {
+type DictArrApi<T extends Record<string, Narrowable>, A extends readonly T[]> = {
     length: number;
     toLookup<PL extends RequiredKeys<T, string> & keyof T & string>(prop: PL): UniqueForProp<A, PL> extends string ? Record<UniqueForProp<A, PL>, T> : Record<string, T>;
     sum<PS extends RequiredKeys<T, number> | OptionalKeys<T, number>>(prop: PS): number;
@@ -2166,8 +1986,8 @@ declare function kvToDict<K extends string, V extends Narrowable, T extends read
 /**
  * Type utility which converts `undefined[]` to `unknown[]`
  */
-declare type UndefinedArrayIsUnknown<T extends any[]> = undefined[] extends T ? unknown[] : T;
-declare type AsArray<T, W extends boolean = false> = T extends any[] ? W extends true ? Widen<T> : T : W extends true ? UndefinedArrayIsUnknown<Widen<T>[]> : UndefinedArrayIsUnknown<T[]>;
+type UndefinedArrayIsUnknown<T extends any[]> = undefined[] extends T ? unknown[] : T;
+type AsArray<T, W extends boolean = false> = T extends any[] ? W extends true ? Widen<T> : T : W extends true ? UndefinedArrayIsUnknown<Widen<T>[]> : UndefinedArrayIsUnknown<T[]>;
 /**
  * Ensures that any input passed in is passed back as an array:
  *
@@ -2193,7 +2013,7 @@ declare const asArray: <T extends Narrowable, W extends boolean = true>(thing: T
  */
 declare function groupBy<T extends Record<string, Narrowable>>(_data: Readonly<T[]>): void;
 
-declare type ExplicitFunction<P extends any[], R extends any> = (...args: P) => R;
+type ExplicitFunction<P extends any[], R extends any> = (...args: P) => R;
 /**
  * Takes a given function and converts it to an explicit representation
  * where the generics represent the _parameter_ and _return_ typings.
@@ -2206,7 +2026,7 @@ declare function ExplicitFunction<T extends (...args: any[]) => any>(fn: T): Exp
  * A dictionary converted by `arrayToObject()` which expects each key `S` to have a only a
  * single/unique value.
  */
-declare type UniqueDictionary<S extends PropertyKey, N extends Narrowable, T extends Record<keyof T, N> & Record<S, any>> = {
+type UniqueDictionary<S extends PropertyKey, N extends Narrowable, T extends Record<keyof T, N> & Record<S, any>> = {
     [V in T as V[S]]: V;
 };
 /**
@@ -2215,10 +2035,10 @@ declare type UniqueDictionary<S extends PropertyKey, N extends Narrowable, T ext
  * A dictionary converted by `arrayToObject()` which expects each key `S` to have an
  * array of values.
  */
-declare type GeneralDictionary<S extends PropertyKey, N extends Narrowable, T extends Record<keyof T, N> & Record<S, any>> = {
+type GeneralDictionary<S extends PropertyKey, N extends Narrowable, T extends Record<keyof T, N> & Record<S, any>> = {
     [V in T as V[S]]: V[];
 };
-declare type ArrayConverter<S extends PropertyKey, U extends boolean> = 
+type ArrayConverter<S extends PropertyKey, U extends boolean> = 
 /**
  * An `ArrayConverter` is the partial application of the `arrayToObject()`
  * utility. At this point, the configuration is setup already and all that's
@@ -2241,6 +2061,33 @@ declare type ArrayConverter<S extends PropertyKey, U extends boolean> =
  */
 declare function arrayToObject<S extends PropertyKey, U extends boolean>(prop: S, unique?: U): ArrayConverter<S, true extends U ? true : false>;
 
+interface Box<T> {
+    __kind: "box";
+    value: T;
+    /**
+     * Unbox the boxed value in the narrowest possible type.
+     *
+     * **Note:** _if you want a wider type definition use `wide()`
+     * instead._
+     */
+    unbox(): T;
+}
+type BoxValue<T extends Box<any>> = T extends Box<infer V> ? V : never;
+type BoxedFnParams<T extends Box<any>> = T extends Box<infer V> ? V extends (...args: infer A) => any ? A : [] : [];
+type BoxedReturn<T extends Box<any>> = T extends Box<infer V> ? V extends Function ? ReturnType<T["value"]> : T["value"] : never;
+type NarrowBox<T> = <N extends BoxedFnParams<Box<T>> | First<BoxedFnParams<Box<T>>>>() => N extends BoxedFnParams<Box<T>> ? T extends (...args: any[]) => any ? (...args: N) => Box<T>["unbox"] : never : (first: N, ...rest: AfterFirst<BoxedFnParams<Box<T>>>) => BoxedReturn<Box<T>>;
+/**
+ * Allows a value with an inner-type to be boxed into a dictionary
+ * so that this type inference is preserved with the help of
+ * [instantiation expressions](https://devblogs.microsoft.com/typescript/announcing-typescript-4-7-beta/#instantiation-expressions).
+ *
+ * NOTE: this feature is immature at best right now
+ */
+declare function box<T extends Narrowable>(value: T): Box<T>;
+declare function isBox(thing: unknown): thing is Box<any>;
+type Unbox<T> = T extends Box<infer U> ? U : T;
+declare function unbox<T>(thing: T): Unbox<T>;
+
 /**
  * Build a _type_ from two run-time dictionaries.
  *
@@ -2296,30 +2143,240 @@ declare function idTypeGuard<T extends {
  */
 declare function literal<N extends Narrowable, T extends Record<keyof T, N>>(obj: T): T;
 
-declare function Model<N extends string, _R extends {} = {}, _O extends {} = {}>(name: N): {
-    required<P extends string>(_prop: P): {
-        required<P_1 extends string>(_prop: P_1): any;
-        optional<P_2 extends string>(_prop: P_2): any;
-        done(): {
-            __model__: N;
-            __kind__: "model";
-        };
-    };
-    optional<P_3 extends string>(_prop: P_3): {
-        required<P_1 extends string>(_prop: P_1): any;
-        optional<P_2 extends string>(_prop: P_2): any;
-        done(): {
-            __model__: N;
-            __kind__: "model";
-        };
-    };
-    done(): {
-        __model__: N;
-        __kind__: "model";
-    };
+/**
+ * **Suggest**
+ *
+ * Type utility that helps to build a enumerated set
+ * of string literals which _could_ be the value for
+ * a string based property but _allows_ a string that
+ * is not part of the suggestion to be typed in too.
+ */
+type Suggest<T extends string> = T | (string & {});
+/**
+ * **SuggestNumeric**`<T>`
+ *
+ * Type utility that helps to build a enumerated set
+ * of numeric literals which _could_ be the value for
+ * a number based property but _allows_ a number that
+ * is not part of the suggestion to be typed in too.
+ */
+type SuggestNumeric<T extends number> = T | (number & {});
+
+type Condition<TInput extends Narrowable, TResult extends boolean> = (input: TInput) => TResult;
+declare const condition: <TInput extends Narrowable, C extends Condition<Narrowable, boolean>>(c: C, input: TInput) => boolean;
+
+type IsArray<T> = T extends any[] ? true : false;
+declare function isArray<T>(i: T): IsArray<T>;
+
+type IsBoolean<T> = T extends boolean ? true : false;
+/**
+ * Runtime and type checks whether a variable is a boolean value.
+ */
+declare function isBoolean<T extends any>(i: T): IsBoolean<T>;
+/**
+ * **ifBoolean**
+ *
+ * Strongly type-aware conditional statement which checks whether a value is
+ * a _boolean_ and returns one of two values (strongly typed) based on the evaluation
+ * of this criteria.
+ *
+ * @param val the value being tested
+ * @param ifVal the value (strongly typed) returned if val is _boolean_
+ * @param elseVal the value (strongly typed) returned if val is NOT a _boolean
+ */
+declare function ifBoolean<T, IF, ELSE>(val: T, ifVal: IF, elseVal: ELSE): IsBoolean<T> extends true ? IF : ELSE;
+
+type IsFalse<T extends Narrowable> = IsBoolean<T> extends true ? T extends false ? true : true extends T ? false : unknown : false;
+declare function isFalse<T>(i: T): IsFalse<T>;
+
+type IsFunction<T> = T extends FunctionType ? true : false;
+type HybridFunction<TProps extends {}> = (<TArgs extends any[]>(...args: TArgs) => any) & TProps;
+type SimpleFunction = <TArgs extends any[]>(...args: TArgs) => any;
+type AnyFunction<TProps extends {} | never = never> = TProps extends {} ? HybridFunction<TProps> : SimpleFunction;
+/**
+ * Checks whether a passed in value is a function and ensures run-time and types
+ * are consistent.
+ * ```ts
+ * // true
+ * const yup = isFunction(() => "hello world");
+ * ```
+ *
+ * Note: the runtime `typeof [variable]` will correctly say "function" when a function is
+ * encountered but if that function also has object types defined then the type will be a big
+ * and ugly union type. This function will give you a proper boolean value in both cases.
+ */
+declare function isFunction<T>(input: T): IsFunction<T>;
+
+type IsNull<T> = T extends null ? true : false;
+declare function isNull<T extends Narrowable>(i: T): T extends null ? true : false;
+/**
+ * **ifNull**
+ *
+ * Strongly type-aware conditional statement which checks whether a value is
+ * Null and returns one of two values (strongly typed) based on the evaluation
+ * of this criteria.
+ *
+ * @param val the value being tested
+ * @param ifVal the value (strongly typed) returned if val is `null`
+ * @param elseVal the value (strongly typed) returned if val is NOT `null`
+ */
+declare function ifNull<T extends Narrowable, IF extends Narrowable, ELSE extends Narrowable>(val: T, ifVal: IF, elseVal: ELSE): IsNull<T> extends true ? IF : ELSE;
+
+type IsNumber<T> = T extends number ? true : false;
+declare function isNumber<T>(i: T): T extends number ? true : false;
+/**
+ * **ifNumber**
+ *
+ * Strongly type-aware conditional statement which checks whether a value is
+ * a _number_ and returns one of two values (strongly typed) based on the evaluation
+ * of this criteria.
+ *
+ * @param val the value being tested
+ * @param ifVal the value (strongly typed) returned if val is number
+ * @param elseVal the value (strongly typed) returned if val is NOT a number
+ */
+declare function ifNumber<T, IF, ELSE>(val: T, ifVal: IF, elseVal: ELSE): IsNumber<T> extends true ? IF : ELSE;
+
+type ObjectType = Not<Record<string, Narrowable>, FunctionType>;
+/**
+ * Detects whether the passed in `v` is of type "object" where an object
+ * is defined to be a string keyed dictionary style object. This means that
+ * arrays are excluded, as well as functions which also have properties hanging
+ * off of them.
+ */
+declare function isObject<T extends unknown>(i: T): IsObject<T>;
+
+/**
+ * **IsString**
+ *
+ * Type utility which returns true/false based on whether `T` is a
+ * string (wide or narrow).
+ */
+type IsString<T> = T extends string ? true : false;
+/**
+ * **IfString**
+ *
+ * Type utility which determines if `T` is a _string_ (wide or narrow) and
+ * returns `IF` type if it is, otherwise returns the type `ELSE`.
+ */
+type IfString<T extends Narrowable, //
+IF extends Narrowable, ELSE extends Narrowable> = IsString<T> extends true ? IF : ELSE;
+
+/**
+ * **isString**
+ *
+ * Returns true or false on whether the passed in parameter is a
+ * string (either a wide string or a string literal).
+ *
+ * The boolean return is traceable by the type system as well as the
+ * runtime system.
+ */
+declare function isString<T>(i: T): IsString<T>;
+/**
+ * **ifString**
+ *
+ * Strongly type-aware conditional statement which checks whether a value is
+ * a _string_ and returns one of two values (strongly typed) based on the evaluation
+ * of this criteria.
+ *
+ * @param val the value being tested for being a string
+ * @param ifVal the value (strongly typed) returned if val is _string_
+ * @param elseVal the value (strongly typed) returned if val is NOT a _string
+ */
+declare function ifString<T extends Narrowable, IF extends Narrowable, ELSE extends Narrowable>(val: T, ifVal: IF, elseVal: ELSE): IfString<T, IF, ELSE>;
+
+declare function isSymbol<T>(i: T): T extends symbol ? true : false;
+
+/**
+ * Type utility which returns `true` or `false` based on
+ * whether the type holds the narrow "true" type.
+ * ```ts
+ * // true
+ * type T = IsTrue<true>;
+ * // unknown
+ * type U = IsTrue<boolean>;
+ * // false
+ * type F = IsTrue<false>;
+ * type F2 = IsTrue<"false">;
+ * ```
+ */
+type IsTrue<T> = IsBoolean<T> extends true ? T extends true ? true : T extends false ? false : unknown : false;
+/**
+ * Run-time and type checking of whether a variable is `true`.
+ */
+declare function isTrue<T extends Narrowable>(i: T): IsTrue<T>;
+/**
+ * **ifTrue**
+ *
+ * Strongly type-aware conditional statement which checks whether a value is
+ * a _true_ and returns one of two values (strongly typed) based on the evaluation
+ * of this criteria.
+ *
+ * @param val the value being tested
+ * @param ifVal the value (strongly typed) returned if val is _true_ value
+ * @param elseVal the value (strongly typed) returned if val is NOT a _true_ value
+ */
+declare function ifTrue<T extends Narrowable, IF, ELSE>(val: T, ifVal: IF, elseVal: ELSE): IsTrue<T> extends true ? IF : ELSE;
+
+declare function isUndefined<T extends Narrowable>(i: T): undefined extends T ? true : false;
+/**
+ * **ifUndefined**
+ *
+ * Strongly type-aware conditional statement which checks whether a value is
+ * _undefined_ and returns one of two values (strongly typed) based on the evaluation
+ * of this criteria.
+ *
+ * @param val the value being tested
+ * @param ifVal the value (strongly typed) returned if val is `undefined`
+ * @param elseVal the value (strongly typed) returned if val is NOT `undefined`
+ */
+declare function ifUndefined<T extends Narrowable, IF extends Narrowable, ELSE extends Narrowable>(val: T, ifVal: IF, elseVal: ELSE): IsUndefined<T> extends true ? IF : ELSE;
+
+type Type<T extends any, V extends Function> = {
+    name: string;
+    type: T;
+    typeGuard: TypeGuard<T>;
+    is: V;
+};
+declare const typeApi: () => {
+    readonly string: Type<string, typeof isString>;
+    readonly boolean: Type<boolean, typeof isBoolean>;
+    readonly number: Type<number, typeof isNumber>;
+    readonly function: Type<Function | (Function & {
+        [key: string]: any;
+    }), typeof isFunction>;
+    readonly null: Type<null, typeof isNull>;
+    readonly symbol: Type<symbol, typeof isSymbol>;
+    readonly undefined: Type<undefined, typeof isUndefined>;
+    readonly true: Type<true, typeof isTrue>;
+    readonly false: Type<false, typeof isFalse>;
+    readonly object: Type<Record<string, Narrowable>, typeof isObject>;
+    readonly array: Type<any[], typeof isArray>;
 };
+type TypeApi = ReturnType<typeof typeApi>;
+declare function isType<T extends any, V extends Function>(t: unknown): t is Type<T, V>;
+type TypeDefinition<T extends any, V extends Function> = (defn: TypeApi) => Type<T, V>;
+declare function type<T extends any, V extends Function>(fn: TypeDefinition<T, V>): Type<T, V>;
+
+/**
+ * **withValue**
+ *
+ * Reduces a dictionary object -- in both _type_ and _run-time_ structure -- to only those
+ * key/value pairs which have a specified value. For instance:
+ *
+ * ```ts
+ * const obj = { foo: 1, bar: 2, message: "hi there" };
+ * // { message: "hi there" }
+ * const onlyStrings = withValue(t => t.string)(obj);
+ * // { foo: 1 }
+ * const justOne = withValue(t => t.literal(1))(obj);
+ * ```
+ *
+ * Note: _often useful to provide run-time type profiles with the_ `inferredType` _utility_
+ */
+declare function withValue<T extends any, V extends Function>(td: TypeDefinition<T, V>): <N extends Narrowable, R extends Record<string, N>>(obj: R) => ExpandRecursively<Pick<R, KeysWithValue<T, R>>>;
 
-declare type Omit$1<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+type Omit$1<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
 interface IConfigurator<C = {}> {
     set<V, K extends string, KV = {
         [U in K]: V;
@@ -2383,4 +2440,4 @@ interface IFluentConfigurator<C> {
  */
 declare function FluentConfigurator<I>(initial?: I): IFluentConfigurator<{}>;
 
-export { AllCaps, Alpha, AlphaNumeric, Api, ApiFunction, ApiValue, AppendToDictionary, AppendToObject, ArrConcat, Array$1 as Array, ArrayConverter, AsArray, AsFinalizedConfig, AssertExtends, Bracket, Break, CamelCase, CapitalizeWords, Cardinality, Cardinality0, Cardinality1, CardinalityExplicit, CardinalityFilter0, CardinalityFilter1, CardinalityIn, CardinalityInput, CardinalityNode, CardinalityOut, CardinalityTuple, ClosingBracket, Condition, ConditionFilter, Configurator, ConfiguredMap, Constructor, DEFAULT_MANY_TO_ONE_MAPPING, DEFAULT_ONE_TO_MANY_MAPPING, DEFAULT_ONE_TO_ONE_MAPPING, DashToSnake, DashUppercase, Dasherize, DecomposeMapConfig, DefaultManyToOneMapping, DefaultOneToManyMapping, DefaultOneToOneMapping, DefinePropertiesApi, DictArrApi, DictArray, DictArrayFilterCallback, DictArrayKv, DictChangeValue, DictFromKv, DictKvTuple, DictPartialApplication, DictPrependWithFn, DictReturnValues, DynamicRule, DynamicRuleSet, Email, EnumValues, ExpandRecursively, ExpectExtends, ExplicitFunction, Extends, ExtendsClause, ExtendsNarrowlyClause, FilterContains, FilterDefn, FilterEnds, FilterEquals, FilterFn, FilterGreaterThan, FilterIs, FilterLessThan, FilterNotEqual, FilterStarts, FinalReturn, FinalizedMapConfig, First, FirstKey, FirstKeyValue, FirstOfEach, FluentConfigurator, FluentFunction, FromDictArray, FunctionType, GeneralDictionary, Get, HasUppercase, IConfigurator, IFluentConfigurator, If, IfBooleanLiteral, IfExtends, IfExtendsThen, IfLiteral, IfNumericLiteral, IfObject, IfOptionalLiteral, IfScalar, IfStringLiteral, Include, Includes, IntersectingKeys, IsArray, IsBoolean, IsBooleanLiteral, IsCapitalized, IsFalse, IsFunction, IsLiteral, IsNull, IsNumber, IsNumericLiteral, IsObject, IsOptionalLiteral, IsScalar, IsString, IsStringLiteral, IsTrue, KebabCase, KeyValue, KeyedRecord, Keys, KeysWithValue, KvFrom, KvTuple, LastInUnion, LeftWhitespace, Length, LogicFunction, LogicalCombinator, LowerAllCaps, LowerAlpha, ManyToMany, ManyToOne, ManyToZero, MapCard, MapCardinality, MapCardinalityFrom, MapCardinalityIllustrated, MapConfig, MapFn, MapFnInput, MapFnOutput, MapIR, MapInput, MapInputFrom, MapOR, MapOutput, MapOutputFrom, MapTo, Mapper, MapperApi, MaybeFalse, MaybeTrue, Model, Mutable, MutableProps, MutationFunction, MutationIdentity, Narrowable, NonAlpha, NonNumericKeys, NonStringKeys, Not, NotFilter, Numeric, NumericFilter, NumericKeys, NumericString, ObjectType, OneToMany, OneToOne, OneToZero, Opaque, OpeningBracket, OptRequired, OptionalKeys, OptionalProps, Parenthesis, PascalCase, Pluralize, PrivateKey, PrivateKeys, PublicKeys, Punctuation, PureFluentApi, Replace, RequireProps, RequiredKeys, RequiredProps, Retain, RightWhitespace, RuleDefinition, RuntimeProp, RuntimeType, SameKeys, SecondOfEach, SimplifyObject, SnakeCase, SpecialCharacters, StringDelimiter, StringFilter, StringKeys, StringLength, ToFluent, Transformer, Trim, TrimLeft, TrimRight, TupleToUnion, Type, TypeApi, TypeCondition, TypeDefault, TypeDefinition, TypeGuard, TypeOptions, UndefinedArrayIsUnknown, UndefinedTreatment, UndefinedValue, UnionToIntersection, UnionToTuple, UniqueDictionary, UniqueForProp, Uniqueness, UnwrapNot, UpperAlpha, ValueTuple, ValueTypeFunc, ValueTypes, Where, WhereNot, Whitespace, Widen, WithNumericKeys, WithStringKeys, WithValue, ZeroToMany, ZeroToOne, ZeroToZero, ZipCode, and, api, arrayToKeyLookup, arrayToObject, asArray, condition, createFnWithProps, createMutationFunction, defineProperties, defineType, dictArr, dictToKv, dictionaryTransform, entries, filter, filterDictArray, fnWithProps, groupBy, idLiteral, idTypeGuard, identity, ifBoolean, ifNull, ifNumber, ifString, ifTrue, ifTypeOf, ifUndefined, isArray, isBoolean, isFalse, isFunction, isNotFilter, isNull, isNumber, isNumericFilter, isObject, isString, isSymbol, isTrue, isType, isUndefined, keys, kindLiteral, kv, kvToDict, literal, mapTo, mapToDict, mapToFn, mapValues, nameLiteral, not, or, randomString, readonlyFnWithProps, ruleSet, strArrayToDict, type, typeApi, uuid, valueTypes, withValue };
+export { AfterFirst, AllCaps, Alpha, AlphaNumeric, AnyFunction, Api, ApiFunction, ApiValue, AppendToDictionary, AppendToObject, ArrConcat, Array$1 as Array, ArrayConverter, AsArray, AsFinalizedConfig, AssertExtends, Box, BoxValue, BoxedFnParams, BoxedReturn, Bracket, Break, CamelCase, CapitalizeWords, Cardinality, Cardinality0, Cardinality1, CardinalityExplicit, CardinalityFilter0, CardinalityFilter1, CardinalityIn, CardinalityInput, CardinalityNode, CardinalityOut, CardinalityTuple, ClosingBracket, Condition, ConditionFilter, Configurator, ConfiguredMap, Constructor, DEFAULT_MANY_TO_ONE_MAPPING, DEFAULT_ONE_TO_MANY_MAPPING, DEFAULT_ONE_TO_ONE_MAPPING, DashToSnake, DashUppercase, Dasherize, DecomposeMapConfig, DefaultManyToOneMapping, DefaultOneToManyMapping, DefaultOneToOneMapping, DefinePropertiesApi, DictArrApi, DictArray, DictArrayFilterCallback, DictArrayKv, DictChangeValue, DictFromKv, DictKvTuple, DictPartialApplication, DictPrependWithFn, DictReturnValues, DomainName, DynamicRule, DynamicRuleSet, Email, EndsWith, EnumValues, ExpandRecursively, ExpectExtends, ExplicitFunction, Extends, FilterContains, FilterDefn, FilterEnds, FilterEquals, FilterFn, FilterGreaterThan, FilterIs, FilterLessThan, FilterNotEqual, FilterStarts, FinalReturn, FinalizedMapConfig, First, FirstKey, FirstKeyValue, FirstOfEach, FirstOrUndefined, FirstString, FluentConfigurator, FluentFunction, FnShape, FromDictArray, FullyQualifiedUrl, FunctionType, GeneralDictionary, Get, HasUppercase, HybridFunction, IConfigurator, IFluentConfigurator, If, IfBooleanLiteral, IfExtends, IfExtendsThen, IfLiteral, IfNumericLiteral, IfObject, IfOptionalLiteral, IfScalar, IfStartsWith, IfStringLiteral, Include, Includes, IntersectingKeys, Ipv4, IsArray, IsBoolean, IsBooleanLiteral, IsCapitalized, IsFalse, IsFunction, IsLiteral, IsNull, IsNumber, IsNumericLiteral, IsObject, IsOptionalLiteral, IsScalar, IsStringLiteral, IsTrue, KebabCase, KeyValue, KeyedRecord, Keys, KeysWithValue, KvFrom, KvTuple, LastInUnion, LeftWhitespace, Length, LogicFunction, LogicalCombinator, LowerAllCaps, LowerAlpha, ManyToMany, ManyToOne, ManyToZero, MapCard, MapCardinality, MapCardinalityFrom, MapCardinalityIllustrated, MapConfig, MapFn, MapFnInput, MapFnOutput, MapIR, MapInput, MapInputFrom, MapOR, MapOutput, MapOutputFrom, MapTo, Mapper, MapperApi, MaybeFalse, MaybeTrue, Mutable, MutableProps, NarrowBox, Narrowable, NetworkProtocol, NonAlpha, NonNumericKeys, NonStringKeys, Not, NotFilter, Numeric, NumericFilter, NumericKeys, NumericString, ObjectType, OneToMany, OneToOne, OneToZero, Opaque, OpeningBracket, OptRequired, OptionalKeys, OptionalProps, Parenthesis, PascalCase, Pluralize, PrivateKey, PrivateKeys, PublicKeys, Punctuation, PureFluentApi, RelativeUrl, Replace, RequireProps, RequiredKeys, RequiredProps, Retain, RightWhitespace, RuleDefinition, RuntimeProp, RuntimeType, SameKeys, SecondOfEach, SimpleFunction, SimplifyObject, SnakeCase, SpecialCharacters, Split, StartsWith, StringDelimiter, StringFilter, StringKeys, StringLength, Suggest, SuggestNumeric, ToFluent, Transformer, Trim, TrimLeft, TrimRight, TupleToUnion, Type, TypeApi, TypeDefault, TypeDefinition, TypeGuard, TypeOptions, Unbox, UndefinedArrayIsUnknown, UndefinedTreatment, UndefinedValue, UnionToIntersection, UnionToTuple, UniqueDictionary, UniqueForProp, Uniqueness, UnwrapNot, UpperAlpha, UrlBuilder, VariableName, Where, WhereNot, Whitespace, Widen, WithNumericKeys, WithStringKeys, WithValue, ZeroToMany, ZeroToOne, ZeroToZero, ZipCode, and, api, arrayToKeyLookup, arrayToObject, asArray, box, condition, createFnWithProps, defineProperties, defineType, dictArr, dictToKv, dictionaryTransform, entries, filter, filterDictArray, fnWithProps, groupBy, idLiteral, idTypeGuard, identity, ifBoolean, ifNull, ifNumber, ifString, ifTrue, ifUndefined, isArray, isBoolean, isBox, isFalse, isFunction, isNotFilter, isNull, isNumber, isNumericFilter, isObject, isString, isSymbol, isTrue, isType, isUndefined, keys, kindLiteral, kv, kvToDict, literal, mapTo, mapToDict, mapToFn, mapValues, nameLiteral, not, or, readonlyFnWithProps, ruleSet, strArrayToDict, type, typeApi, unbox, withValue };