inferred-types 0.20.0 → 0.22.0

package/src/types/dictionary/index.ts

@@ -1,11 +1,16 @@
 // #autoindex
 // #region autoindexed files
-// index last changed at: 6th Jun, 2022, 03:36 AM ( GMT-7 )
-// hash-code: 1f3a5076
+// index last changed at: 7th Jul, 2022, 02:28 PM ( GMT-7 )
+// hash-code: 6e90bc78
 
 // file exports
+export * from "./DictPartialApplication";
+export * from "./DictPrependWithFn";
+export * from "./DictReturnValues";
 export * from "./Get";
-export * from "./NotEmptyObject";
+export * from "./RequireProps";
+export * from "./SameKeys";
+export * from "./props";
 
 // #endregion
 

package/src/types/{props.ts → dictionary/props.ts}

@@ -18,7 +18,7 @@ export type OptionalKeys<T extends object> = {
  * 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.
+ * result set.
  * ```ts
  * // "foo"
  * type Str = KeysWithValue<{ foo: "hi"; bar: 5 }>;

package/src/types/functions/FinalReturn.ts

@@ -0,0 +1,12 @@
+/**
+ * A type utility which looks at a chain for functions and reduces the type
+ * to the final `ReturnType` of the chain.
+ * 
+ * ```ts
+ * // number
+ * type T = FinalReturn<() => (foo: string) => (bar: string) => () => number>;
+ * ```
+ */
+export type FinalReturn<T extends any> = T extends (...args: any[]) => any
+  ? FinalReturn<ReturnType<T>>
+  : T;

package/{on-hold/types → src/types/functions}/index.ts

@@ -1,9 +1,10 @@
 // #autoindex
 // #region autoindexed files
-// index last changed at: 1st Jan, 2022, 03:27 PM ( GMT-8 )
-// hash-code: da242834
-
+// index last changed at: 6th Jun, 2022, 10:19 AM ( GMT-7 )
+// hash-code: 7fa9afdf
 
+// file exports
+export * from "./FinalReturn";
 
 // #endregion
 

package/src/types/index.ts

@@ -1,7 +1,7 @@
 // #autoindex
 // #region autoindexed files
-// index last changed at: 1st Jan, 2022, 03:27 PM ( GMT-8 )
-// hash-code: 7e6e29a0
+// index last changed at: 7th Jul, 2022, 01:15 PM ( GMT-7 )
+// hash-code: f976e182
 
 // file exports
 export * from "./Api";
@@ -22,12 +22,12 @@ export * from "./Not";
 export * from "./Numeric";
 export * from "./Opaque";
 export * from "./Retain";
+export * from "./SimplifyObject";
 export * from "./Transformer";
 export * from "./TypeGuard";
 export * from "./Where";
 export * from "./append-types";
 export * from "./maybe";
-export * from "./props";
 export * from "./ruleset-types";
 export * from "./runtime";
 export * from "./type-testing";
@@ -35,6 +35,7 @@ export * from "./type-testing";
 export * from "./alphabetic/index";
 export * from "./dictionary/index";
 export * from "./fluent/index";
+export * from "./functions/index";
 export * from "./kv/index";
 export * from "./lists/index";
 export * from "./string-literals/index";

package/src/types/ruleset-types.ts

@@ -1,6 +1,6 @@
-import type { TypeCondition } from "~/utility/runtime/ifTypeOf";
-import { OptionalKeys } from "./props";
-import { SameKeys } from "./type-conversion/SameKeys";
+import { TypeCondition } from "src/utility/runtime";
+import { OptionalKeys } from "./dictionary/props";
+import { SameKeys } from "./dictionary/SameKeys";
 
 /**
  * **RuleDefinition**

package/src/types/runtime.ts

@@ -1,7 +1,7 @@
-import { TypeGuard } from "~/types";
-
 // runtime types relate to the types coming out of the runtime utilities
 
+import { TypeGuard } from "./TypeGuard";
+
 export type RuntimeType<T> = {
   __kind: "type";
 
@@ -14,21 +14,21 @@ export type RuntimeProp<P extends Readonly<PropertyKey>, T extends RuntimeType<a
   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);
- * ```
- */
+   * 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"]>>;
 };
