inferred-types 0.15.0 → 0.18.0

package/dist/types/types/props.d.ts

@@ -1,100 +0,0 @@
-import { Alpha } from "common-types";
-/**
- * Extracts the _required_ keys in the object's type
- */
-export declare type RequiredKeys<T extends object> = {
-    [K in keyof T]-?: {} extends {
-        [P in K]: T[K];
-    } ? never : K;
-}[keyof T];
-/**
- * Extracts the _optional_ keys in the object's type
- */
-export declare type OptionalKeys<T extends object> = {
-    [K in keyof T]-?: {} extends {
-        [P in K]: T[K];
-    } ? K : 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
- * resultset.
- * ```ts
- * // "foo"
- * type Str = KeysWithValue<{ foo: "hi"; bar: 5 }>;
- * ```
- */
-export 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
- */
-export declare type PrivateKey = `_${Alpha}${string}`;
-/**
- * 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.
- */
-export declare type PrivateKeys<T extends object> = {
-    [K in keyof T]: K extends `_${string}` ? K : never;
-}[keyof T];
-/**
- * **PublicKeys**
- *
- * Builds a union type of all keys which are "public" where a public
- * key is any key which _does not_ start with the `_` character.
- */
-export declare type PublicKeys<T extends object> = {
-    [K in keyof T]: K extends `_${string}` ? never : K;
-}[keyof T];
-export declare type StringKeys<T extends object> = {
-    [K in keyof T]: K extends string ? Readonly<K> : never;
-}[keyof T];
-/**
- * The keys of an object which _are not_ a string type
- */
-export declare type NonStringKeys<T extends object> = {
-    [K in keyof T]: K extends string ? never : Readonly<K>;
-}[keyof T];
-export declare type NumericKeys<T extends object> = {
-    [K in keyof T]: K extends number ? Readonly<K> : never;
-}[keyof T];
-export declare type NonNumericKeys<T extends object> = {
-    [K in keyof T]: K extends number ? never : Readonly<K>;
-}[keyof T];
-/**
- * **RequiredProps**
- *
- * Reduces an object type to only key/value pairs where the key is required
- */
-export declare type RequiredProps<T extends object> = Pick<T, RequiredKeys<T>>;
-/**
- * **OptionalProps**
- *
- * Reduces an object to only key/value pairs where the key is optional
- */
-export declare type OptionalProps<T extends object> = Pick<T, RequiredKeys<T>>;
-/**
- * **WithValue**
- *
- * Reduces an object's type down to only those key/value pairs where the
- * value is of type `W`.
- * ```ts
- * const foo = { a: 1, b: "hi", c: () => "hello" }
- * // { c: () => "hello" }
- * type W = WithValue<Function, typeof foo>
- * ```
- */
-export 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.
- */
-export declare type WithStringKeys<T extends object> = Omit<T, NonStringKeys<T>>;
-/**
- * Reduces an object to only the key/value pairs where the key is numeric.
- */
-export declare type WithNumericKeys<T extends object> = Omit<T, NonNumericKeys<T>>;

package/dist/types/types/ruleset-types.d.ts

@@ -1,59 +0,0 @@
-import type { TypeCondition } from "../utility/runtime/ifTypeOf";
-import { OptionalKeys } from "./props";
-import { SameKeys } from "./SameKeys";
-/**
- * **RuleDefinition**
- *
- * A rule definition is the typing for the fluent API surface that is built up
- * with the **ruleset** utility.
- */
-export 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>;
-    /**
-     * 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>>;
-};
-/**
- * **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");
- * ```
- */
-export declare 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.
- */
-export declare type DynamicRuleSet<TState extends any, TRules extends Record<string, TypeCondition<any, TState>>> = (rules: TRules) => true | false;

package/dist/types/types/runtime.d.ts

@@ -1,33 +0,0 @@
-import { TypeGuard } from "./index";
-export declare type RuntimeType<T> = {
-    __kind: "type";
-    type: T;
-    is: TypeGuard<T>;
-};
-export declare 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"]>>;
-};
-export 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;

package/dist/types/types/string-literals/Break.d.ts

@@ -1,12 +0,0 @@
-/**
- * **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", " ">;
- * ```
- */
-export 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, ""]));

package/dist/types/types/string-literals/Concat.d.ts

