@avstantso/ts 1.1.0 → 1.2.1

package/dist/_global/structure/structure.d.ts

@@ -0,0 +1,289 @@
+declare namespace AVStantso.TS {
+    /**
+     * @summary If `T` is structure object.\
+     * Not extends special object types
+     * @example
+     * type n = CheckType<IfStructure<number>, false>;
+     * type s = CheckType<IfStructure<string>, false>;
+     * type o = CheckType<IfStructure<{}>, true>;
+     * type ob = CheckType<IfStructure<object>, true>;
+     * type a = CheckType<IfStructure<[]>, false>;
+     * type d = CheckType<IfStructure<Date>, false>;
+     * type b = CheckType<IfStructure<Buffer>, false>;
+     * type mp = CheckType<IfStructure<Map<unknown, unknown>>, false>;
+     * type st = CheckType<IfStructure<Set<unknown>>, false>;
+     * 
+     * type fb = CheckType<IfStructure<(x: number) => string>, false>;
+     * type fe = CheckType<IfStructure<((x: number) => string) & { y: 15 }>, true>;
+     */
+    type IfStructure<T, IfTrue = true, IfFalse = false> = T extends undefined ? IfFalse : T extends object ? T extends Structure.NotRules ? IfFalse : T extends TS.Func ? [keyof T] extends [never] ? IfFalse : IfTrue : IfTrue : IfFalse;
+    /**
+     * @summary Constraint: `T` is structure object.\
+     * Not extends special object types
+     * @see IfStructure
+     * @see Structure.NotRules
+     */
+    type Structure<T extends object> = IfStructure<T, T, never>;
+    namespace Structure {
+        /**
+         * @summary Not strict Structure.
+         */
+        export type Wildcard = object | AVStantso.TS.Func;
+        /**
+         * @summary Used as rules source in `IfStructure`.
+         *
+         * If extends one of values — it is not a structure
+         */
+        export interface MapOfNotRules extends AtomicObjects {
+            Array: ReadonlyArray<unknown>;
+            Map: ReadonlyMap<unknown, unknown>;
+            Set: ReadonlySet<unknown>;
+        }
+        /**
+         * @summary Used as rules `IfStructure`.
+         */
+        export type NotRules = MapOfNotRules[keyof MapOfNotRules];
+        /**
+         * @summary Transform structure `O` to keys tuple
+         * @template O Structure
+         * @see Union.ToTuple
+         * @example
+         * type n = CheckType<ToKeysArray<never>, never>;
+         * type u = CheckType<ToKeysArray<undefined>, undefined>;
+         * 
+         * type st1 = CheckType<ToKeysArray<{ a: 1, b: true }>, ['a', 'b']>;
+         * type st2 = CheckType<ToKeysArray<{ a: 1, b: true, c: () => null }>, ['a', 'b', 'c']>;
+         * type a = CheckType<ToKeysArray<[]>, never>;
+         */
+        export type ToKeysArray<O extends object> = O extends undefined ? O : IfStructure<O> extends true ? Union.ToTuple<keyof O> : never;
+        type _ToValuesArray<O extends object, Keys extends readonly (keyof O)[], R extends ArrR = []> = Keys extends readonly [infer F extends keyof O, ...infer Rest extends (keyof O)[]] ? _ToValuesArray<O, Rest, [...R, O[F]]> : R;
+        /**
+         * @summary Transform structure `O` to values tuple
+         * @template O Structure
+         * @see Union.ToTuple
+         * @example
+         * type n = CheckType<ToValuesArray<never>, never>;
+         * type u = CheckType<ToValuesArray<undefined>, undefined>;
+         * 
+         * type st1 = CheckType<ToValuesArray<{ a: 1, b: true }>, [1, true]>;
+         * type st2 = CheckType<ToValuesArray<{ a: 1, b: true, c: () => null }>, [1, true, () => null]>;
+         * type a = CheckType<ToValuesArray<[]>, never>;
+         */
+        export type ToValuesArray<O extends object> = O extends undefined ? O : IfStructure<O> extends true ? _ToValuesArray<O, Extract<Union.ToTuple<keyof O>, readonly (keyof O)[]>> : never;
+        type _ToEntriesArray<O extends object, Keys extends readonly (keyof O)[], R extends ArrR = []> = Keys extends readonly [infer F extends keyof O, ...infer Rest extends (keyof O)[]] ? _ToEntriesArray<O, Rest, [...R, [F, O[F]]]> : R;
+        /**
+         * @summary Transform structure `O` to entries tuple
+         * @template O Structure
+         * @see Union.ToTuple
+         * @example
+         * type n = CheckType<ToEntriesArray<never>, never>;
+         * type u = CheckType<ToEntriesArray<undefined>, undefined>;
+         * 
+         * type st1 = CheckType<ToEntriesArray<{ a: 1, b: true }>, [['a', 1], ['b', true]]>;
+         * type st2 = CheckType<
+         *   ToEntriesArray<{ a: 1, b: true, c: () => null }>,
+         *   [['a', 1], ['b', true], ['c', () => null]]
+         * >;
+         * type a = CheckType<ToEntriesArray<[]>, never>;
+         */
+        export type ToEntriesArray<O extends object> = O extends undefined ? O : IfStructure<O> extends true ? _ToEntriesArray<O, Extract<Union.ToTuple<keyof O>, readonly (keyof O)[]>> : never;
+        /**
+         * @summary Separate structure object `T` to `[<Plain>, <Structural>]`\
+         * ⚠ Unsafe, internal
+         * @example
+         * type nv = CheckType<_Separate<never>, [never, never]>; // ⚠
+         * type ud = CheckType<_Separate<undefined>, [undefined, undefined]>; // ⚠
+         * type n = CheckType<_Separate<number>, [number, number]>; // ⚠
+         * type s = CheckType<_Separate<string>, [string, string]>; // ⚠
+         * type a = CheckType<_Separate<[]>, [object, object]>; // ⚠All methods here
+         * type d = CheckType<_Separate<Date>, [object, object]>; // ⚠All methods here
+         * type b = CheckType<_Separate<Buffer>, [object, object]>; // ⚠All methods here
+         * type mp = CheckType<_Separate<Map<unknown, unknown>>, [object, object]>; // ⚠All methods here
+         * type st = CheckType<_Separate<Set<unknown>>, [object, object]>; // ⚠All methods here
+         * 
+         * type o = CheckType<_Separate<{}>, [{}, {}]>;
+         * type ob = CheckType<_Separate<object>, [object, object]>;
+         * 
+         * type x = CheckType<_Separate<
+         *   { a: number; b: { c: string }, d: string, e: number[] }
+         * >, [{
+         *   a: number;
+         *   d: string;
+         *   e: number[];
+         * }, {
+         *   b: {
+         *     c: string;
+         *   };
+         * }]>;
+         * 
+         * type f = CheckType<_Separate<
+         *   {
+         *     v: () => Buffer,
+         *     w: (() => string) & { n: string }
+         *   }
+         * >, [{
+         *   v: () => Buffer,
+         * }, {
+         *   w: (() => string) & { n: string }
+         * }]>;
+         */
+        export type _Separate<T, P = {
+            [K in keyof T as IfStructure<T[K], never, K>]: T[K];
+        }, S = {
+            [K in keyof T as IfStructure<T[K], K, never>]: T[K];
+        }> = [P, S];
+        /**
+         * @summary Separate structure object `T` to `[<Plain>, <Structural>]`
+         * @template T Structure object for separate
+         * @returns `[<Plain>, <Structural>]`
+         * @example
+         * type nv = CheckType<Separate<never>, never>;
+         * type ud = CheckType<Separate<undefined>, never>;
+         * type n = CheckType<Separate<number>, never>;
+         * type s = CheckType<Separate<string>, never>;
+         * type a = CheckType<Separate<[]>, never>;
+         * type d = CheckType<Separate<Date>, never>;
+         * type b = CheckType<Separate<Buffer>, never>;
+         * type mp = CheckType<Separate<Map<unknown, unknown>>, never>;
+         * type st = CheckType<Separate<Set<unknown>>, never>;
+         * 
+         * type o = CheckType<Separate<{}>, [{}, {}]>;
+         * type ob = CheckType<Separate<object>, [object, object]>;
+         * 
+         * type x = CheckType<Separate<
+         *   { a: number; b: { c: string }, d: string, e: number[] }
+         * >, [{
+         *   a: number;
+         *   d: string;
+         *   e: number[];
+         * }, {
+         *   b: {
+         *     c: string;
+         *   };
+         * }]>;
+         * 
+         * type f = CheckType<Separate<
+         *   {
+         *     v: () => Buffer,
+         *     w: (() => string) & { n: string }
+         *   }
+         * >, [{
+         *   v: () => Buffer,
+         * }, {
+         *   w: (() => string) & { n: string }
+         * }]>;
+         */
+        export type Separate<T> = T extends undefined ? never : IfStructure<T> extends true ? _Separate<T> : never;
+        /**
+         * @summary Reverse structure `object` `T` to map value-key.\
+         * Non keyable values is ignored\
+         * except `object` if defined `TProviderFiled` and it's have this key
+         * @template T Structure object for reverse
+         * @template TProviderFiled Sub key of `object` values for extract value
+         * @example
+         * type r_simple = CheckType<
+         *   Reverse<{ x: 1; y: 'ABC'; z: { a: true } }>,
+         *   {
+         *     1: 'x';
+         *     ABC: 'y';
+         *   }
+         * >;
+         * 
+         * type r_provider = CheckType<
+         *   Reverse<{ x: 1; y: 'ABC'; z: { a: 15 } }, 'a'>,
+         *   {
+         *     1: 'x';
+         *     ABC: 'y';
+         *     15: 'z';
+         *   }
+         * >;
+         */
+        export type Reverse<T extends object, TProviderFiled extends Key = undefined> = {
+            [K in keyof T as T[K] extends Key ? T[K] : T[K] extends {
+                [K0 in TProviderFiled]: unknown;
+            } ? Extract<T[K][TProviderFiled], Key> : never]: K;
+        };
+        type _Split<O extends object, Keys extends readonly (keyof O)[], R extends Arr = []> = Keys extends readonly [infer F extends keyof O, ...infer Rest extends (keyof O)[]] ? _Split<O, Rest, [
+            ...R,
+            {
+                [K in F]: O[F];
+            }
+        ]> : R;
+        /**
+         * @summary Split structural object `O` to array of objects with one field in each
+         * @template O Object to split.
+         * @returns Array of objects for each key or `never` if not structural object passed as `O`
+         * @see Union.ToTuple
+         * @example
+         * type n = CheckType<Split<never>, never>;
+         * type u = CheckType<Split<undefined>, undefined>;
+         * 
+         * type a1 = CheckType<Split<[]>, never>;
+         * type a2 = CheckType<Split<[1, 2, 3]>, never>;
+         * 
+         * type d3 = {
+         *   a: number;
+         *   b: string;
+         *   c: { x: bigint }
+         * };
+         * type r3 = [
+         *   { a: number; },
+         *   { b: string; },
+         *   { c: { x: bigint; }; }
+         * ];
+         * type s3 = CheckType<Split<d3>, r3>;
+         * 
+         * type d6 = d3 & {
+         *   d: object;
+         *   e: string[];
+         *   f: { y: undefined }
+         * };
+         * type r6 = [
+         *   ...r3,
+         *   { d: object },
+         *   { e: string[] },
+         *   { f: { y: undefined } }
+         * ];
+         * type s6 = CheckType<Split<d6>, r6>;
+         * 
+         * type d7 = d6 & {
+         *   g: Buffer;
+         * };
+         * type r7 = [
+         *   ...r6,
+         *   { g: Buffer; }
+         * ];
+         * 
+         * type s7 = CheckType<Split<d7>, r7>;
+         */
+        export type Split<O extends object> = O extends undefined ? undefined : IfStructure<O> extends true ? _Split<O, Extract<Union.ToTuple<keyof O>, readonly (keyof O)[]>> : never;
+        type _Combine<A extends readonly object[], R extends object = {}> = A extends readonly [infer F extends object, ...infer Rest extends object[]] ? _Combine<Rest, R & F> : {
+            [K in keyof R]: R[K];
+        };
+        /**
+       * @summary Combine array `A` of structural object parts
+       * @template A Array to combine
+       * @returns Structural object or `never`
+       * @example
+       * type n = CheckType<Combine<never>, never>;
+       * type u = CheckType<Combine<undefined>, undefined>;
+       * 
+       * type s = CheckType<
+       *   Combine<readonly [
+       *     { a: number },
+       *     { b: string },
+       *     { c: { x: bigint } }
+       *   ]>,
+       *   {
+       *     a: number;
+       *     b: string;
+       *     c: { x: bigint; };
+       *   }
+       * >;
+       * 
+       * type a1 = CheckType<Combine<[]>, {}>;
+       */
+        export type Combine<A extends readonly object[]> = A extends undefined ? A : A extends ArrN ? _Combine<A> : never;
+        export {};
+    }
+}