@@ -36,4 +36,4 @@ export type RuntimeProp<P extends Readonly<PropertyKey>, T extends RuntimeType<a
 export 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;
+} & T;

package/src/types/string-literals/LeftWhitespace.ts

@@ -1,4 +1,5 @@
-import type { Replace, TrimLeft } from "~/types";
+import { Replace } from "./Replace";
+import { TrimLeft } from "./TrimLeft";
 
 /**
  * Provides the _left_ whitespace of a string
@@ -7,4 +8,6 @@ import type { Replace, TrimLeft } from "~/types";
  * type T = LeftWhitespace<"\n\t foobar">;
  * ```
  */
-export type LeftWhitespace<S extends string> = string extends S ? string : Replace<S, TrimLeft<S>, "">;
+export type LeftWhitespace<S extends string> = string extends S
+  ? string
+  : Replace<S, TrimLeft<S>, "">;

package/src/types/string-literals/RightWhitespace.ts

@@ -1,4 +1,5 @@
-import type { Replace, TrimRight } from "~/types";
+import { Replace } from "./Replace";
+import { TrimRight } from "./TrimRight";
 
 /**
  * Provides the _left_ whitespace of a string
@@ -7,4 +8,6 @@ import type { Replace, TrimRight } from "~/types";
  * type T = LeftWhitespace<"\n\t foobar">;
  * ```
  */
-export type RightWhitespace<S extends string> = string extends S ? string : Replace<S, TrimRight<S>, "">;
+export type RightWhitespace<S extends string> = string extends S
+  ? string
+  : Replace<S, TrimRight<S>, "">;

package/src/types/tuples/FirstKey.ts

@@ -1,10 +1,10 @@
-import type { Keys, UnionToTuple } from "~/types";
+import { Keys } from "../Keys";
+import { UnionToTuple } from "../type-conversion/UnionToTuple";
 
 /**
  * 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 type FirstKey<T extends object> = UnionToTuple<Keys<T>>[0];
-

package/src/types/tuples/FromDictArray.ts

@@ -1,5 +1,5 @@
-import { ExpandRecursively, UnionToIntersection } from "~/types";
-
+import { ExpandRecursively } from "../ExpandRecursively";
+import { UnionToIntersection } from "../type-conversion";
 
 /**
  * Typescript utility which receives `T` as shape which resembles `DictArray<D>`
@@ -9,5 +9,6 @@ import { ExpandRecursively, UnionToIntersection } from "~/types";
  * type Dict = FromDictArray<[["foo", { foo: 1 }], ["bar", { bar: "hi" }]]>;
  * ```
  */
-export type FromDictArray<T extends [string, Record<string, unknown>][]> =
-  ExpandRecursively<UnionToIntersection<T[number][1]>>;
+export type FromDictArray<T extends [string, Record<string, unknown>][]> = ExpandRecursively<
+  UnionToIntersection<T[number][1]>
+>;

package/src/types/type-conversion/index.ts

@@ -1,16 +1,13 @@
 // #autoindex
 
 // #region autoindexed files
-// index last changed at: 6th Jun, 2022, 03:36 AM ( GMT-7 )
-// hash-code: ac142b94
+// index last changed at: 6th Jun, 2022, 10:18 AM ( GMT-7 )
+// hash-code: b346a5f3
 
 // file exports
-export * from "./SameKeys";
 export * from "./TupleToUnion";
 export * from "./UnionToIntersection";
 export * from "./UnionToTuple";
-export * from "./UnwrapValue";
-export * from "./WrapValue";
 
 // #endregion
 

package/src/utility/api/api.ts

@@ -1,9 +1,10 @@
-import { Narrowable } from "~/types";
+import { Narrowable } from "src/types/Narrowable";
 