@@ -1,8 +0,0 @@
-/**
- * Concatenates two arrays (of literals).
- * ```ts
- * // [ "foo", "bar", "baz" ]
- * type T = ArrConcat<["foo"], ["bar", "baz"]>;
- * ```
- */
-export declare type ArrConcat<A extends any[], B extends any[]> = [...A, ...B];

package/dist/types/types/string-literals/LeftWhitespace.d.ts

@@ -1,9 +0,0 @@
-import type { Replace, TrimLeft } from "../index";
-/**
- * Provides the _left_ whitespace of a string
- * ```ts
- * // "\n\t "
- * type T = LeftWhitespace<"\n\t foobar">;
- * ```
- */
-export declare type LeftWhitespace<S extends string> = string extends S ? string : Replace<S, TrimLeft<S>, "">;

package/dist/types/types/string-literals/Replace.d.ts

@@ -1,11 +0,0 @@
-/**
- * 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", "">;
- * ```
- *
- * Note: _the first match is replaced and all subsequent matches are ignored_
- */
-export 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;

package/dist/types/types/string-literals/RightWhitespace.d.ts

@@ -1,9 +0,0 @@
-import type { Replace, TrimRight } from "../index";
-/**
- * Provides the _left_ whitespace of a string
- * ```ts
- * // "\n\t "
- * type T = LeftWhitespace<"\n\t foobar">;
- * ```
- */
-export declare type RightWhitespace<S extends string> = string extends S ? string : Replace<S, TrimRight<S>, "">;

package/dist/types/types/string-literals/StringLength.d.ts

@@ -1,10 +0,0 @@
-/**
- * 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">;
- * ```
- */
-export 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"];

package/dist/types/types/string-literals/Trim.d.ts

@@ -1,11 +0,0 @@
-import { Whitespace } from "../alphabetic/index";
-/**
- * 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>;
- * ```
- */
-export 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;

package/dist/types/types/string-literals/TrimLeft.d.ts

@@ -1,11 +0,0 @@
-import { Whitespace } from "../alphabetic/index";
-/**
- * Trims off whitespace on left of string
- * ```ts
- * // "foobar "
- * type T = TrimLeft<"\n\t  foobar ">;
- * // string
- * type T = TrimLeft<string>;
- * ```
- */
-export declare type TrimLeft<S extends string> = string extends S ? string : S extends `${Whitespace}${infer Right}` ? TrimLeft<Right> : S;

package/dist/types/types/string-literals/TrimRight.d.ts

@@ -1,11 +0,0 @@
-import { Whitespace } from "../alphabetic/index";
-/**
- * Trims off whitespace on left of string
- * ```ts
- * // "\n foobar"
- * type T = TrimRight<"\n foobar \t">;
- * // string
- * type T = TrimRight<string>;
- * ```
- */
-export declare type TrimRight<S extends string> = string extends S ? string : S extends `${infer Right}${Whitespace}` ? TrimRight<Right> : S;

package/dist/types/types/string-literals/form-fields.d.ts

@@ -1,12 +0,0 @@
-import { NumericString } from "../alphabetic/alpha-characters";
-/**
- * An email address
- */
-export 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
- */
-export declare type ZipCode = Zip5 | `${Zip5}-${Zip4}`;
-export {};

package/dist/types/types/string-literals/index.d.ts

@@ -1,10 +0,0 @@
-export * from "./Break";
-export * from "./Concat";
-export * from "./LeftWhitespace";
-export * from "./Replace";
-export * from "./RightWhitespace";
-export * from "./StringLength";
-export * from "./Trim";
-export * from "./TrimLeft";
-export * from "./TrimRight";
-export * from "./form-fields";

package/dist/types/types/tuples/DictArray.d.ts