package/dist/_global/type/_register.d.ts

@@ -0,0 +1,64 @@
+declare namespace AVStantso {
+    namespace TS {
+        /**
+         * @summary Available types for value
+         */
+        type Type = Literal.Map[Literal];
+    }
+    namespace Code {
+        namespace TS {
+            namespace Type {
+                /**
+                 * @summary Create type definition array `[<key>, <type literal>, <default value>?]`
+                 */
+                type KLD = {
+                    /**
+                     * @summary Create type definition array `[<key>, <type literal>, <default value>?]`
+                     * @template K Key constraint
+                     * @template L Literal constraint
+                     * @template D Default constraint
+                     * @param key Key value
+                     * @param type Literal type value
+                     * @param def Resolved type default value
+                     */
+                    <K extends AVStantso.TS.Key, L extends AVStantso.TS.Literal, D extends AVStantso.TS.Resolve<L> = undefined>(key: K, type: L, def?: D): AVStantso.TS.Type.KLD<K, L, D>;
+                    /**
+                     * @summary Parse params like `[K, L]` or `[[K, L]]`
+                     *
+                     * `⚠ Without strict control`
+                     */
+                    Parse(params: AVStantso.TS.Arr): AVStantso.TS.Type.KLD;
+                };
+            }
+            /**
+             * @summary `AVStantso.TS.Type` utility
+             */
+            interface Type {
+                /**
+                 * @summary Create keyed type definition structure
+                 * @template K Key constraint
+                 * @template L Literal constraint
+                 * @param key Key value
+                 * @param type Literal type value
+                 */
+                KeyDef<K extends AVStantso.TS.Key, L extends AVStantso.TS.Literal>(key: K, type: L): AVStantso.TS.Type.KeyDef.Make<K, L>;
+                /**
+                 * @summary Create type definition array `[<key>, <type literal>, <default value>?]`
+                 * @template K Key constraint
+                 * @template L Literal constraint
+                 * @template D Default constraint
+                 * @param key Key value
+                 * @param type Literal type value
+                 * @param def Resolved type default value
+                 */
+                KLD: Type.KLD;
+            }
+        }
+        interface TS {
+            /**
+             * @summary `AVStantso.TS.Type` utility
+             */
+            Type: TS.Type;
+        }
+    }
+}