-export const api = <N extends Narrowable, TPrivate extends Readonly<Record<any, N>>>(priv: TPrivate) => <TPublic extends object>(pub: TPublic) => {
-  const surface = () => pub as TPublic;
-  surface.prototype.priv = () => priv as TPrivate;
-
-  return surface;
-};
+export const api =
+  <N extends Narrowable, TPrivate extends Readonly<Record<any, N>>>(priv: TPrivate) =>
+  <TPublic extends object>(pub: TPublic) => {
+    const surface = () => pub as TPublic;
+    surface.prototype.priv = () => priv as TPrivate;
 
+    return surface;
+  };

package/src/utility/dictionary/dictionaryTransform.ts

@@ -1,6 +1,8 @@
 /* eslint-disable no-use-before-define */
-import { keys } from "~/utility/keys";
-import { SameKeys, Transformer } from "~/types";
+
+import { SameKeys } from "src/types/dictionary";
+import { Transformer } from "src/types/Transformer";
+import { keys } from "../keys";
 
 /**
  * Takes a dictionary of type `I` and converts it to a dictionary of type `O` where
@@ -13,9 +15,8 @@ export function dictionaryTransform<I extends object, O extends SameKeys<I>>(
   input: I,
   transform: Transformer<I, O>
 ) {
-
   return keys(input).reduce((acc, i) => {
     const key = i as string & keyof I;
-    return {...acc, [key]: transform(input, key)};
+    return { ...acc, [key]: transform(input, key) };
   }, {} as O);
 }

package/src/utility/dictionary/entries.ts

@@ -1,10 +1,11 @@
-import { KeyValue, Narrowable } from "~/types";
+import { KeyValue } from "src/types/kv";
+import { Narrowable } from "src/types/Narrowable";
 import { keys } from "../keys";
 
 /**
  * **entries**
  *
- * Provides an _interable_ over the passed in dictionary object where each iteration 
+ * Provides an _iterable_ over the passed in dictionary object where each iteration
  * provides a tuple of `[ key, value ]` which preserve type literals.
  *
  * For example:
@@ -14,8 +15,11 @@ import { keys } from "../keys";
  * for (const [k, v] of entries(obj)) { ... }
  * ```
  */
