inferred-types 0.25.0 → 0.27.0

package/.vscode/settings.json

@@ -5,6 +5,7 @@
     "Aint",
     "Dasherize",
     "dasherized",
+    "fooy",
     "ruleset",
     "tokei",
     "Uncapitalize"

package/dist/index.d.ts

@@ -579,26 +579,52 @@ O extends (...args: any[]) => any = (...args: any[]) => any> = SimplifyObject<{
 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;
 
 /**
- * **MapTo**
+ * Expresses whether an option is "opt" (optional) or "req" (required)
+ */
+declare type OptRequired = "opt" | "req";
+
+/**
+ * Expresses relationship between inputs/outputs:
+ */
+declare enum MapDirection {
+    /** 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 MapDirectionVal = EnumValues<MapDirection>;
+declare type MapInput<I, IR, D extends MapDirectionVal> = D extends MapDirection.OneToMany | "I -> O[]" ? IR extends "opt" ? I | undefined : I : D extends MapDirection.OneToOne | "I -> O" ? IR extends "opt" ? I | undefined : I : D extends MapDirection.ManyToOne | "I[] -> O" ? IR extends "opt" ? I[] | undefined : I[] : never;
+declare type MapOutput<O, OR, D extends MapDirectionVal> = D extends MapDirection.OneToMany | "I -> O[]" ? OR extends "opt" ? O[] : [O, ...O[]] : D extends MapDirection.OneToOne | "I -> O" ? OR extends "opt" ? O | null : O : D extends MapDirection.ManyToOne | "I[] -> O" ? OR extends "opt" ? O | null : O : never;
+/**
+ * **MapTo<I, O>**
  *
- * Maps from one type `I` to another `O[]`
+ * A mapping function between an input type `I` and output type `O`.
  *
- * **Note:** because the output is an array you can easily support `1:1` and `1:M` mappings
- * but not a filtering operation (e.g., `1:0`); if you need this then use `MapToWithFiltering`
- * instead.
+ * **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 MapTo<I extends {}, O extends {}> = (i: I) => O[];
+declare type MapTo<I, O, IR extends OptRequired = "req", D extends MapDirectionVal = MapDirection.OneToMany, OR extends OptRequired = "opt"> = IR extends "opt" ? (source?: MapInput<I, IR, D>) => MapOutput<O, OR, D> : (source: MapInput<I, IR, D>) => MapOutput<O, OR, D>;
+declare type MapFnOutput<I, O, S, OR extends OptRequired, D extends MapDirectionVal> = D extends "I -> O[]" | MapDirection.OneToMany ? S extends I[] ? OR extends "opt" ? O[] : [O, ...O[]] : OR extends "opt" ? O[] | null : O[] : D extends MapDirection.OneToOne | "I -> O" ? S extends I[] ? OR extends "opt" ? O[] : [O, ...O[]] : OR extends "opt" ? O | null : O : D extends MapDirection.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 MapDirectionVal> = D extends "I -> O[]" | MapDirection.OneToMany ? IR extends "opt" ? I | I[] | undefined : I | I[] : D extends MapDirection.OneToOne | "I -> O" ? IR extends "opt" ? I | I[] | undefined : I | I[] : D extends MapDirection.ManyToOne | "I[] -> O" ? IR extends "opt" ? I[] | I[][] | undefined : I[] | I[][] : never;
 /**
- * **MapToWithFiltering**
- *
- * Maps from one type `I` to another `(O | null)[]`
+ * The mapping function provided by the `mapFn()` utility. This _fn_
+ * is intended to be used in two ways:
  *
- * **Note:** because the output is an array you can easily support `1:1` and `1:M` mappings
- * and the allowance of the conversion to result in a `null` value also means that filter
- * out an input value entirely is possible. If you don't need _filtering_ then use the
- * `MapTo` type instead.
+ * 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 approp)
+ *    const out2 = m(inputs);
+ *    ```
  */
-declare type MapToWithFiltering<I extends {}, O extends {}> = (i: I) => O[] | null;
+declare type MapFn<I, O, IR extends OptRequired = "req", D extends MapDirectionVal = MapDirection.OneToMany, OR extends OptRequired = "opt"> = IR extends "opt" ? <S extends MapFnInput<I, IR, D>>(source?: S) => MapFnOutput<I, O, S, OR, D> : <S extends MapFnInput<I, IR, D>>(source: S) => MapFnOutput<I, O, S, OR, D>;
 
 /**
  * Given a dictionary of type `<T>`, this utility function will
@@ -1061,6 +1087,77 @@ declare type _DU<T extends string> = T extends Lowercase<T> ? T : `-${Lowercase<
  */
 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>}` : "";
 
+/**
+ * Converts a Tuple type into a _union_ of the tuple elements
+ * ```ts
+ * const arr = [1, 3, 5] as const;
+ * // 1 | 3 | 5
+ * type U = TupleToUnion<typeof arr>;
+ * ```
+ */
+declare type TupleToUnion<T> = Mutable<T> extends any[] ? Mutable<T>[number] : never;
+
+/**
+ * LastInUnion<1 | 2> = 2.
+ */
+declare 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];
+
+declare type Widen<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T;
+
+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";
+/**
+ * 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 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
+ */
+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[];
+
 /**
  * Converts a string literal into a _dasherized_ format while ignoring _exterior_ whitespace.
  *
@@ -1192,6 +1289,11 @@ declare type PureFluentApi<TApi extends Record<string, (...args: any[]) => PureF
  */
 declare 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;
+
 declare type DictFromKv<T extends readonly Readonly<{
     key: string;
     value: unknown;
@@ -1272,15 +1374,6 @@ declare type DictArray<T> = Array<{
     [K in keyof T]: DictArrayKv<K, T>;
 }[keyof T]>;
 
-/**
- * LastInUnion<1 | 2> = 2.
- */
-declare 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];
-
 /**
  * Returns the _first_ key in an object.
  *
@@ -1309,18 +1402,6 @@ declare type FirstKeyValue<T extends object> = FirstKey<T> extends keyof T ? T[F
  */
 declare type FirstOfEach<T extends readonly any[][]> = T[number][0] extends T[number][number] ? T[number][0] : never;
 
-/**
- * Converts a Tuple type into a _union_ of the tuple elements
- * ```ts
- * const arr = [1, 3, 5] as const;
- * // 1 | 3 | 5
- * type U = TupleToUnion<typeof arr>;
- * ```
- */
-declare type TupleToUnion<T> = Mutable<T> extends any[] ? Mutable<T>[number] : never;
-
-declare type Widen<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T;
-
 /**
  * Typescript utility which receives `T` as shape which resembles `DictArray<D>`
  * and if the type `D` can be inferred it is returned.
@@ -1422,6 +1503,116 @@ declare function ruleSet<N extends Narrowable, TState extends Record<keyof TStat
 
 declare const api: <N extends Narrowable, TPrivate extends Readonly<Record<any, N>>>(priv: TPrivate) => <TPublic extends object>(pub: TPublic) => () => TPublic;
 
+/**
+ * Groups a number of "logic functions" together by combining their results using
+ * the logical **AND** operator.
+ *
+ * **Note:** a "logic function" is any function which returns a boolean
+ */
+declare const and: <T extends any[]>(...ops: readonly LogicFunction<T>[]) => LogicFunction<T>;
+
+/**
+ * Groups a number of "logic functions" together by combining their results using
+ * the logical **OR** operator.
+ *
+ * **Note:** a "logic function" is any function which returns a boolean
+ */
+declare const or: <T extends any[]>(...ops: LogicFunction<T>[]) => LogicFunction<T>;
+
+/**
+ * Groups a number of "logic functions" together by combining their results using
+ * the logical **NOT** operator.
+ *
+ * **Note:** a "logic function" is any function which returns a boolean
+ */
+declare const not: <T extends any[]>(op: LogicFunction<T>) => LogicFunction<T>;
+
+declare type FilterStarts = {
+    /** one or more string which the value is allowed to start with */
+    startsWith: string | string[];
+};
+declare type FilterIs = {
+    /** whether a string _**is**_ of a particular value */
+    is: string | string[];
+};
+declare type FilterEnds = {
+    endsWith: string | string[];
+};
+declare type FilterContains = {
+    /** whether any of the strings specified are _contained_ in the value */
+    contains: string | string[];
+};
+declare type FilterEquals = {
+    /** one or more values which _equal_ the value passed in */
+    equals: number | number[];
+};
+declare type FilterNotEqual = {
+    /** one or more values which ALL _do not equal_ the value passed in */
+    notEqual: number | number[];
+};
+declare type FilterGreaterThan = {
+    /** the incoming value is greater than this value */
+    greaterThan: number;
+};
+declare 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 = {
+    /**
+     * **not**
+     *
+     * If you want to build a filter who's conditions being met results in _filtering_
+     * the value rather than accepting it then choose this.
+     */
+    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;
+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";
+/**
+ * **FilterFn**
+ *
+ * A filter function derived from the `filter()` configurator. This function is intended to provide a type-strong _filter_ function which can be used like so:
+ * be used like:
+ * ```ts
+ * const onlyPrivate = filter({ startsWith: "_" });
+ * const privateFiles = files.filter(onlyPrivate);
+ * ```
+ *
+ */
+declare 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;
+/**
+ * **filter**
+ *
+ * A higher order helper utility which builds a boolean _filter_ function based on a simple
+ * configuration object. Support either _string_ or _numeric_ filters.
+ *
+ * ```ts
+ * const str = filter({startsWith: ["_", "."], endsWith: ".md"});
+ * const num = filter({ greaterThan: 55, notEqual: [66, 77]});
+ * ```
+ *
+ * All conditions (e.g., `startsWith`, `contains`, `notEqual`, etc.) that a particular filter
+ * is defined as having -- if there is more than one -- will be logically combined using AND
+ * unless specified otherwise in the third parameter.
+ *
+ * How a value of _undefined_ will be treated is stated in the second parameter but defaults
+ * to "no-impact" which means it's `false` when the logicCombinator is OR but defaults
+ * to `true` when the logicCombinator is AND.
+ */
+declare const filter: <F extends FilterDefn | NotFilter, U extends boolean | "no-impact", C extends LogicalCombinator>(config: F, logicCombinator?: C, ifUndefined?: U) => FilterFn<UnwrapNot<F>>;
+
 /**
  * Passing in an array of strings, you are passed back a dictionary with
  * all the keys being the strings and values set to `true`.
@@ -1509,32 +1700,74 @@ declare function entries<N extends Narrowable, T extends Record<string, N>, I ex
  */
 declare function mapValues<N extends Narrowable, T extends Record<string, N>, V>(obj: T, valueMapper: (k: T[keyof T]) => V): { [K in keyof T]: V; };
 
+interface MapConfig<IR extends OptRequired = "req", D extends MapDirectionVal = "I -> O[]", OR extends OptRequired = "opt"> {
+    input?: IR;
+    output?: OR;
+    direction?: D;
+}
 /**
- * **mapTo**
- *
- * A utility function which maps one dictionary structure `I` to another `O`; which allows
- * the transform to:
- *
- * - _split_ inputs into multiple outputs
- * - _map_ 1:1 between input and output
- * - _filter_ inputs which don't meet certain criteria (by returning `null`)
- *
- * This higher order function first asks for the mapping criteria:
- * ```ts
- * const mapper = mapTo<I,O>(i => i.name
- *  ? [
- *      { name: i.name, a: "static text", b: i.products.length }
- *    ]
- *  : null
- * );
- * ```
+ * Provides a mapper function using the default configuration
+ */
+declare type MapperApiDefault = <I, O>(map: MapTo<I, O>) => MapFn<I, O>;
+/**
+ * Provides opportunity to configure _input_ and _output_ relationships
+ * prior to providing a mapping function.
+ */
+declare type MapperApiConfigured = <IR extends OptRequired = "req", D extends MapDirectionVal = "I -> O[]", OR extends OptRequired = "opt">(config: MapConfig<IR, D, OR>) => <I, O>(map: MapTo<I, O, IR, D, OR>) => MapFn<I, O, IR, D, OR>;
+/**
+ * **mapTo** _utility_
  *
- * and now you'll have a _mapper_ variable will be assigned as a mapping fn:
+ * This utility creates a strongly typed data mapper which maps from one
+ * known source `I` to another `O`:
  * ```ts
- * function (source: I | I[]): O[]
+ * const mapper = mapTo<I, O>(i => [{
+ *    foo: i.bar
+ * }]);
  * ```
  */
-declare const mapTo: <I extends {}, O extends {}>(cb: MapToWithFiltering<I, O>) => (source: I | I[]) => O[];
+declare const mapToFn: <I, O>(map: (source: I) => O[]) => <S extends I | I[]>(source: S) => S extends I[] ? O[] : O[] | null;
+/**
+ * Provides a `config` method which allows the relationships between _inputs_
+ * and _outputs_ to be configured.
+ */
+declare const mapToDict: {
+    /** configure the relationship between the _inputs_ and _outputs_ */
+    config: <IR extends OptRequired = "req", D extends "I -> O[]" | "I -> O" | "I[] -> O" = "I -> O[]", OR extends OptRequired = "opt">(c?: MapConfig<IR, D, OR>) => {
+        /**
+         * create your mapping with your recently setup configuration:
+         * ```ts
+         * const mapper = mapTo
+         *  .config({ ... })
+         *  .map<I, O>(i => [{
+         *    foo: i.bar
+         * }]);
+         * ```
+         */
+        map<I, O>(map: MapTo<I, O, IR, D, OR>): MapFn<I, O, IR, D, OR>;
+    };
+};
+/**
+ * **mapTo** _utility_
+ *
+ * This utility creates a strongly typed data mapper which maps from one
+ * known source `I` to another `O`.
+ */
+declare const mapTo: (<I, O>(map: (source: I) => O[]) => <S extends I | I[]>(source: S) => S extends I[] ? O[] : O[] | null) & {
+    /** configure the relationship between the _inputs_ and _outputs_ */
+    config: <IR extends OptRequired = "req", D extends "I -> O[]" | "I -> O" | "I[] -> O" = "I -> O[]", OR extends OptRequired = "opt">(c?: MapConfig<IR, D, OR>) => {
+        /**
+         * create your mapping with your recently setup configuration:
+         * ```ts
+         * const mapper = mapTo
+         *  .config({ ... })
+         *  .map<I, O>(i => [{
+         *    foo: i.bar
+         * }]);
+         * ```
+         */
+        map<I, O>(map: MapTo<I, O, IR, D, OR>): MapFn<I, O, IR, D, OR>;
+    };
+};
 
 /**
  * converts an array of strings `["a", "b", "c"]` into a more type friendly
@@ -1592,6 +1825,24 @@ declare function kvToDict<K extends string, V extends Narrowable, T extends read
     value: V;
 }>[]>(kvArr: T): DictFromKv<T>;
 
+/**
+ * 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[]>;
+/**
+ * Ensures that any input passed in is passed back as an array:
+ *
+ * - if it was already an array than this just serves as an _identity_ function
+ * - if it was not then it wraps the element into a one element array of the
+ * given type
+ *
+ * Note: by default the _type_ of values will be intentionally widened so that the value "abc"
+ * is of type `string` not the literal `abc`. If you want to keep literal types then
+ * change the optional _widen_ parameter to _false_.
+ */
+declare const asArray: <T extends Narrowable, W extends boolean = true>(thing: T, _widen?: W | undefined) => AsArray<T, W>;
+
 /**
  * Groups an array of data based on the value of a property
  * in the objects within the array.
@@ -1707,33 +1958,6 @@ declare function idTypeGuard<T extends {
  */
 declare function literal<N extends Narrowable, T extends Record<keyof T, N>>(obj: T): T;
 
-declare type Filter<A> = {
-    kind: "Equals";
-    field: keyof A;
-    val: A[keyof A];
-} | {
-    kind: "Greater";
-    field: keyof A;
-    val: A[keyof A];
-} | {
-    kind: "Less";
-    field: keyof A;
-    val: A[keyof A];
-} | {
-    kind: "And";
-    a: Filter<A>;
-    b: Filter<A>;
-} | {
-    kind: "Or";
-    a: Filter<A>;
-    b: Filter<A>;
-};
-declare const equals: <A, K extends keyof A>(field: K, val: A[K]) => Filter<A>;
-declare const greater: <A, K extends keyof A>(field: K, val: A[K]) => Filter<A>;
-declare const less: <A, K extends keyof A>(field: K, val: A[K]) => Filter<A>;
-declare const and: <A>(a: Filter<A>, b: Filter<A>) => Filter<A>;
-declare const or: <A>(a: Filter<A>, b: Filter<A>) => Filter<A>;
-
 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;
@@ -1821,4 +2045,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, AssertExtends, Bracket, Break, CamelCase, CapitalizeWords, ClosingBracket, Condition, Configurator, Constructor, DashToSnake, DashUppercase, Dasherize, DefinePropertiesApi, DictArrApi, DictArray, DictArrayFilterCallback, DictArrayKv, DictChangeValue, DictFromKv, DictKvTuple, DictPartialApplication, DictPrependWithFn, DictReturnValues, DynamicRule, DynamicRuleSet, Email, EnumValues, ExpandRecursively, ExpectExtends, ExplicitFunction, ExtendsClause, ExtendsNarrowlyClause, Filter, FinalReturn, First, FirstKey, FirstKeyValue, FirstOfEach, FluentConfigurator, FluentFunction, FromDictArray, FunctionType, GeneralDictionary, Get, HasUppercase, IConfigurator, IFluentConfigurator, If, IfExtends, IfExtendsThen, Include, Includes, IsArray, IsBoolean, IsBooleanLiteral, IsCapitalized, IsFalse, IsFunction, IsLiteral, IsNumericLiteral, IsObject, IsString, IsStringLiteral, IsTrue, KebabCase, KeyValue, KeyedRecord, Keys, KeysWithValue, KvFrom, KvTuple, LastInUnion, LeftWhitespace, Length, LowerAllCaps, LowerAlpha, MapTo, MapToWithFiltering, MaybeFalse, MaybeTrue, Model, Mutable, MutableProps, MutationFunction, MutationIdentity, Narrowable, NonAlpha, NonNumericKeys, NonStringKeys, Not, Numeric, NumericKeys, NumericString, ObjectType, Opaque, OpeningBracket, 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, StringKeys, StringLength, ToFluent, Transformer, Trim, TrimLeft, TrimRight, TupleToUnion, Type, TypeApi, TypeCondition, TypeDefinition, TypeGuard, TypeOptions, UnionToIntersection, UnionToTuple, UniqueDictionary, UniqueForProp, Uniqueness, UpperAlpha, ValueTuple, ValueTypeFunc, ValueTypes, Where, WhereNot, Whitespace, Widen, WithNumericKeys, WithStringKeys, WithValue, ZipCode, and, api, arrayToKeyLookup, arrayToObject, condition, createFnWithProps, createMutationFunction, defineProperties, defineType, dictArr, dictToKv, dictionaryTransform, entries, equals, filterDictArray, fnWithProps, greater, groupBy, idLiteral, idTypeGuard, identity, ifTypeOf, isArray, isBoolean, isFalse, isFunction, isNull, isNumber, isObject, isString, isSymbol, isTrue, isType, isUndefined, keys, kindLiteral, kv, kvToDict, less, literal, mapTo, mapValues, nameLiteral, or, randomString, readonlyFnWithProps, ruleSet, strArrayToDict, type, typeApi, uuid, valueTypes, withValue };
+export { AllCaps, Alpha, AlphaNumeric, Api, ApiFunction, ApiValue, AppendToDictionary, AppendToObject, ArrConcat, Array$1 as Array, ArrayConverter, AsArray, AssertExtends, Bracket, Break, CamelCase, CapitalizeWords, Cardinality, Cardinality0, Cardinality1, CardinalityExplicit, CardinalityFilter0, CardinalityFilter1, CardinalityIn, CardinalityInput, CardinalityNode, CardinalityOut, CardinalityTuple, ClosingBracket, Condition, ConditionFilter, Configurator, Constructor, DashToSnake, DashUppercase, Dasherize, DefinePropertiesApi, DictArrApi, DictArray, DictArrayFilterCallback, DictArrayKv, DictChangeValue, DictFromKv, DictKvTuple, DictPartialApplication, DictPrependWithFn, DictReturnValues, DynamicRule, DynamicRuleSet, Email, EnumValues, ExpandRecursively, ExpectExtends, ExplicitFunction, ExtendsClause, ExtendsNarrowlyClause, FilterContains, FilterDefn, FilterEnds, FilterEquals, FilterFn, FilterGreaterThan, FilterIs, FilterLessThan, FilterNotEqual, FilterStarts, FinalReturn, First, FirstKey, FirstKeyValue, FirstOfEach, FluentConfigurator, FluentFunction, FromDictArray, FunctionType, GeneralDictionary, Get, HasUppercase, IConfigurator, IFluentConfigurator, If, IfExtends, IfExtendsThen, Include, Includes, IsArray, IsBoolean, IsBooleanLiteral, IsCapitalized, IsFalse, IsFunction, IsLiteral, IsNumericLiteral, IsObject, IsString, IsStringLiteral, IsTrue, KebabCase, KeyValue, KeyedRecord, Keys, KeysWithValue, KvFrom, KvTuple, LastInUnion, LeftWhitespace, Length, LogicFunction, LogicalCombinator, LowerAllCaps, LowerAlpha, ManyToMany, ManyToOne, ManyToZero, MapConfig, MapDirection, MapDirectionVal, MapFn, MapFnInput, MapFnOutput, MapInput, MapOutput, MapTo, MapperApiConfigured, MapperApiDefault, 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, 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, ifTypeOf, 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 };