package/dist/_global/type/def.d.ts

@@ -0,0 +1,47 @@
+declare namespace AVStantso.TS.Type {
+    /**
+     * @summary Type definition structure
+     */
+    type Def = {
+        /**
+           * @summary Literal
+           */
+        L: Literal;
+        /**
+           * @summary Type
+           */
+        T?: unknown;
+    } | {
+        L?: Literal;
+        T: unknown;
+    };
+    namespace Def {
+        /**
+         * @summary Make type definition structure
+         */
+        type Make<T, L extends Literal = undefined> = L extends undefined ? {
+            T: T;
+        } : {
+            L: L;
+            T: T;
+        };
+        /**
+         * @summary Get type definition structure from type union or structure, and literal
+         */
+        type From<T, L extends Literal> = T extends Def ? Make<T['T'], IfDefKey<'L', Def, T> | (L extends undefined ? never : L)> : Make<T, L>;
+        namespace Or {
+            /**
+             * @summary Type definition structure or literal
+             */
+            type L = Def | Literal;
+        }
+        /**
+         * @summary Test type is `TS.Type.Def`
+         * @template TOrDef Tested `TS.Type.Def`
+         * @template IfTrue Result, if `TOrDef` is `TS.Type.TArr`
+         * @template IfFalse Result, if `TOrDef` NOT is `TS.Type.TArr`
+         * @returns `IfFalse` or `IfTrue` param
+         */
+        type Is<TOrDef, IfTrue = true, IfFalse = false> = TOrDef extends Def ? IfTrue : IfFalse;
+    }
+}