@@ -1,19 +0,0 @@
-export declare 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]`.
- */
-export declare type DictArrayKv<K extends keyof T, T> = [K, Pick<T, K>];
-export declare 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.
- * ```ts
- * const example: DictArray<{ foo: 1, bar: "hi" }> = [
- *   [ "foo", { foo: 1 }],
- *   [ "bar", { bar: "hi" }]
- * ]
- * ```
- */
-export declare type DictArray<T> = Array<{
-    [K in keyof T]: DictArrayKv<K, T>;
-}[keyof T]>;

package/dist/types/types/tuples/FirstKey.d.ts

@@ -1,8 +0,0 @@
-import type { Keys, UnionToTuple } from "../index";
-/**
- * Returns the _first_ key in an object.
- *
- * **Note:** key order is not guarenteed so typically this is used
- * for a key/value pair where only one key is expected
- */
-export declare type FirstKey<T extends object> = UnionToTuple<Keys<T>>[0];

package/dist/types/types/tuples/FirstKeyValue.d.ts

@@ -1,8 +0,0 @@
-import { FirstKey } from "./FirstKey";
-/**
- * Utility type which operates on a dictionary and provides the **value** of the
- * `First<T>` key of the dictionary. Because dictionary's don't provide assurances
- * about key order, this is typically only used in cases where it's known there is
- * a single key on the object.
- */
-export declare type FirstKeyValue<T extends object> = FirstKey<T> extends keyof T ? T[FirstKey<T>] : never;

package/dist/types/types/tuples/FirstOfEach.d.ts

@@ -1,11 +0,0 @@
-/**
- * For a two-dimensional array, returns a _union type_ which combines the first element of the interior
- * array.
- *
- * ```ts
- * const test = [ ["foo", 1], ["bar", 2] ];
- * // "foo" | "bar"
- * type F = FirstOfEach<typeof test>;
- * ```
- */
-export declare type FirstOfEach<T extends readonly any[][]> = T[number][0] extends T[number][number] ? T[number][0] : never;

package/dist/types/types/tuples/FromDictArray.d.ts

@@ -1,10 +0,0 @@
-import { ExpandRecursively, UnionToIntersection } from "../index";
-/**
- * Typescript utility which recieves `T` as shape which resembles `DictArray<D>`
- * and if the type `D` can be inferred it is returned.
- * ```ts
- * // { foo: 1; bar: "hi" }
- * type Dict = FromDictArray<[["foo", { foo: 1 }], ["bar", { bar: "hi" }]]>;
- * ```
- */
-export declare type FromDictArray<T extends [string, Record<string, unknown>][]> = ExpandRecursively<UnionToIntersection<T[number][1]>>;

package/dist/types/types/tuples/SecondOfEach.d.ts

@@ -1,10 +0,0 @@
-/**
- * For a two-dimensional array, returns a _union type_ which combines the first element of the interior
- * array.
- *
- * ```ts
- * // 1 | 2
- * type F = SecondOfEach<[ ["foo", 1], ["bar", 2] ]>;
- * ```
- */
-export declare type SecondOfEach<T extends any[][]> = T[number][1] extends T[number][number] ? T[number][1] : never;

package/dist/types/types/tuples/index.d.ts

@@ -1,6 +0,0 @@
-export * from "./DictArray";
-export * from "./FirstKey";
-export * from "./FirstKeyValue";
-export * from "./FirstOfEach";
-export * from "./FromDictArray";
-export * from "./SecondOfEach";

package/dist/types/types/type-conversion/TupleToUnion.d.ts

@@ -1,10 +0,0 @@
-import { Mutable } from "../Mutable";
-/**
- * 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>;
- * ```
- */
-export declare type TupleToUnion<T> = Mutable<T> extends any[] ? Mutable<T>[number] : never;

package/dist/types/types/type-conversion/UnionToIntersection.d.ts

@@ -1,5 +0,0 @@
-/**
- * UnionToIntersection<{ foo: string } | { bar: string }> =
- *  { foo: string } & { bar: string }.
- */
-export declare type UnionToIntersection<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;

package/dist/types/types/type-conversion/UnionToTuple.d.ts

@@ -1,9 +0,0 @@
-import { UnionToIntersection } from "./UnionToIntersection";
-/**
- * LastInUnion<1 | 2> = 2.
- */
-export declare type LastInUnion<U> = UnionToIntersection<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
-/**
- * UnionToTuple<1 | 2> = [1, 2].
- */
-export declare type UnionToTuple<U, Last = LastInUnion<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, Last>>, Last];

package/dist/types/types/type-conversion/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./TupleToUnion";
-export * from "./UnionToIntersection";
-export * from "./UnionToTuple";

package/dist/types/types/type-testing.d.ts

