@avstantso/utils-names-tree 1.2.1 → 1.3.2

package/dist/_global/_register.d.ts

@@ -1,10 +1,115 @@
 declare namespace AVStantso {
+    const symbolRootAlias: unique symbol;
     const BaseKinds: {
         name: Kinds.Method;
+        backslash: Kinds.Method;
+        slash: Kinds.Method;
+        dot: Kinds.Method;
+        amp: Kinds.Method;
+        hash: Kinds.Method;
+        colon: Kinds.Method;
+        arrow: Kinds.Method;
+        dash: Kinds.Method;
+        underscore: Kinds.Method;
+        doubleColon: Kinds.Method;
+        comma: Kinds.Method;
+        semicolon: Kinds.Method;
+        space: Kinds.Method;
+        pipe: Kinds.Method;
         path: Kinds.Method;
         url: Kinds.Method;
+        query: Kinds.Method;
         i18n: Kinds.Method;
         domain: Kinds.Method;
+        longArg: Kinds.Method;
+        shortArg: Kinds.Method;
+        envVar: Kinds.Method;
+        cssClass: Kinds.Method;
+        cssId: Kinds.Method;
+        anchor: Kinds.Method;
+        scoped: Kinds.Method;
+        param: Kinds.Method;
+        arg: Kinds.Method;
+        params: Kinds.Method;
+        args: Kinds.Method;
+        snake: Kinds.Method;
+        namespace: Kinds.Method;
+        csv: Kinds.Method;
+        title: Kinds.Method;
+    };
+    const BaseKindsMeta: {
+        readonly name: never;
+        readonly backslash: "\\";
+        readonly slash: "/";
+        readonly dot: ".";
+        readonly amp: "&";
+        readonly hash: "#";
+        readonly colon: ":";
+        readonly arrow: "->";
+        readonly dash: "-";
+        readonly underscore: "_";
+        readonly doubleColon: "::";
+        readonly comma: ",";
+        readonly semicolon: ";";
+        readonly space: " ";
+        readonly pipe: "|";
+        readonly path: "/";
+        readonly url: {
+            readonly prefix: "/";
+            readonly separator: "/";
+        };
+        readonly query: {
+            readonly prefix: "?";
+            readonly separator: "&";
+        };
+        readonly i18n: ".";
+        readonly domain: ".";
+        readonly longArg: {
+            readonly prefix: "--";
+            readonly separator: "-";
+        };
+        readonly shortArg: {
+            readonly beforeEach: "-";
+        };
+        readonly envVar: {
+            readonly separator: "_";
+            readonly up: true;
+        };
+        readonly cssClass: {
+            readonly prefix: ".";
+            readonly separator: "-";
+        };
+        readonly cssId: {
+            readonly prefix: "#";
+            readonly separator: "-";
+        };
+        readonly anchor: {
+            readonly beforeEach: "#";
+        };
+        readonly scoped: {
+            readonly prefix: "@";
+            readonly separator: "/";
+        };
+        readonly param: {
+            readonly beforeEach: ":";
+        };
+        readonly arg: {
+            readonly beforeEach: "{";
+            readonly afterEach: "}";
+        };
+        readonly params: {
+            readonly beforeEach: ":";
+            readonly separator: "/";
+        };
+        readonly args: {
+            readonly beforeEach: "{";
+            readonly afterEach: "}";
+            readonly separator: "/";
+        };
+        readonly snake: "_";
+        readonly namespace: "::";
+        readonly csv: ",";
+        readonly title: " ";
     };
     export namespace NamesTree {
         export namespace Kinds {
@@ -21,18 +126,116 @@ declare namespace AVStantso {
          * @summary Allow tree kind
          */
         export type Kind = Kinds.All[number];
+        export type KindMeta = {
+            prefix?: string;
+            separator?: string;
+            beforeEach?: string;
+            afterEach?: string;
+            up?: boolean;
+        };
+        type BaseKindsMeta = typeof BaseKindsMeta;
+        export interface KindsMeta extends BaseKindsMeta {
+        }
+        namespace _ResolveKind {
+            type RR<M extends KindMeta, MK extends keyof KindMeta> = M[MK] extends string ? M[MK] : '';
+            export type Step<M extends KindMeta, K extends TS.Key, F extends boolean> = TS.Array.Join<[
+                RR<M, F extends true ? 'prefix' : 'separator'>,
+                RR<M, 'beforeEach'>,
+                TS.String<K>,
+                RR<M, 'afterEach'>
+            ]> extends infer S extends string ? M['up'] extends true ? Uppercase<S> : S : never;
+            export {};
+        }
+        type _ResolveKind<M extends KindMeta, P extends TS.Keys, F extends boolean, R extends string = ''> = P extends readonly [infer C extends TS.Key, ...infer Rest extends TS.Keys] ? _ResolveKind<M, Rest, false, `${R}${_ResolveKind.Step<M, C, F>}`> : R;
+        /**
+         * Resolve kind step
+         * @template KD Kind to resolve
+         * @template P Path stack. E.g. for `a/b/c` must be `['c', 'b', 'a']`
+         * @example
+         * // Stack expected
+         * type P0 = ['node0'];
+         * type P1 = ['node1', 'node0'];
+         * type P2 = ['node2', 'node1', 'node0'];
+         * 
+         * type name0 = CheckType<ResolveKind<'name', P0>, 'node0'>;
+         * type name1 = CheckType<ResolveKind<'name', P1>, 'node1'>;
+         * type name2 = CheckType<ResolveKind<'name', P2>, 'node2'>;
+         * 
+         * type path0 = CheckType<ResolveKind<'path', P0>, 'node0'>;
+         * type path1 = CheckType<ResolveKind<'path', P1>, 'node0/node1'>;
+         * type path2 = CheckType<ResolveKind<'path', P2>, 'node0/node1/node2'>;
+         * 
+         * type url0 = CheckType<ResolveKind<'url', P0>, '/node0'>;
+         * type url1 = CheckType<ResolveKind<'url', P1>, '/node0/node1'>;
+         * type url2 = CheckType<ResolveKind<'url', P2>, '/node0/node1/node2'>;
+         * 
+         * type dot0 = CheckType<ResolveKind<'dot', P0>, 'node0'>;
+         * type dot1 = CheckType<ResolveKind<'dot', P1>, 'node0.node1'>;
+         * type dot2 = CheckType<ResolveKind<'dot', P2>, 'node0.node1.node2'>;
+         * 
+         * type param0 = CheckType<ResolveKind<'params', P0>, ':node0'>;
+         * 
+         * type params0 = CheckType<ResolveKind<'params', P0>, ':node0'>;
+         * type params1 = CheckType<ResolveKind<'params', P1>, ':node0/:node1'>;
+         * type params2 = CheckType<ResolveKind<'params', P2>, ':node0/:node1/:node2'>;
+         * 
+         * type arg0 = CheckType<ResolveKind<'arg', P0>, '{node0}'>;
+         * 
+         * type args0 = CheckType<ResolveKind<'args', P0>, '{node0}'>;
+         * type args1 = CheckType<ResolveKind<'args', P1>, '{node0}/{node1}'>;
+         * type args2 = CheckType<ResolveKind<'args', P2>, '{node0}/{node1}/{node2}'>;
+         * 
+         * type envVar0 = CheckType<ResolveKind<'envVar', P0>, 'NODE0'>;
+         * type envVar1 = CheckType<ResolveKind<'envVar', P1>, 'NODE0_NODE1'>;
+         * type envVar2 = CheckType<ResolveKind<'envVar', P2>, 'NODE0_NODE1_NODE2'>;
+         * 
+         * type query0 = CheckType<ResolveKind<'query', ['a']>, '?a'>;
+         * type query1 = CheckType<ResolveKind<'query', ['b', 'a']>, '?a&b'>;
+         * type query2 = CheckType<ResolveKind<'query', ['c', 'b', 'a']>, '?a&b&c'>;
+         * 
+         * type longArg0 = CheckType<ResolveKind<'longArg', ['dry']>, '--dry'>;
+         * type longArg1 = CheckType<ResolveKind<'longArg', ['run', 'dry']>, '--dry-run'>;
+         * 
+         * type shortArg0 = CheckType<ResolveKind<'shortArg', ['v']>, '-v'>;
+         * type shortArg1 = CheckType<ResolveKind<'shortArg', ['f', 'v']>, '-v-f'>;
+         * 
+         * type cssClass0 = CheckType<ResolveKind<'cssClass', ['btn']>, '.btn'>;
+         * type cssClass1 = CheckType<ResolveKind<'cssClass', ['primary', 'btn']>, '.btn-primary'>;
+         * 
+         * type cssId0 = CheckType<ResolveKind<'cssId', ['main']>, '#main'>;
+         * type cssId1 = CheckType<ResolveKind<'cssId', ['content', 'main']>, '#main-content'>;
+         * 
+         * type anchor0 = CheckType<ResolveKind<'anchor', ['section']>, '#section'>;
+         * type anchor1 = CheckType<ResolveKind<'anchor', ['intro', 'section']>, '#section#intro'>;
+         * 
+         * type scoped0 = CheckType<ResolveKind<'scoped', ['org']>, '@org'>;
+         * type scoped1 = CheckType<ResolveKind<'scoped', ['pkg', 'org']>, '@org/pkg'>;
+         * 
+         * type param0_ = CheckType<ResolveKind<'param', ['id']>, ':id'>;
+         * type param1_ = CheckType<ResolveKind<'param', ['sub', 'id']>, ':id:sub'>;
+         * 
+         * type prefixed = CheckType<ResolveKind<'dash', ['id', 'user'], { prefix: '$' }>, '$user-id'>;
+         */
+        export type ResolveKind<KD extends Kind, P extends TS.Keys, O extends Options = Options> = ([KindsMeta[KD]] extends [never] ? TS.String<P[0]> : (KindsMeta[KD] extends string ? {
+            separator: KindsMeta[KD];
+        } : KindsMeta[KD]) extends infer M extends KindMeta ? _ResolveKind<M, TS.Array.Reverse<P>, true> : string) extends infer R extends string ? O extends {
+            prefix: string;
+        } ? `${O['prefix']}${R}` : R : never;
         /**
          * @summary Tree node data source
          */
-        export type Source = Source.Root | string;
+        export type Source = TS.Type.Builtin;
         export namespace Source {
             /**
              * @summary Tree root node data source
              */
             type Root = object | Function;
         }
-        type _NodeKinds<KDs extends readonly Kind[], R = unknown> = KDs extends readonly [infer C extends Kind, ...infer Rest extends readonly Kind[]] ? _NodeKinds<Rest, R & {
-            [K in `_${C}`]: string;
+        export type _NodeKinds<O extends Options, KDs extends readonly Kind[], P extends TS.Keys, R = unknown> = KDs extends readonly [
+            infer C extends Kind,
+            ...infer Rest extends readonly Kind[]
+        ] ? _NodeKinds<O, Rest, P, R & {
+            [K in `_${C}`]: ResolveKind<C, P>;
         }> : {
             [K in keyof R]: R[K];
         };
@@ -41,22 +244,49 @@ declare namespace AVStantso {
          *
          * If `S = true`, allows tails nodes as string
          */
-        export type Node<T extends Source = Source, KDs extends readonly Kind[] = Kinds.All, S extends boolean = false> = (S extends true ? unknown : _NodeKinds<KDs>) & Node.Data<T, KDs, S>;
+        export type Node<T extends Source = Source, O extends Options = Options, KDs extends readonly Kind[] = Kinds.All, S extends boolean = false, P extends TS.Keys = []> = (S extends true ? unknown : _NodeKinds<O, KDs, P>) & Node.Data<T, O, KDs, S, P>;
         export namespace Node {
+            type _Constraint<KDs extends readonly Kind[], R = unknown> = KDs extends readonly [
+                infer C extends Kind,
+                ...infer Rest extends readonly Kind[]
+            ] ? _Constraint<Rest, R & {
+                [K in `_${C}`]: string;
+            }> : R;
             /**
-             * @summary Tree node data part for source `T` with allow kinds `KDs`
-             *
-             * If `S = true`, allows tails nodes as string
+             * @summary Node constraint
              */
-            type Data<T extends Source = Source, KDs extends readonly Kind[] = Kinds.All, S extends boolean = false> = T extends Source.Root ? (T extends Function ? T : unknown) & {
-                [K in keyof T]: Node<Extract<T[K], Source>, KDs, S>;
-            } : S extends true ? T : unknown;
+            export type Constraint<KDs extends readonly Kind[] = Kinds.All> = _Constraint<KDs> extends infer R ? {
+                [K in keyof R]: R[K];
+            } : never;
+            /**
+             * @summary Node data part
+             */
+            export type Data<T extends Source = Source, O extends Options = Options, KDs extends readonly Kind[] = Kinds.All, S extends boolean = false, P extends TS.Keys = []> = T extends Source.Root ? (T extends Function ? T : unknown) & {
+                [K in keyof T]: Node<Extract<T[K], Source>, O, KDs, S, [
+                    TS.String<K, '?'>,
+                    ...P
+                ]>;
+            } : S extends true ? NamesTree.ResolveKind<KDs[0], P, O> : unknown;
+            export {};
         }
         /**
          * @summary Tree options
          */
         export interface Options {
+            /**
+             * @summary Additional prefix for all `Kinds` methods
+             */
             prefix?: string;
+            /**
+             * @summary Alias for root of tree as additional property.\
+             * E.g. `Home` for urls
+             */
+            rootAlias?: string;
+            /**
+             * @summary If picked and represents in internal array — will be used on `ToString` for nodes.\
+             * Else will be used first kind from tree.
+             */
+            defaultKind?: Kind;
         }
         /**
          * @summary `NamesTree` kinds presets
@@ -70,18 +300,22 @@ declare namespace AVStantso {
                  * @summary `Names` preset kinds
                  */
                 type Kinds = ['name'];
+                /**
+                 * @summary `Names` preset node constraint
+                 */
+                type Constraint = NamesTree.Node.Constraint<Kinds>;
                 /**
                  * @summary `Names` preset tree node for source `T`
                  *
                  * If `S = true`, allows tails nodes as string
                  */
-                type Node<T extends Source = Source, S extends boolean = false> = NamesTree.Node<T, Kinds, S>;
+                type Node<T extends Source = Source, O extends Options = Options, S extends boolean = false, P extends TS.Keys = []> = NamesTree.Node<T, O, Kinds, S, P>;
                 /**
                  * @summary `Names` preset `NamesTree` for data `T`
                  *
                  * If `S = true`, allows tails nodes as string
                  */
-                type Tree<T extends NamesTree.Source.Root, S extends boolean = false> = AVStantso.NamesTree<T, Kinds, S>;
+                type Tree<T extends Source.Root, O extends Options, S extends boolean = false> = NamesTree<T, O, Kinds, S>;
             }
             /**
              * @summary `I18ns` preset
@@ -91,18 +325,22 @@ declare namespace AVStantso {
                  * @summary `I18ns` preset kinds
                  */
                 type Kinds = ['i18n', 'name'];
+                /**
+                 * @summary `I18ns` preset node constraint
+                 */
+                type Constraint = NamesTree.Node.Constraint<Kinds>;
                 /**
                  * @summary `I18ns` preset tree node for source `T`
                  *
                  * If `S = true`, allows tails nodes as string
                  */
-                type Node<T extends Source = Source, S extends boolean = false> = NamesTree.Node<T, Kinds, S>;
+                type Node<T extends Source = Source, O extends Options = Options, S extends boolean = false, P extends TS.Keys = []> = NamesTree.Node<T, O, Kinds, S, P>;
                 /**
                  * @summary `I18ns` preset `NamesTree` for data `T`
                  *
                  * If `S = true`, allows tails nodes as string
                  */
-                type Tree<T extends NamesTree.Source.Root, S extends boolean = false> = AVStantso.NamesTree<T, Kinds, S>;
+                type Tree<T extends Source.Root, O extends Options, S extends boolean = false> = NamesTree<T, O, Kinds, S>;
             }
             /**
              * @summary `Urls` preset
@@ -112,36 +350,40 @@ declare namespace AVStantso {
                  * @summary `Urls` preset kinds
                  */
                 type Kinds = ['name', 'path', 'url'];
+                /**
+                 * @summary `Urls` preset node constraint
+                 */
+                type Constraint = NamesTree.Node.Constraint<Kinds>;
                 /**
                  * @summary `Urls` preset tree node for source `T`
                  *
                  * If `S = true`, allows tails nodes as string
                  */
-                type Node<T extends Source = Source, S extends boolean = false> = NamesTree.Node<T, Kinds, S>;
+                type Node<T extends Source = Source, O extends Options = Options, S extends boolean = false, P extends TS.Keys = []> = NamesTree.Node<T, O, Kinds, S, P>;
                 /**
                  * @summary `Urls` preset `NamesTree` for data `T`
                  *
                  * If `S = true`, allows tails nodes as string
                  */
-                type Tree<T extends NamesTree.Source.Root, S extends boolean = false> = AVStantso.NamesTree<T, Kinds, S>;
+                type Tree<T extends NamesTree.Source.Root, O extends NamesTree.Options, S extends boolean = false> = NamesTree<T, O, Kinds, S>;
             }
         }
         export {};
     }
     namespace _NamesTree {
-        type _Splitted<T extends NamesTree.Source.Root, KDs extends readonly NamesTree.Kind[], R extends TS.Arr = []> = KDs extends readonly [
+        type _Splitted<T extends NamesTree.Source.Root, O extends NamesTree.Options, KDs extends readonly NamesTree.Kind[], R extends TS.Arr = []> = KDs extends readonly [
             infer C extends NamesTree.Kind,
             ...infer Rest extends readonly NamesTree.Kind[]
-        ] ? _Splitted<T, Rest, [
+        ] ? _Splitted<T, O, Rest, [
             ...R,
-            NamesTree<T, [C], true>
+            NamesTree<T, O, [C], true>
         ]> : R;
-        export type Splitted<T extends NamesTree.Source.Root, KDs extends readonly NamesTree.Kind[]> = _Splitted<T, KDs>;
-        export type ExtractByKinds<T extends NamesTree.Source.Root, KDs extends readonly NamesTree.Kind[], R = unknown> = KDs extends readonly [
+        export type Splitted<T extends NamesTree.Source.Root, O extends NamesTree.Options, KDs extends readonly NamesTree.Kind[]> = _Splitted<T, O, KDs>;
+        export type ExtractByKinds<T extends NamesTree.Source.Root, O extends NamesTree.Options, KDs extends readonly NamesTree.Kind[], R = unknown> = KDs extends readonly [
             infer C extends NamesTree.Kind,
             ...infer Rest extends readonly NamesTree.Kind[]
-        ] ? ExtractByKinds<T, Rest, R & {
-            [K in Capitalize<C>]: NamesTree<T, [C], true>;
+        ] ? ExtractByKinds<T, O, Rest, R & {
+            [K in Capitalize<C>]: NamesTree<T, O, [C], true>;
         }> : R;
         export {};
     }
@@ -150,22 +392,34 @@ declare namespace AVStantso {
      *
      * If `S = true`, allows tails nodes as string
      */
-    export type NamesTree<T extends NamesTree.Source.Root, KDs extends readonly NamesTree.Kind[], S extends boolean = false> = NamesTree.Node.Data<T, KDs, S> & (S extends true ? {} : {
+    export type NamesTree<T extends NamesTree.Source.Root, O extends NamesTree.Options, KDs extends readonly NamesTree.Kind[], S extends boolean = false> = NamesTree.Node.Data<T, O, KDs, S> & (S extends true ? O extends {
+        rootAlias: infer R extends TS.Key;
+    } ? {
+        [K in R]: NamesTree.ResolveKind<KDs[0], [''], O>;
+    } : unknown : {
+        /**
+         * @summary Get array of splitted trees each with unique kind
+         */
+        $splitted: _NamesTree.Splitted<T, O, KDs>;
         /**
-           * @summary Get array of splitted trees each with unique kind
-           */
-        splitted: _NamesTree.Splitted<T, KDs>;
+         * @summary Modify existing tree by additional data
+         */
+        $merge<M extends NamesTree.Source.Root>(data: M): NamesTree<T & M, O, KDs, S>;
         /**
-           * @summary Modify existing tree by additional data
-           */
-        merge<M extends NamesTree.Source.Root>(data: M): NamesTree<T & M, KDs, S>;
-    } & _NamesTree.ExtractByKinds<T, KDs>);
+         * @summary Access to `rootAlias` value
+         */
+        [symbolRootAlias]: O['rootAlias'];
+    } & _NamesTree.ExtractByKinds<T, O, KDs> & (O extends {
+        rootAlias: infer R extends TS.Key;
+    } ? {
+        [K in R]: NamesTree._NodeKinds<O, KDs, ['']>;
+    } : unknown));
     export namespace Code {
         /**
          * @summary `AVStantso.NamesTree` utility
          */
         interface NamesTree {
-            <T extends AVStantso.NamesTree.Source.Root, K0 extends AVStantso.NamesTree.Kind, K1 extends Exclude<AVStantso.NamesTree.Kind, K0> = undefined, K2 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1> = undefined, K3 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2> = undefined, K4 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3> = undefined, K5 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4> = undefined, K6 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4 | K5> = undefined, K7 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4 | K5 | K6> = undefined, K8 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4 | K5 | K6 | K7> = undefined, K9 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4 | K5 | K6 | K7 | K8> = undefined>(data: T, options: AVStantso.NamesTree.Options, kind0: K0, kind1?: K1, kind2?: K2, kind3?: K3, kind4?: K4, kind5?: K5, kind6?: K6, kind7?: K7, kind8?: K8, kind9?: K9): AVStantso.NamesTree<T, AVStantso.TS.Array.FilterUnique<[
+            <T extends AVStantso.NamesTree.Source.Root, O extends AVStantso.NamesTree.Options, K0 extends AVStantso.NamesTree.Kind, K1 extends Exclude<AVStantso.NamesTree.Kind, K0> = undefined, K2 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1> = undefined, K3 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2> = undefined, K4 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3> = undefined, K5 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4> = undefined, K6 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4 | K5> = undefined, K7 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4 | K5 | K6> = undefined, K8 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4 | K5 | K6 | K7> = undefined, K9 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4 | K5 | K6 | K7 | K8> = undefined>(data: T, options: O, kind0: K0, kind1?: K1, kind2?: K2, kind3?: K3, kind4?: K4, kind5?: K5, kind6?: K6, kind7?: K7, kind8?: K8, kind9?: K9): AVStantso.NamesTree<T, O, AVStantso.TS.Array.Filter<AVStantso.TS.Array.Filter.Unique<[
                 K0,
                 K1,
                 K2,
@@ -176,8 +430,8 @@ declare namespace AVStantso {
                 K7,
                 K8,
                 K9
-            ]>>;
-            <T extends AVStantso.NamesTree.Source.Root, K0 extends AVStantso.NamesTree.Kind, K1 extends Exclude<AVStantso.NamesTree.Kind, K0> = undefined, K2 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1> = undefined, K3 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2> = undefined, K4 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3> = undefined, K5 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4> = undefined, K6 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4 | K5> = undefined, K7 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4 | K5 | K6> = undefined, K8 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4 | K5 | K6 | K7> = undefined, K9 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4 | K5 | K6 | K7 | K8> = undefined>(data: T, kind0: K0, kind1?: K1, kind2?: K2, kind3?: K3, kind4?: K4, kind5?: K5, kind6?: K6, kind7?: K7, kind8?: K8, kind9?: K9): AVStantso.NamesTree<T, AVStantso.TS.Array.FilterUnique<[
+            ]>>>;
+            <T extends AVStantso.NamesTree.Source.Root, K0 extends AVStantso.NamesTree.Kind, K1 extends Exclude<AVStantso.NamesTree.Kind, K0> = undefined, K2 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1> = undefined, K3 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2> = undefined, K4 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3> = undefined, K5 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4> = undefined, K6 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4 | K5> = undefined, K7 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4 | K5 | K6> = undefined, K8 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4 | K5 | K6 | K7> = undefined, K9 extends Exclude<AVStantso.NamesTree.Kind, K0 | K1 | K2 | K3 | K4 | K5 | K6 | K7 | K8> = undefined>(data: T, kind0: K0, kind1?: K1, kind2?: K2, kind3?: K3, kind4?: K4, kind5?: K5, kind6?: K6, kind7?: K7, kind8?: K8, kind9?: K9): AVStantso.NamesTree<T, undefined, AVStantso.TS.Array.Filter<AVStantso.TS.Array.Filter.Unique<[
                 K0,
                 K1,
                 K2,
@@ -188,7 +442,7 @@ declare namespace AVStantso {
                 K7,
                 K8,
                 K9
-            ]>>;
+            ]>>>;
             /**
              * @summary Register external `NamesTree` kinds
              */
@@ -196,15 +450,19 @@ declare namespace AVStantso {
             /**
              * @summary Make `Name` `NamesTree`
              */
-            Names<T extends AVStantso.NamesTree.Source.Root>(data: T, options?: AVStantso.NamesTree.Options): AVStantso.NamesTree.Presets.Names.Tree<T>;
+            Names<T extends AVStantso.NamesTree.Source.Root, O extends AVStantso.NamesTree.Options = undefined>(data: T, options?: O): AVStantso.NamesTree.Presets.Names.Tree<T, O>;
             /**
              * @summary Make `i18n` `NamesTree`
              */
-            I18ns<T extends AVStantso.NamesTree.Source.Root>(data: T, options?: AVStantso.NamesTree.Options): AVStantso.NamesTree.Presets.I18ns.Tree<T>;
+            I18ns<T extends AVStantso.NamesTree.Source.Root, O extends AVStantso.NamesTree.Options = undefined>(data: T, options?: O): AVStantso.NamesTree.Presets.I18ns.Tree<T, O>;
             /**
              * @summary Make `urls` `NamesTree`
              */
-            Urls<T extends AVStantso.NamesTree.Source.Root>(data: T, options?: AVStantso.NamesTree.Options): AVStantso.NamesTree.Presets.Urls.Tree<T>;
+            Urls<T extends AVStantso.NamesTree.Source.Root, O extends AVStantso.NamesTree.Options = undefined>(data: T, options?: O): AVStantso.NamesTree.Presets.Urls.Tree<T, O>;
+            /**
+             * @summary Symbol for access to `rootAlias` value of property
+             */
+            symbolRootAlias: typeof symbolRootAlias;
         }
     }
     export interface Code {