package/dist/_global/type/index.d.ts

@@ -0,0 +1,7 @@
+import './_register';
+import './key-literal-default-arr';
+import './def';
+import './key-arr-def';
+import './key-def';
+import './not';
+import './union';

package/dist/_global/type/key-arr-def.d.ts

@@ -0,0 +1,14 @@
+declare namespace AVStantso.TS.Type {
+    /**
+     * @summary Key or type definition array or keyed type definition structure
+     */
+    type KeyArrDef = Key | KLD | KeyDef;
+    namespace KeyArrDef {
+        /**
+         * @summary Constraint for `TS.Type.KeyArrDef` next type parameter
+         * @template TKeyArrDef Type def for constraint
+         * @template TIfSatisfy Type if constraint is satisfied
+         */
+        type Constraint<TKeyArrDef extends KeyArrDef, TIfSatisfy = unknown> = TKeyArrDef extends object ? never : TIfSatisfy;
+    }
+}

package/dist/_global/type/key-def.d.ts

@@ -0,0 +1,76 @@
+declare namespace AVStantso.TS.Type {
+    /**
+     * @summary Keyed type definition structure
+     */
+    type KeyDef = {
+        /**
+         * @summary Key
+         */
+        K: Key;
+    } & Def;
+    namespace KeyDef {
+        /**
+         * @summary Keyed type definition abstract structure
+         */
+        export type Abstract = {
+            K: Key;
+        } & Def;
+        type _Make<K extends Key, DL extends Def.Or.L, TforL extends Make.Constraint<DL>, Debug extends boolean, T = DL extends Def ? Extract<keyof DL, 'T'> extends never ? {} : {
+            T: DL['T'];
+        } : [TforL] extends [never] ? {} : {
+            T: TforL;
+        }, L = DL extends Def ? Extract<keyof DL, 'L'> extends never ? {} : {
+            L: DL['L'];
+        } : {
+            L: DL;
+        }, KD = {
+            K: K;
+        } & T & L, R = Debug extends true ? {
+            K: K;
+            DL: DL;
+            T: T;
+            L: L;
+            KD: KD;
+        } : {
+            [K in keyof KD]: KD[K];
+        }> = R;
+        /**
+         * @summary Make keyed type definition structure by `Key` and `Def`
+         */
+        export type Make<K extends Key, DL extends Def.Or.L, T extends Make.Constraint<DL> = never> = _Make<K, DL, T, false>;
+        export namespace Make {
+            /**
+             * @summary  Constraint for last params in kake keyed type definition structure by `Key` and `Def`
+             */
+            type Constraint<DL extends Def.Or.L> = DL extends Def ? never : unknown;
+        }
+        type _From<TKA extends Key | KLD, T extends KeyArrDef.Constraint<TKA>, Debug extends boolean, K extends Key = TKA extends KLD ? TKA[0] : TKA, P = TKA extends KLD ? TKA[1] : T, L = {} extends P ? never : Extract<Literal, P>, O = Exclude<P, Literal>, D = (L extends never ? never : {
+            L: L;
+        }) | (O extends never ? never : {
+            T: O;
+        }), R = {
+            K: K;
+        } & D> = Debug extends true ? {
+            TKeyOrArr: TKA;
+            TProperty: T;
+            K: K;
+            L: L;
+            O: O;
+            D: D;
+            R: R;
+        } : R;
+        /**
+         * @summary Get keyed type definition structure from `TS.Type.KeyArrDef` and property type `T`
+         */
+        export type From<TKAD extends KeyArrDef, T extends KeyArrDef.Constraint<TKAD> = KeyArrDef.Constraint<TKAD>> = TKAD extends KeyDef ? TKAD : _From<Exclude<TKAD, KeyDef>, T, false>;
+        /**
+         * @summary Merge keyed type definition structure with type field `T`
+         */
+        export type Merge<KD extends KeyDef, T = unknown> = Omit<KD, 'T'> & (Extract<'T', keyof KD> extends never ? {
+            T: T;
+        } : {
+            T: KD['T'] | T;
+        });
+        export {};
+    }
+}