@@ -1,13 +0,0 @@
-/**
- * Validates that a given type extends another and returns `true` or `false` type
- */
-export 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
- */
-export declare type AssertExtends<VALUE, EXPECTED> = EXPECTED extends VALUE ? any : never;
-export declare type IfExtends<VALUE, EXPECTED> = EXPECTED extends VALUE ? VALUE : never;
-/**
- * Give a type `TValue` and a comparison type `TExtends`
- */
-export declare type IfExtendsThen<VALUE, EXPECTED, THEN> = EXPECTED extends VALUE ? THEN : never;

package/dist/types/utility/api/api.d.ts

@@ -1,2 +0,0 @@
-import { Narrowable } from "../../types/index";
-export declare const api: <N extends Narrowable, TPrivate extends Readonly<Record<any, N>>>(priv: TPrivate) => <TPublic extends object>(pub: TPublic) => () => TPublic;

package/dist/types/utility/api/index.d.ts

@@ -1 +0,0 @@
-export * from "./api";

package/dist/types/utility/createFnWithProps.d.ts

@@ -1 +0,0 @@
-export declare function createFnWithProps<F extends Function, P extends {}>(fn: F, props: P): F & P;

package/dist/types/utility/dictionary/arrayToKeyLookup.d.ts

@@ -1,10 +0,0 @@
-/**
- * Passing in an array of strings, you are passed back a dictionary with all the keys
- * being the strings and values set to `true`.
- *
- * ```ts
- * // { foo: true, bar: true }
- * const fooBar = arrayToKeyLookup("foo", "bar");
- * ```
- */
-export declare function arrayToKeyLookup<T extends readonly string[]>(...keys: T): Record<T[number], true>;

package/dist/types/utility/dictionary/dictFilter.d.ts

@@ -1,8 +0,0 @@
-import { Narrowable } from "../../types/index";
-export declare type ObjFilterCallback<T extends object, R extends boolean> = (k: keyof T, state: T) => R;
-/**
- * **dictFilter**
- *
- * Provides a means ot filter down the properties on a given object.
- */
-export declare function dictFilter<N extends Narrowable, T extends Record<string, N>, R extends boolean>(obj: T, cb: ObjFilterCallback<T, R>): Exclude<T, (keyof T)[]>;

package/dist/types/utility/dictionary/dictionaryTransform.d.ts

@@ -1,9 +0,0 @@
-import { SameKeys, Transformer } from "../../types/index";
-/**
- * Takes a dictionary of type `I` and converts it to a dictionary of type `O` where
- * they _keys_ used in both dictionaries are the same.
- *
- * The _transform_ function passed in must be able to recieve the full input object
- * and key, and then return expected value of `O` for the given key.
- */
-export declare function dictionaryTransform<I extends object, O extends SameKeys<I>>(i: I, transform: Transformer<I, O>): O;

package/dist/types/utility/dictionary/entries.d.ts

@@ -1,17 +0,0 @@
-import { KeyValue, Narrowable } from "../../types/index";
-/**
- * **entries**
- *
- * Provides an _interable_ over the passed in dictionary object where each iteration
- * provides a tuple of `[ key, value ]` which preserve type literals.
- *
- * For example:
- * ```ts
- * const obj = { foo: 1, bar: "hi" };
- * // k type is "foo" then "bar"; v type is 1 then "hi"
- * for (const [k, v] of entries(obj)) { ... }
- * ```
- */
-export declare function entries<N extends Narrowable, T extends Record<string, N>, I extends KeyValue<T, keyof T>>(obj: T): {
-    [Symbol.iterator](): Generator<I, void, unknown>;
-};

package/dist/types/utility/dictionary/index.d.ts

@@ -1,8 +0,0 @@
-export * from "./arrayToKeyLookup";
-export * from "./dictFilter";
-export * from "./dictionaryTransform";
-export * from "./entries";
-export * from "./mapValues";
-export * from "./strArrayToDict";
-export * from "./valuesOfProp";
-export * from "./kv/index";

package/dist/types/utility/dictionary/kv/dictToKv.d.ts

