inferred-types 0.16.0 → 0.18.1

package/dist/types/types/alphabetic/AllCaps.d.ts

@@ -1,12 +0,0 @@
-/**
- * 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>;
- * ```
- */
-export declare type AllCaps<T extends string> = string extends T ? "unknown" : T extends Uppercase<T> ? true : false;

package/dist/types/types/alphabetic/CamelCase.d.ts

@@ -1,2 +0,0 @@
-import { PascalCase } from "./index";
-export declare type CamelCase<S extends string> = Uncapitalize<PascalCase<S>>;

package/dist/types/types/alphabetic/CapFirstAlpha.d.ts

@@ -1,13 +0,0 @@
-import type { NonAlpha, Replace } from "../index";
-/**
- * Strips the non-alpha characters that lead a string
- */
-export declare type StripLeftNonAlpha<S extends string> = S extends `${infer First}${infer Rest}` ? First extends NonAlpha ? StripLeftNonAlpha<Rest> : S : never;
-/**
- * identifies the leading characters which are _not_ alphabetical
- */
-export declare type LeadingNonAlpha<S extends string> = Replace<S, StripLeftNonAlpha<S>, "">;
-/**
- * Capitalize the first alphabetical character in the string
- */
-export declare type CapFirstAlpha<T extends string> = LeadingNonAlpha<T> extends string ? `${LeadingNonAlpha<T>}${Capitalize<Replace<T, LeadingNonAlpha<T>, "">>}` : Capitalize<T>;

package/dist/types/types/alphabetic/CapitalizeWords.d.ts

@@ -1,4 +0,0 @@
-/**
- * Capitalize all words in a string
- */
-export 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>;

package/dist/types/types/alphabetic/DashToSnake.d.ts

@@ -1 +0,0 @@
-export declare type DashToSnake<T extends string> = T extends `${infer HEAD}-${infer TAIL}` ? DashToSnake<`${HEAD}_${TAIL}`> : T;

package/dist/types/types/alphabetic/DashUppercase.d.ts

@@ -1,14 +0,0 @@
-import { HasUppercase } from "./HasUppercase";
-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">;
- * ```
- *
- * _Intended to be used as a lower level utility; prefer `Dasherize<T>` for more full-fledged
- * dash solution_.
- */
-export 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>}` : "";
-export {};

package/dist/types/types/alphabetic/Dasherize.d.ts

@@ -1,15 +0,0 @@
-import { DashUppercase, LowerAllCaps } from "../index";
-import { Trim } from "../string-literals/index";
-/**
- * Converts a string literal into a _dasherized_ format while ignoring _exterior_ whitepace.
- *
- * ```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">;
- * ```
- */
-export 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>>>>>;

package/dist/types/types/alphabetic/HasUppercase.d.ts

@@ -1,13 +0,0 @@
-import { UpperAlpha } from "./alpha-characters";
-/**
- * Indicates whether `T` has uppercase characters in it.
- * ```ts
- * // true
- * type T = HasUppercase<"Foobar">;
- * // false
- * type T = HasUppercase<"foobar">;
- * // "unknown"
- * type T = HasUppercase<string>;
- * ```
- */
-export declare type HasUppercase<T extends string> = string extends T ? "unknown" : T extends `${string}${UpperAlpha}${string}` ? true : false;

package/dist/types/types/alphabetic/Intrinsic.d.ts

@@ -1,4 +0,0 @@
-export declare type Capitalize<T> = intrinsic;
-export declare type Uncapitalize<T> = intrinsic;
-export declare type Uppercase<T> = intrinsic;
-export declare type Lowercase<T> = intrinsic;

package/dist/types/types/alphabetic/IsCapitalized.d.ts

@@ -1,15 +0,0 @@
-/**
- * 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>;
- * ```
- *
- * Note: _if the value passed in is a "string" then the result will be "unknown"_
- */
-export declare type IsCapitalized<T extends string> = string extends T ? "unknown" : T extends Capitalize<T> ? true : false;