package/dist/_global/type/key-literal-default-arr.d.ts

@@ -0,0 +1,45 @@
+declare namespace AVStantso.TS.Type {
+    /**
+     * @summary Type definition array `[<key>, <type literal>, <default value>?]`
+     * @template K Key constraint
+     * @template L Literal constraint
+     * @template D Default value
+     */
+    type KLD<K extends Key = Key, L extends Literal = Literal, D extends Resolve<L> = any> = [K, L, D?];
+    namespace KLD {
+        /**
+         * @summary Type definition map by array of definition arrays
+         */
+        export namespace Map {
+            /**
+             * @summary Type definition map item with default value
+             * @template L Literal constraint
+             * @template D Default value
+             */
+            type DefRec<L extends Literal = Literal, D extends Resolve<L> = any> = {
+                type: L;
+                def: D;
+            };
+            /**
+             * @summary Type definition map item depend on `TAllowDefaults`
+             * @template TAllowDefaults If 'true' — allow put default values into map
+             * @template L Literal constraint
+             * @template D Default value
+             */
+            type Item<TAllowDefaults extends boolean, L extends Literal = Literal, D extends Resolve<L> = any> = TAllowDefaults extends true ? DefRec<L, D> : L;
+        }
+        export type Map<TAllowDefaults extends boolean> = NodeJS.Dict<Map.Item<TAllowDefaults>>;
+        type _ToMap<TArrOfArr extends KLD[], TAllowDefaults extends boolean, R extends {} = {}, I extends number = 0> = AVStantso.TS.Array.IfEnd<TArrOfArr, I> extends true ? {
+            [K in keyof R]: R[K];
+        } : _ToMap<TArrOfArr, TAllowDefaults, R & {
+            [K in TArrOfArr[I][0]]: Map.Item<TAllowDefaults, TArrOfArr[I][1], TArrOfArr[I][2]>;
+        }, AVStantso.TS.Increment<I>>;
+        /**
+         * @summary Create type definition map by array of definition arrays
+         * @template TArrOfArr Array of definition arrays
+         * @template TAllowDefaults If 'true' — allow put default values into map
+         */
+        export type ToMap<TArrOfArr extends KLD[], TAllowDefaults extends boolean = false> = _ToMap<TArrOfArr, TAllowDefaults>;
+        export {};
+    }
+}

