@avstantso/ts 1.0.3 → 1.1.0

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

@@ -1,289 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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 {};
-}