-export function entries<N extends Narrowable, T extends Record<string, N>, I extends KeyValue<T, keyof T>>(obj: T) {
-
+export function entries<
+  N extends Narrowable,
+  T extends Record<string, N>,
+  I extends KeyValue<T, keyof T>
+>(obj: T) {
   const iterable = {
     *[Symbol.iterator]() {
       for (const k of keys(obj)) {
@@ -26,4 +30,4 @@ export function entries<N extends Narrowable, T extends Record<string, N>, I ext
   };
 
   return iterable;
-}
+}

package/src/utility/dictionary/index.ts

@@ -1,7 +1,7 @@
 // #autoindex
 // #region autoindexed files
-// index last changed at: 1st Jan, 2022, 03:27 PM ( GMT-8 )
-// hash-code: c3587066
+// index last changed at: 7th Jul, 2022, 01:47 PM ( GMT-7 )
+// hash-code: dd2bf50a
 
 // file exports
 export * from "./arrayToKeyLookup";
@@ -9,7 +9,6 @@ export * from "./dictionaryTransform";
 export * from "./entries";
 export * from "./mapValues";
 export * from "./strArrayToDict";
-export * from "./valuesOfProp";
 // directory exports
 export * from "./kv/index";
 

package/src/utility/dictionary/kv/dictToKv.ts

@@ -1,6 +1,8 @@
-import { Mutable, Narrowable, UnionToTuple } from "~/types";
-import { KvFrom } from "~/types/kv/KvFrom";
-import { keys } from "~/utility/keys";
+import { KvFrom } from "src/types/kv";
+import { Mutable } from "src/types/Mutable";
+import { Narrowable } from "src/types/Narrowable";
+import { UnionToTuple } from "src/types/type-conversion";
+import { keys } from "src/utility/keys";
 
 /**
  * Converts a dictionary object into an array of dictionaries with `key` and `value` properties

package/src/utility/dictionary/kv/filterDictArray.ts

@@ -1,5 +1,5 @@
-import type { DictArray, DictArrayFilterCallback } from "~/types";
-import { Configurator, IConfigurator } from "~/utility/state";
+import { DictArray, DictArrayFilterCallback } from "src/types/tuples";
+import { Configurator, IConfigurator } from "src/utility/state";
 
 export interface Array<T> {
   filter<U extends T>(pred: (a: T) => a is U): U[];
@@ -11,12 +11,11 @@ export interface Array<T> {
  */
 export function filterDictArray<
   T extends object,
-  C extends DictArrayFilterCallback<keyof T, T, true | false>,
-  >(dictArr: DictArray<T>, cb: C) {
-
+  C extends DictArrayFilterCallback<keyof T, T, true | false>
+>(dictArr: DictArray<T>, cb: C) {
   const state: IConfigurator = Configurator();
 
-  const updated = dictArr.filter(i => {
+  const updated = dictArr.filter((i) => {
     const [k, v] = i;
     const keep = cb(k, v);
     if (!keep) {
@@ -30,4 +29,3 @@ export function filterDictArray<
   type ExcludedKeys = "";
   return updated as unknown as DictArray<Omit<T, ExcludedKeys>>;
 }
-

package/src/utility/dictionary/kv/kv.ts

@@ -1,13 +1,18 @@
-import { ExpandRecursively, Narrowable } from "~/types";
+import { ExpandRecursively } from "src/types/ExpandRecursively";
+import { Narrowable } from "src/types/Narrowable";
 
 /**
  * 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
+ * > to a narrower type then both inferences will break and you should
  * > instead use `KV2` to get this capability.
  */
-export function kv<K extends string, N extends Narrowable, V extends Record<any, N> | boolean | number | string | null | undefined>(key: K, value: V) {
+export function kv<
+  K extends string,
+  N extends Narrowable,
+  V extends Record<any, N> | boolean | number | string | null | undefined
+>(key: K, value: V) {
   return { [key]: value } as ExpandRecursively<Record<K, V>>;
 }

package/src/utility/dictionary/kv/kvToDict.ts

@@ -1,5 +1,6 @@
-import { Mutable, Narrowable } from "~/types";
-import { DictFromKv } from "~/types/kv";
+import { DictFromKv } from "src/types/kv";
+import { Mutable } from "src/types/Mutable";
+import { Narrowable } from "src/types/Narrowable";
 
 /**
  * Converts an array of dictionaries with `key` and `value` properties to a singular dictionary.

package/src/utility/dictionary/mapValues.ts

@@ -1,20 +1,23 @@
-import { Narrowable } from "~/types";
+import { Narrowable } from "src/types/Narrowable";
 import { entries } from "./entries";
 
 /**
  * **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 function mapValues<N extends Narrowable, T extends Record<string, N>, V>(obj: T, valueMapper: (k: T[keyof T]) => V) {
+export function mapValues<N extends Narrowable, T extends Record<string, N>, V>(
+  obj: T,
+  valueMapper: (k: T[keyof T]) => V
+) {
   return Object.fromEntries(
     // TODO: fix the type error with v and valueMapper
     [...entries(obj)].map(([k, v]) => [k, valueMapper(v as any)])
   ) as { [K in keyof T]: V };
-}
+}

package/src/utility/dictionary/strArrayToDict.ts

@@ -1,5 +1,4 @@
-import { ExpandRecursively } from "~/types/ExpandRecursively";
-
+import { ExpandRecursively } from "src/types/ExpandRecursively";
 
 /**
  * converts an array of strings `["a", "b", "c"]` into a more type friendly

package/src/utility/keys.ts

@@ -1,12 +1,16 @@
-import { Keys, Length } from "~/types";
+import { Keys } from "src/types/Keys";
+import { Length } from "src/types/Length";
 
 /**
  * Provides the _keys_ of an object with the `keyof T` made explicit.
  */
 export function keys<T extends {}, W extends readonly string[]>(obj: T, ...without: W) {
-  const v = without.length > 0
-    ? Object.keys(obj).filter(k => !without.includes(k)) as unknown as Array<Exclude<keyof T, Keys<W>>>
-    : Object.keys(obj) as unknown as Array<keyof T>;
+  const v =
+    without.length > 0
+      ? (Object.keys(obj).filter((k) => !without.includes(k)) as unknown as Array<
+          Exclude<keyof T, Keys<W>>
+        >)
+      : (Object.keys(obj) as unknown as Array<keyof T>);
 
   return v as unknown as Length<W> extends 0 ? Array<keyof T> : Array<Exclude<keyof T, Keys<W>>>;
 }

package/src/utility/lists/groupBy.ts

@@ -1,5 +1,4 @@
-import { Narrowable } from "~/types";
-// import { UniqueForProp } from "~/types/lists/UniqueForProp";
+import { Narrowable } from "src/types/Narrowable";
 
 /**
  * Groups an array of data based on the value of a property
@@ -11,12 +10,6 @@ import { Narrowable } from "~/types";
  *
  * @ignore not implemented
  */
-export function groupBy<T extends Record<string, Narrowable>, K extends keyof T & string>(
-  _data: Readonly<T[]>
-) {
+export function groupBy<T extends Record<string, Narrowable>>(_data: Readonly<T[]>) {
   throw new Error("not implemented");
-  return (_groupBy: K) => {
-    // type _GroupedBy = UniqueForProp<typeof data, K>;
-    // const _output = {} as Record<GroupedBy, Narrowable>;
-  };
 }

package/src/utility/literals/arrayToObject.ts

@@ -1,22 +1,28 @@
-import { Narrowable } from "~/types/Narrowable";
-
+import { Narrowable } from "src/types/Narrowable";
 
 /**
  * **UniqueDictionary**
- * 
+ *
  * A dictionary converted by `arrayToObject()` which expects each key `S` to have a only a
  * single/unique value.
  */
-export type UniqueDictionary<S extends PropertyKey, N extends Narrowable, T extends Record<keyof T, N> & Record<S, any>> = { [V in T as V[S]]: V };
+export type UniqueDictionary<
+  S extends PropertyKey,
+  N extends Narrowable,
+  T extends Record<keyof T, N> & Record<S, any>
+> = { [V in T as V[S]]: V };
 
 /**
  * **GeneralDictionary**
- * 
+ *
  * A dictionary converted by `arrayToObject()` which expects each key `S` to have an
  * array of values.
  */
-export type GeneralDictionary<S extends PropertyKey, N extends Narrowable, T extends Record<keyof T, N> & Record<S, any>> = { [V in T as V[S]]: V[] };
-
+export type GeneralDictionary<
+  S extends PropertyKey,
+  N extends Narrowable,
+  T extends Record<keyof T, N> & Record<S, any>
+> = { [V in T as V[S]]: V[] };
 
 export type ArrayConverter<S extends PropertyKey, U extends boolean> =
   /**
@@ -28,45 +34,40 @@ export type ArrayConverter<S extends PropertyKey, U extends boolean> =
     arr: readonly T[]
   ) => true extends U ? UniqueDictionary<S, N, T> : GeneralDictionary<S, N, T>;
 
-
 /**
  * Converts an array of objects into a dictionary by picking a property name contained
  * by all objects and using that as the key to the dictionary.
- * 
+ *
  * ```ts
- * const arr = [ 
+ * const arr = [
  *   { kind: "color", favorite: "blue", likes: 100 },
  *   { kind: "song", favorite: "some song", likes: 25 }
  * ];
  * const dict = arrayToObject("kind")(arr);
  * ```
- * 
+ *
  * This will produce a dictionary with keys of `color` and `song`.
  */
-export function arrayToObject<
-  S extends PropertyKey,
-  U extends boolean
->(prop: S, unique?: U) {
+export function arrayToObject<S extends PropertyKey, U extends boolean>(prop: S, unique?: U) {
   type X = true extends U ? true : false;
   /**
    * **arrayToObject** - partially applied
-   * 
+   *
    * pass in an array of objects to complete application of arrayToObject()
    */
-  const transform: ArrayConverter<S, X> = <N extends Narrowable, T extends Record<keyof T, N> & Record<S, any>>(
+  const transform: ArrayConverter<S, X> = <
+    N extends Narrowable,
+    T extends Record<keyof T, N> & Record<S, any>
+  >(
     arr: readonly T[]
   ): true extends X ? UniqueDictionary<S, N, T> : GeneralDictionary<S, N, T> => {
-
-    const result = unique !== false
-      ? arr.reduce(
-        (acc, v) => ({ ...acc, [v[prop]]: v }), {} as UniqueDictionary<S, N, T>
-      )
-      : arr.reduce(
-        (acc, v) => {
-          const existing = acc[v[prop] as T[S]] || [];
-          return { ...acc, [v[prop]]: [...existing, v] };
-        }, {} as GeneralDictionary<S, N, T>
-      );
+    const result =
+      unique !== false
+        ? arr.reduce((acc, v) => ({ ...acc, [v[prop]]: v }), {} as UniqueDictionary<S, N, T>)
+        : arr.reduce((acc, v) => {
+            const existing = acc[v[prop] as T[S]] || [];
+            return { ...acc, [v[prop]]: [...existing, v] };
+          }, {} as GeneralDictionary<S, N, T>);
 
     // type cast based on `U`
     return result as true extends X ? UniqueDictionary<S, N, T> : GeneralDictionary<S, N, T>;
@@ -75,4 +76,3 @@ export function arrayToObject<
   return transform;
   // return converter(prop, unique);
 }
-

package/src/utility/literals/defineType.ts

@@ -1,15 +1,15 @@
-import { ExpandRecursively, Narrowable } from "~/types";
+import { ExpandRecursively } from "src/types/ExpandRecursively";
+import { Narrowable } from "src/types/Narrowable";
 
 /**
  * Build a _type_ from two run-time dictionaries.
- * 
+ *
  * 1. The _first_ -- which is optional -- is interpreted as a _literal_ type definition
  * 2. The _second_ dictionary is interpreted as a "wide" definition of prop types
  */
-export function defineType<
-  N extends Narrowable,
-  TLiteral extends Record<string, N>
->(literal: TLiteral = {} as TLiteral) {
+export function defineType<N extends Narrowable, TLiteral extends Record<string, N>>(
+  literal: TLiteral = {} as TLiteral
+) {
   /**
    * Add any key/value pairs which you want to have _wide_ types associated;
    * literal types are defined already and stated above.

package/src/utility/literals/identity.ts

@@ -1,4 +1,5 @@
-import { Narrowable } from "~/types/Narrowable";
+import { Narrowable } from "src/types/Narrowable";
+
 /**
  * An identity function for any type, with the goal of preserving literal type information
  * whereever possible.
@@ -6,4 +7,6 @@ import { Narrowable } from "~/types/Narrowable";
 export const identity = <
   N extends Narrowable,
   T extends Record<any, N> | number | string | boolean | symbol | undefined | null
->(v: T) => v;
+>(
+  v: T
+) => v;

package/src/utility/literals/literal.ts

@@ -1,6 +1,6 @@
 /* eslint-disable no-use-before-define */
 
-import { Narrowable } from "~/types";
+import { Narrowable } from "src/types/Narrowable";
 
 /**
  * Takes an object as input --which has an `id` property and returns it as the same
@@ -39,8 +39,8 @@ export function idTypeGuard<T extends { id: I }, I extends PropertyKey>(
 /**
  * Takes an object as input and infers the narrow literal types of the property
  * values on the object.
- * 
- * > Note: this addresses this [a known TS gap](https://github.com/microsoft/TypeScript/issues/30680). 
+ *
+ * > Note: this addresses this [a known TS gap](https://github.com/microsoft/TypeScript/issues/30680).
  * > Hopefully at some point this will be addressed in the language.
  */
 export function literal<N extends Narrowable, T extends Record<keyof T, N>>(obj: T) {