package/dist/_global/type/not.d.ts

@@ -0,0 +1,44 @@
+declare namespace AVStantso.TS.Type {
+    type _Not<T extends Type | Literal, Debug extends boolean, L = HasString<T, never, Extract<Literal, T>>, O = Exclude<T, Literal>, R = L | true extends true ? Exclude<Type, O> : O | true extends true ? Exclude<Literal, L> : never> = Debug extends true ? {
+        T: T;
+        L: L;
+        O: O;
+        R: R;
+    } : R;
+    /**
+     * @summary Available types for value (`Type`) xor `Literal`, exclude specified.
+     * If `T` union includes `string` — literals is ignored,
+     * else if types and literals is mixed — returns `never`
+     * @example
+     * type xor = CheckType<Not<boolean | 'boolean'>, never>;
+     * 
+     * type s = CheckType<Not<string>, number | bigint | boolean | symbol | object | Function>;
+     * 
+     * // ⚠ literals is ignored:
+     * type tslb = CheckType<
+     *   Not<string | 'boolean'>,
+     *   number | bigint | boolean | symbol | object | Function
+     * >;
+     * 
+     * type lbls = CheckType<
+     *   Not<'boolean' | 'string'>,
+     *   'number' | 'bigint' | 'symbol' | 'undefined' | 'object' | 'function' | 'Date' | 'Buffer'
+     * >;
+     */
+    export type Not<T extends Type | Literal> = _Not<T, false>;
+    export namespace Not {
+        /**
+         * @summary Available types for value, exclude `Function`
+         */
+        type Function = Exclude<Type, globalThis.Function>;
+        /**
+         * @summary Available types for value, exclude `object`
+         */
+        type Object = Exclude<Type, object>;
+        /**
+         * @summary Available types for value, exclude `string`
+         */
+        type String = Exclude<Type, string>;
+    }
+    export {};
+}