package/dist/types/types/alphabetic/KebabCase.d.ts

@@ -1,12 +0,0 @@
-import type { Dasherize } from "./index";
-/**
- * **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">;
- * ``` */
-export declare type KebabCase<T extends string> = Dasherize<T>;

package/dist/types/types/alphabetic/LowerAllCaps.d.ts

@@ -1,4 +0,0 @@
-import { AllCaps } from "./AllCaps";
-/**
- * If **ALL CAPS** it converts to all lowercase; if not then it does nothing */
-export declare type LowerAllCaps<T extends string> = AllCaps<T> extends true ? Lowercase<T> : T;

package/dist/types/types/alphabetic/PascalCase.d.ts

@@ -1,16 +0,0 @@
-import type { Capitalize, LowerAllCaps, Trim } from "../index";
-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">;
- * ```
- */
-export 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>>>;
-export {};

package/dist/types/types/alphabetic/Pluralize.d.ts

@@ -1,36 +0,0 @@
-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;
-/**
- * strings which end in the letters "is" should have an "es" added to the end
- */
-declare type PluralizeEndingIn_IS<T extends string> = T extends `${infer HEAD}is` ? `${HEAD}ises` : T;
-/**
- * singular nouns should have "es" added to the end
- */
-declare type PluralizeEndingSingularNoun<T extends string> = T extends `${infer HEAD}${SingularNoun}` ? `${T}es` : T;
-/**
- * strings which end in the letters "f" or "fe" should have "ves" replace the ending
- */
-declare type PluralizeEnding_F<T extends string> = T extends `${infer HEAD}${F}` ? `${HEAD}ves` : T;
-/**
- * singular nouns should have "es" added to the end
- */
-declare type PluralizeEndingIn_Y<T extends string> = T extends `${infer HEAD}${Y}` ? `${RemoveTrailingY<T>}ies` : T;
-export 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`;
-export {};

package/dist/types/types/alphabetic/SnakeCase.d.ts

@@ -1,14 +0,0 @@
-import type { DashUppercase, LowerAllCaps, Trim } from "../index";
-/** 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_.
- * ```ts
- * // "foo_bar"
- * type T = SnakeCase<"fooBar">;
- * type T = SnakeCase<"FooBar">;
- * type T = SnakeCase<"foo-bar">;
- * type T = SnakeCase<"\n foo bar \t">;
- * ``` */
-export 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>>>>>;
-export {};

package/dist/types/types/alphabetic/alpha-characters.d.ts

@@ -1,36 +0,0 @@
-export 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 */
-export declare type UpperAlpha = Uppercase<LowerAlpha>;
-/**
- * Alphabetical characters (upper and lower)
- */
-export declare type Alpha = UpperAlpha | LowerAlpha;
-export declare type Whitespace = " " | "\n" | "\t";
-export declare type Punctuation = "." | "," | ";" | "!" | "?";
-/**
- * Characters which typically are used to separate words (but not including a space)
- */
-export declare type StringDelimiter = "_" | "-" | "/" | "\\";
-export declare type OpenningBracket = "(" | "[" | "{";
-export declare type ClosingBracket = ")" | "]" | "}";
-/**
- * Openning and closing parenthesis
- */
-export declare type Parenthesis = "(" | ")";
-/**
- * Openning and closing brackets
- */
-export declare type Bracket = OpenningBracket | ClosingBracket;
-/**
- * Numeric string characters
- */
-export declare type NumericString = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
-/**
- * Any alphabetic or numeric string character
- */
-export declare type AlphaNumeric = Alpha | NumericString;
-export declare type SpecialCharacters = "@" | "~" | "^" | "#" | "&" | "*";
-/**
- * Non-alphabetic characters including whitespace, string numerals, and
- */
-export declare type NonAlpha = Whitespace | Punctuation | NumericString | Bracket | SpecialCharacters;

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