@@ -1,16 +0,0 @@
-import { Mutable, Narrowable, UnionToTuple } from "../../../types/index";
-import { KvFrom } from "../../../types/kv/KvFrom";
-/**
- * Converts a dictionary object into an array of dictionaries with `key` and `value` properties
- * ```ts
- * // [ { key: "id", value: 123 }, { key: "foo", value: "bar" } ]
- * const arr = dictToKv({ id: 123, foo: "bar" });
- * ```
- */
-export declare function dictToKv<N extends Narrowable, T extends Record<string, N>, U extends boolean>(obj: T, _makeTuple?: U): U extends true ? UnionToTuple<{ [K in keyof Mutable<T>]: {
-    key: K;
-    value: Mutable<T>[K];
-}; }[keyof T], import("../../../types/index").LastInUnion<{ [K in keyof Mutable<T>]: {
-    key: K;
-    value: Mutable<T>[K];
-}; }[keyof T]>> : KvFrom<Mutable<T>>;

package/dist/types/utility/dictionary/kv/filterDictArray.d.ts

@@ -1,9 +0,0 @@
-import type { DictArray, DictArrayFilterCallback } from "../../../types/index";
-export interface Array<T> {
-    filter<U extends T>(pred: (a: T) => a is U): U[];
-}
-/**
- * Accepts a `DictArray` and a callback which receives each key
- * value pair.
- */
-export declare function filterDictArray<T extends object, C extends DictArrayFilterCallback<keyof T, T, true | false>>(dictArr: DictArray<T>, cb: C): DictArray<Omit<T, "">>;

package/dist/types/utility/dictionary/kv/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./dictToKv";
-export * from "./filterDictArray";
-export * from "./kv";
-export * from "./kvToDict";

package/dist/types/utility/dictionary/kv/kv.d.ts

@@ -1,10 +0,0 @@
-import { ExpandRecursively, Narrowable } from "../../../types/index";
-/**
- * Build a key-value pair where both _key_ and _value_ are inferred. This
- * includes ensuring that the _key_ is a type literal not just a "string".
- *
- * > note: the value will be inferred but if you need to constrain it
- * > to a narrower type then both inferrences will break and you should
- * > instead use `KV2` to get this capability.
- */
-export declare function kv<K extends string, N extends Narrowable, V extends Record<any, N> | boolean | number | string | null | undefined>(key: K, value: V): ExpandRecursively<Record<K, V>>;

package/dist/types/utility/dictionary/kv/kvToDict.d.ts

@@ -1,15 +0,0 @@
-import { Narrowable } from "../../../types/index";
-import { DictFromKv } from "../../../types/kv/index";
-/**
- * Converts an array of dictionaries with `key` and `value` properties to a singular dictionary.
- * ```ts
- * // { id: 123, foo: "bar" }
- * const arr = kvToDict([{ key: "id", value: 123 }, { key: "foo", value: "bar" }]);
- * ```
- *
- * Note: this is the inverse of `dictToKv()` function
- */
-export declare function kvToDict<K extends string, V extends Narrowable, T extends readonly Readonly<{
-    key: K;
-    value: V;
-}>[]>(kvArr: T): DictFromKv<T>;

package/dist/types/utility/dictionary/mapValues.d.ts

@@ -1,13 +0,0 @@
-import { Narrowable } from "../../types/index";
-/**
- * **mapValues**
- *
- * Maps over a dictionary, preserving the keys but allowing the values to be mutated.
- *
- * ```ts
- * const colors = { red: 4, blue: 2, green: 3 };
- * // { red: 8, blue: 4, green: 6 }
- * const twoX = mapValues(colors, v => v * 2);
- * ```
- */
-export 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; };

package/dist/types/utility/dictionary/strArrayToDict.d.ts

@@ -1,6 +0,0 @@
-import { ExpandRecursively } from "../../types/ExpandRecursively";
-/**
- * converts an array of strings `["a", "b", "c"]` into a more type friendly
- * dictionary of the type `{ a: true, b: true, c: true }`
- */
-export declare function strArrayToDict<T extends readonly string[]>(...strings: T): ExpandRecursively<Record<T[number], true>>;

package/dist/types/utility/dictionary/valuesOfProp.d.ts

@@ -1 +0,0 @@
-export declare function valuesOfProp<_T extends object>(): void;

package/dist/types/utility/index.d.ts

@@ -1,10 +0,0 @@
-export * from "./createFnWithProps";
-export * from "./keys";
-export * from "./ruleset";
-export * from "./api/index";
-export * from "./dictionary/index";
-export * from "./literals/index";
-export * from "./map-reduce/index";
-export * from "./modelling/index";
-export * from "./runtime/index";
-export * from "./state/index";