package/dist/_global/type/union.d.ts

@@ -0,0 +1,33 @@
+declare namespace AVStantso.TS.Type {
+    type _Union<TOrDef, TLiteral extends Union.Constraint<TOrDef>, Debug extends boolean, L extends Literal = TOrDef extends Def ? IfDefKey<'L', Def, TOrDef, never> : TLiteral, O = TOrDef extends Def ? IfDefKey<'T', Def, TOrDef> : TOrDef, R = HasString<O, O, O | L>> = Debug extends true ? {
+        TOrDef: TOrDef;
+        TLiteral: TLiteral;
+        L: L;
+        O: O;
+        R: R;
+    } : R;
+    /**
+     * @summary Type union `T` with `Literal`.
+     * With type `string` literals NOT supported
+     * @example
+     * type nv = CheckType<Union<never>, never>;
+     * type ud = CheckType<Union<undefined>, unknown>;
+     * 
+     * // ⛔ literals NOT supported:
+     * type ts = CheckType<Union<string | 'bigint'>, string>;
+     * 
+     * type r0 = CheckType<Union<number, 'string' | 'bigint'>, number | 'string' | 'bigint'>;
+     * 
+     * type r1 = CheckType<Union<{ T: Function; L: 'boolean' }>, 'boolean' | Function>;
+     * 
+     * type r2 = CheckType<Union<object>, object | Literal>;
+     */
+    export type Union<TOrDef, TLiteral extends Union.Constraint<TOrDef> = Union.Constraint<TOrDef>> = _Union<TOrDef, TLiteral, false>;
+    export namespace Union {
+        /**
+         * @summary Constraint for `TS.Type.Union` second type parameter
+         */
+        type Constraint<TOrDef> = Def.Is<TOrDef, never, Literal>;
+    }
+    export {};
+}