@@ -1,16 +0,0 @@
-export * from "./AllCaps";
-export * from "./CamelCase";
-export * from "./CapFirstAlpha";
-export * from "./CapitalizeWords";
-export * from "./DashToSnake";
-export * from "./DashUppercase";
-export * from "./Dasherize";
-export * from "./HasUppercase";
-export * from "./Intrinsic";
-export * from "./IsCapitalized";
-export * from "./KebabCase";
-export * from "./LowerAllCaps";
-export * from "./PascalCase";
-export * from "./Pluralize";
-export * from "./SnakeCase";
-export * from "./alpha-characters";

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

@@ -1,9 +0,0 @@
-export declare 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>
- */
-export declare type AppendToDictionary<TDict, TKey extends string, TValue> = {
-    [K in keyof TDict | TKey]: K extends keyof TDict ? TDict[K] : TValue;
-};

package/dist/types/types/dictionary/Get.d.ts

@@ -1,7 +0,0 @@
-/**
- * Get the type of a property of an object:
- * ```ts
- * const car = { make: "Chevy", model: "Malibu", }
- * ```
- */
-export 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;

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

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

package/dist/types/types/fluent.d.ts

@@ -1,51 +0,0 @@
-/**
- * **ToFluent**
- *
- * Converts the typing of a dictionary of functions into the same
- * function signatures but changes the return type to be the Fluent API.
- *
- * **Note:** this utility also allows a non-fluent API surface `X` to be included as
- * part of the API surface if this is desired.
- */
-export declare type ToFluent<T extends {
-    [key: string]: (...args: any[]) => any;
-}, X extends object = {}> = {
-    [K in keyof T]: (...args: Parameters<T[K]>) => ToFluent<T, X> & X;
-} & X;
-/**
- * A _pure_ Fluent API which promotes an API surface where _every_ API endpoint must be a function
- * which returns the same API surface.
- *
- * To provide value, this style of Fluent API will need to perform useful _side effects_ when functions
- * on the API surface are called as this structure does not provide any means to maintain an internal state
- * which can be returned later.
- *
- * **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._
- */
-export declare 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>>;
-};
-/**
- * Represents a **Fluent API** which exposes a API as a dictionary of functions. These functions will:
- *
- * 1. mutate an internal state or cause useful side-effects
- * 2. return the same API surface
- *
- * While in the case where the Fluent API is used to cause useful side effects, you might only
- * need the Fluent API surface to achieve your objectives but if instead it is used to
- * build up a useful _internal state_, then we must allow for
- * If this were 100% pure, however, the internal state would be unreachable and this pattern would
- * not be very valuable. Therefore, a secondary API, is expressed which allows for non-fluent
- *
- * At some point the internal state will be configured "enough" and the API will be extended to allow
- * the extraction of this state. This functional goal is expressed with the following generics:
- *
- * - `TFluent` is the fluent API which exposes a dictionary of functions
- * - `TEscape` is a non-fluent API used to do whatever you like but often is the means to
- * pass out the interior state which has been configured by the fluent parts of the API
- * - `TExclude` represents part of the API which -- due to the internal state -- should be hidden
- */
-export declare type FluentApi<TFluent extends {
-    [K in keyof TFluent]: (...args: Parameters<TFluent[K]>) => FluentApi<TFluent, TEscape>;
-}, TEscape extends object = {}, TExclude extends string = ""> = Omit<TFluent & TEscape, TExclude>;

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

@@ -1,34 +0,0 @@
-export * from "./Api";
-export * from "./EnumValues";
-export * from "./ExpandRecursively";
-export * from "./First";
-export * from "./FunctionType";
-export * from "./If";
-export * from "./Include";
-export * from "./Includes";
-export * from "./KeyedRecord";
-export * from "./Keys";
-export * from "./Length";
-export * from "./Mutable";
-export * from "./Narrowable";
-export * from "./Not";
-export * from "./Numeric";
-export * from "./Opaque";
-export * from "./Retain";
-export * from "./SameKeys";
-export * from "./Transformer";
-export * from "./TypeGuard";
-export * from "./append-types";
-export * from "./fluent";
-export * from "./maybe";
-export * from "./props";
-export * from "./ruleset-types";
-export * from "./runtime";
-export * from "./type-testing";
-export * from "./alphabetic/index";
-export * from "./dictionary/index";
-export * from "./kv/index";
-export * from "./lists/index";
-export * from "./string-literals/index";
-export * from "./tuples/index";
-export * from "./type-conversion/index";

package/dist/types/types/kv/DictFromKv.d.ts

@@ -1,6 +0,0 @@
-export declare type DictFromKv<T extends readonly Readonly<{
-    key: string;
-    value: unknown;
-}>[]> = {
-    [R in T[number] as R["key"]]: R["value"];
-};

package/dist/types/types/kv/KeyValue.d.ts

@@ -1,11 +0,0 @@
-import { ExpandRecursively } from "../ExpandRecursively";
-/**
- * Provides a strongly typed _key_ and _value_ for a dictionary `T`
- *
- * ```ts
- * type Obj = { foo: 1, bar: "hi" };
- * // ["foo", 1 ]
- * type Foo = KeyValue<Obj, "foo">;
- * ```
- */
-export declare type KeyValue<T extends object, K extends keyof T> = [K & keyof T, ExpandRecursively<T[K]>];

package/dist/types/types/kv/KvFrom.d.ts

@@ -1,13 +0,0 @@
-/**
- * Type utility which takes an object type and converts to an array of KV objects:
- * ```ts
- * // [ {key: "id", value: 123 } | {key: "foo", value: "bar" } ][]
- * type Arr = KvFrom<{ id: 123, foo: "bar" }>;
- * ```
- */
-export declare type KvFrom<T extends object> = Array<{
-    [K in keyof T]: {
-        key: K;
-        value: T[K];
-    };
-}[keyof T]>;

package/dist/types/types/kv/KvTuple.d.ts

@@ -1,14 +0,0 @@
-/**
- * **KvTuple**
- *
- * a key/value of type `T` represented as `[key, kv]`
- *
- * ```ts
- * type Obj = { foo: 1, bar: "hi" };
- * // ["foo", { foo: 1 } ]
- * type Foo = KvTuple<Obj, "foo">;
- * ```
- *
- * **Note:** _consider use of `KeyValue<T,K>` as an alternate representation_
- */
-export declare type KvTuple<T, K extends keyof T> = [K, Record<K, T[K]>];

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

@@ -1,4 +0,0 @@
-export * from "./DictFromKv";
-export * from "./KeyValue";
-export * from "./KvFrom";
-export * from "./KvTuple";

package/dist/types/types/lists/UniqueForProp.d.ts

@@ -1,14 +0,0 @@
-import { Get } from "../dictionary/Get";
-import { Narrowable } from "../Narrowable";
-/**
- * Create a union type based on a given property in an array of objects
- * ```ts
- * const data = [
- *    { id: 123, color: "blue" },
- *    { id: 456, color: "red" },
- *  ] as const;
- * // 123 | 456
- * type U = UniqueForProp<typeof data, "id">;
- * ```
- */
-export declare type UniqueForProp<T extends readonly Record<string, Narrowable>[], P extends string> = Readonly<Get<T[number], P>>;

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

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

package/dist/types/types/maybe.d.ts

@@ -1,8 +0,0 @@
-/**
- * Accepts the `true` literal or _undefined_.
- */
-export declare type MaybeTrue = true | undefined;
-/**
- * Accepts the `false` literal or _undefined_.
- */
-export declare type MaybeFalse = false | undefined;

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;