@wooksjs/event-cli 0.5.19 → 0.5.25

package/dist/index.d.ts

@@ -1,12 +1,12 @@
-import * as _prostojs_router from '@prostojs/router';
-import { TProstoRouterPathHandle } from '@prostojs/router';
+import * as wooks from 'wooks';
+import { TWooksHandler, TWooksOptions, WooksAdapterBase, Wooks } from 'wooks';
 import * as _prostojs_cli_help from '@prostojs/cli-help';
 import { CliHelpRenderer, TCliHelpOptions, TCliEntry } from '@prostojs/cli-help';
 import { TConsoleBase } from '@prostojs/logger';
 import * as _wooksjs_event_core from '@wooksjs/event-core';
 import { TEventOptions, TEmpty } from '@wooksjs/event-core';
 import minimist from 'minimist';
-import { TWooksHandler, TWooksOptions, WooksAdapterBase, Wooks } from 'wooks';
+import { TProstoRouterPathHandle } from '@prostojs/router';
 
 interface TCliEventData {
     argv: string[];
@@ -21,12 +21,6 @@ interface TCliContextStore {
 }
 interface TCliHelpCustom {
     handler: TWooksHandler<any>;
-    /**
-     * ### Callback for registered path
-     *
-     * @param path registered path
-     * @param aliasType 0 - direct command, 1 - direct alias, 2 - computed alias
-     */
     cb?: <T>(path: string, aliasType: number, route?: TProstoRouterPathHandle<T>) => void;
 }
 type TCliHelpRenderer = CliHelpRenderer<TCliHelpCustom>;
@@ -52,402 +46,29 @@ declare class WooksCli extends WooksAdapterBase {
     protected logger: TConsoleBase;
     protected cliHelp: TCliHelpRenderer;
     constructor(opts?: TWooksCliOptions | undefined, wooks?: Wooks | WooksAdapterBase);
-    /**
-     * ### Register CLI Command
-     * Command path segments may be separated by / or space.
-     *
-     * For example the folowing path are interpreted the same:
-     * - "command test use:dev :name"
-     * - "command/test/use:dev/:name"
-     *
-     * Where name will become an argument
-     *
-     * ```js
-     * // example without options
-     * app.cli('command/:arg', () => 'arg = ' + useRouteParams().params.arg )
-     *
-     * // example with options
-     * app.cli('command/:arg', {
-     *   description: 'Description of the command',
-     *   options: [{ keys: ['project', 'p'], description: 'Description of the option', value: 'myProject' }],
-     *   args: { arg: 'Description of the arg' },
-     *   aliases: ['cmd'],  // alias "cmd/:arg" will be registered
-     *   examples: [{
-     *      description: 'Example of usage with someProject',
-     *      cmd: 'argValue -p=someProject',
-     *      // will result in help display:
-     *      // "# Example of usage with someProject\n" +
-     *      // "$ myCli command argValue -p=someProject\n"
-     *   }],
-     *   handler: () => 'arg = ' + useRouteParams().params.arg
-     * })
-     * ```
-     *
-     * @param path command path
-     * @param _options handler or options
-     *
-     * @returns
-     */
-    cli<ResType = unknown, ParamsType = Record<string, string | string[]>>(path: string, _options: TWooksCliEntry<ResType> | TWooksHandler<ResType>): _prostojs_router.TProstoRouterPathHandle<ParamsType>;
+    cli<ResType = unknown, ParamsType = Record<string, string | string[]>>(path: string, _options: TWooksCliEntry<ResType> | TWooksHandler<ResType>): wooks.TProstoRouterPathHandle<ParamsType>;
     protected alreadyComputedAliases: boolean;
     protected computeAliases(): void;
-    /**
-     * ## run
-     * ### Start command processing
-     * Triggers command processing
-     *
-     * By default takes `process.argv.slice(2)` as a command
-     *
-     * It's possible to replace the command by passing an argument
-     *
-     * @param _argv optionally overwrite `process.argv.slice(2)` with your `argv` array
-     */
     run(_argv?: string[], _opts?: minimist.Opts): Promise<unknown>;
     protected onError(e: Error): void;
-    /**
-     * Triggers `unknown command` processing and callbacks
-     * @param pathParams `string[]` containing command
-     */
     onUnknownCommand(pathParams: string[]): void;
     protected error(e: string | Error): void;
 }
-/**
- * Factory for WooksCli App
- * @param opts TWooksCliOptions
- * @param wooks Wooks | WooksAdapterBase
- * @returns WooksCli
- */
 declare function createCliApp(opts?: TWooksCliOptions, wooks?: Wooks | WooksAdapterBase): WooksCli;
 
-/**
- * ## useCliHelp
- * ### Composable
- * ```js
- * // example of printing cli instructions
- * const { print } = useCliHelp()
- * // print with colors
- * print(true)
- * // print with no colors
- * // print(false)
- * ```
- * @returns
- */
 declare function useCliHelp(): {
     getCliHelp: () => TCliHelpRenderer;
     getEntry: () => _prostojs_cli_help.TCliEntry<TCliHelpCustom>;
     render: (width?: number, withColors?: boolean) => string[];
     print: (withColors?: boolean) => void;
 };
-/**
- * ## useAutoHelp
- * ### Composable
- *
- * Prints help if `--help` option provided.
- *
- * ```js
- *  // example of use: print help and exit
- *  app.cli('test', () => {
- *      useAutoHelp() && process.exit(0)
- *      return 'hit test command'
- *  })
- *
- *  // add option -h to print help, no colors
- *  app.cli('test/nocolors', () => {
- *      useAutoHelp(['help', 'h'], false) && process.exit(0)
- *      return 'hit test nocolors command'
- *  })
- * ```
- * @param keys default `['help']` - list of options to trigger help render
- * @param colors default `true`, prints with colors when true
- * @returns true when --help was provided. Otherwise returns false
- */
 declare function useAutoHelp(keys?: string[], colors?: boolean): true | undefined;
-/**
- * ##useCommandLookupHelp
- * ### Composable
- *
- * Tries to find valid command based on provided command.
- *
- * If manages to find a valid command, throws an error
- * suggesting a list of valid commands
- *
- * Best to use in `onUnknownCommand` callback:
- *
- * ```js
- *  const app = createCliApp({
- *      onUnknownCommand: (path, raiseError) => {
- *          // will throw an error suggesting a list
- *          // of valid commands if could find some
- *          useCommandLookupHelp()
- *          // fallback to a regular error handler
- *          raiseError()
- *      },
- *  })
- * ```
- *
- * @param lookupDepth depth of search in backwards
- * @example
- *
- * For provided command `run test:drive dir`
- *  - lookup1: `run test:drive dir`  (deep = 0)
- *  - lookup2: `run test:drive`      (deep = 1)
- *  - lookup3: `run test`            (deep = 2)
- *  - lookup4: `run`                 (deep = 3)
- * ...
- */
 declare function useCommandLookupHelp(lookupDepth?: number): void;
 
-/**
- * Get CLI Options
- *
- * @returns an object with CLI options
- */
 declare function useCliOptions(): Record<string, string | boolean>;
-/**
- * Getter for Cli Option value
- *
- * @param name name of the option
- * @returns value of a CLI option
- */
 declare function useCliOption(name: string): string | boolean;
 
 declare function createCliContext(data: Omit<TCliEventData, 'type'>, options: TEventOptions): <T>(cb: (...a: any[]) => T) => T;
-/**
- * Wrapper on top of useEventContext that provides
- * proper context types for CLI event
- * @returns set of hooks { getCtx, restoreCtx, clearCtx, hookStore, getStore, setStore }
- */
-declare function useCliContext<T extends TEmpty>(): {
-    getCtx: () => TCliContextStore & T & _wooksjs_event_core.TGenericContextStore<TCliEventData>;
-    store: <K extends "flags" | keyof _wooksjs_event_core.TGenericContextStore<TCliEventData> | keyof T>(key: K) => {
-        value: (TCliContextStore & T & _wooksjs_event_core.TGenericContextStore<TCliEventData>)[K];
-        hook: <K2 extends keyof Required<TCliContextStore & T & _wooksjs_event_core.TGenericContextStore<TCliEventData>>[K]>(key2: K2) => {
-            value: Required<TCliContextStore & T & _wooksjs_event_core.TGenericContextStore<TCliEventData>>[K][K2];
-            isDefined: boolean;
-        };
-        init: <K2_1 extends keyof Required<TCliContextStore & T & _wooksjs_event_core.TGenericContextStore<TCliEventData>>[K]>(key2: K2_1, getter: () => Required<Required<TCliContextStore & T & _wooksjs_event_core.TGenericContextStore<TCliEventData>>[K]>[K2_1]) => Required<Required<TCliContextStore & T & _wooksjs_event_core.TGenericContextStore<TCliEventData>>[K]>[K2_1];
-        set: <K2_2 extends keyof Required<TCliContextStore & T & _wooksjs_event_core.TGenericContextStore<TCliEventData>>[K]>(key2: K2_2, v: Required<(TCliContextStore & T & _wooksjs_event_core.TGenericContextStore<TCliEventData>)[K]>[K2_2]) => Required<(TCliContextStore & T & _wooksjs_event_core.TGenericContextStore<TCliEventData>)[K]>[K2_2];
-        get: <K2_3 extends keyof Required<TCliContextStore & T & _wooksjs_event_core.TGenericContextStore<TCliEventData>>[K]>(key2: K2_3) => Required<TCliContextStore & T & _wooksjs_event_core.TGenericContextStore<TCliEventData>>[K][K2_3] | undefined;
-        has: <K2_4 extends keyof Required<TCliContextStore & T & _wooksjs_event_core.TGenericContextStore<TCliEventData>>[K]>(key2: K2_4) => boolean;
-        del: <K2_5 extends keyof Required<TCliContextStore & T & _wooksjs_event_core.TGenericContextStore<TCliEventData>>[K]>(key2: K2_5) => void;
-        entries: () => [string, unknown][];
-        clear: () => void;
-    };
-    getStore: <K_1 extends "flags" | keyof _wooksjs_event_core.TGenericContextStore<TCliEventData> | keyof T>(key: K_1) => (TCliContextStore & T & _wooksjs_event_core.TGenericContextStore<TCliEventData>)[K_1];
-    setStore: <K_2 extends "flags" | keyof _wooksjs_event_core.TGenericContextStore<TCliEventData> | keyof T>(key: K_2, v: (TCliContextStore & T & _wooksjs_event_core.TGenericContextStore<TCliEventData>)[K_2]) => void;
-    setParentCtx: (parentCtx: unknown) => void;
-    hasParentCtx: () => boolean;
-    getParentCtx: <T2 = TCliContextStore & T & _wooksjs_event_core.TGenericContextStore<TCliEventData>>() => {
-        getCtx: () => T2;
-        store: <K_3 extends keyof T2>(key: K_3) => {
-            value: T2[K_3];
-            hook: <K2_6 extends keyof Required<T2>[K_3]>(key2: K2_6) => {
-                value: Required<T2>[K_3][K2_6];
-                isDefined: boolean;
-            };
-            init: <K2_7 extends keyof Required<T2>[K_3]>(key2: K2_7, getter: () => Required<Required<T2>[K_3]>[K2_7]) => Required<Required<T2>[K_3]>[K2_7];
-            set: <K2_8 extends keyof Required<T2>[K_3]>(key2: K2_8, v: Required<T2[K_3]>[K2_8]) => Required<T2[K_3]>[K2_8];
-            get: <K2_9 extends keyof Required<T2>[K_3]>(key2: K2_9) => Required<T2>[K_3][K2_9] | undefined;
-            has: <K2_10 extends keyof Required<T2>[K_3]>(key2: K2_10) => boolean;
-            del: <K2_11 extends keyof Required<T2>[K_3]>(key2: K2_11) => void;
-            entries: () => [string, unknown][];
-            clear: () => void;
-        };
-        getStore: <K_4 extends keyof T2>(key: K_4) => T2[K_4];
-        setStore: <K_5 extends keyof T2>(key: K_5, v: T2[K_5]) => void;
-        setParentCtx: (parentCtx: unknown) => void;
-        hasParentCtx: () => boolean;
-        getParentCtx: <T2_1 = T2>() => {
-            getCtx: () => T2_1;
-            store: <K_6 extends keyof T2_1>(key: K_6) => {
-                value: T2_1[K_6];
-                hook: <K2_12 extends keyof Required<T2_1>[K_6]>(key2: K2_12) => {
-                    value: Required<T2_1>[K_6][K2_12];
-                    isDefined: boolean;
-                };
-                init: <K2_13 extends keyof Required<T2_1>[K_6]>(key2: K2_13, getter: () => Required<Required<T2_1>[K_6]>[K2_13]) => Required<Required<T2_1>[K_6]>[K2_13];
-                set: <K2_14 extends keyof Required<T2_1>[K_6]>(key2: K2_14, v: Required<T2_1[K_6]>[K2_14]) => Required<T2_1[K_6]>[K2_14];
-                get: <K2_15 extends keyof Required<T2_1>[K_6]>(key2: K2_15) => Required<T2_1>[K_6][K2_15] | undefined;
-                has: <K2_16 extends keyof Required<T2_1>[K_6]>(key2: K2_16) => boolean;
-                del: <K2_17 extends keyof Required<T2_1>[K_6]>(key2: K2_17) => void;
-                entries: () => [string, unknown][];
-                clear: () => void;
-            };
-            getStore: <K_7 extends keyof T2_1>(key: K_7) => T2_1[K_7];
-            setStore: <K_8 extends keyof T2_1>(key: K_8, v: T2_1[K_8]) => void;
-            setParentCtx: (parentCtx: unknown) => void;
-            hasParentCtx: () => boolean;
-            getParentCtx: <T2_2 = T2_1>() => {
-                getCtx: () => T2_2;
-                store: <K_9 extends keyof T2_2>(key: K_9) => {
-                    value: T2_2[K_9];
-                    hook: <K2_18 extends keyof Required<T2_2>[K_9]>(key2: K2_18) => {
-                        value: Required<T2_2>[K_9][K2_18];
-                        isDefined: boolean;
-                    };
-                    init: <K2_19 extends keyof Required<T2_2>[K_9]>(key2: K2_19, getter: () => Required<Required<T2_2>[K_9]>[K2_19]) => Required<Required<T2_2>[K_9]>[K2_19];
-                    set: <K2_20 extends keyof Required<T2_2>[K_9]>(key2: K2_20, v: Required<T2_2[K_9]>[K2_20]) => Required<T2_2[K_9]>[K2_20];
-                    get: <K2_21 extends keyof Required<T2_2>[K_9]>(key2: K2_21) => Required<T2_2>[K_9][K2_21] | undefined;
-                    has: <K2_22 extends keyof Required<T2_2>[K_9]>(key2: K2_22) => boolean;
-                    del: <K2_23 extends keyof Required<T2_2>[K_9]>(key2: K2_23) => void;
-                    entries: () => [string, unknown][];
-                    clear: () => void;
-                };
-                getStore: <K_10 extends keyof T2_2>(key: K_10) => T2_2[K_10];
-                setStore: <K_11 extends keyof T2_2>(key: K_11, v: T2_2[K_11]) => void;
-                setParentCtx: (parentCtx: unknown) => void;
-                hasParentCtx: () => boolean;
-                getParentCtx: <T2_3 = T2_2>() => {
-                    getCtx: () => T2_3;
-                    store: <K_12 extends keyof T2_3>(key: K_12) => {
-                        value: T2_3[K_12];
-                        hook: <K2_24 extends keyof Required<T2_3>[K_12]>(key2: K2_24) => {
-                            value: Required<T2_3>[K_12][K2_24];
-                            isDefined: boolean;
-                        };
-                        init: <K2_25 extends keyof Required<T2_3>[K_12]>(key2: K2_25, getter: () => Required<Required<T2_3>[K_12]>[K2_25]) => Required<Required<T2_3>[K_12]>[K2_25];
-                        set: <K2_26 extends keyof Required<T2_3>[K_12]>(key2: K2_26, v: Required<T2_3[K_12]>[K2_26]) => Required<T2_3[K_12]>[K2_26];
-                        get: <K2_27 extends keyof Required<T2_3>[K_12]>(key2: K2_27) => Required<T2_3>[K_12][K2_27] | undefined;
-                        has: <K2_28 extends keyof Required<T2_3>[K_12]>(key2: K2_28) => boolean;
-                        del: <K2_29 extends keyof Required<T2_3>[K_12]>(key2: K2_29) => void;
-                        entries: () => [string, unknown][];
-                        clear: () => void;
-                    };
-                    getStore: <K_13 extends keyof T2_3>(key: K_13) => T2_3[K_13];
-                    setStore: <K_14 extends keyof T2_3>(key: K_14, v: T2_3[K_14]) => void;
-                    setParentCtx: (parentCtx: unknown) => void;
-                    hasParentCtx: () => boolean;
-                    getParentCtx: <T2_4 = T2_3>() => {
-                        getCtx: () => T2_4;
-                        store: <K_15 extends keyof T2_4>(key: K_15) => {
-                            value: T2_4[K_15];
-                            hook: <K2_30 extends keyof Required<T2_4>[K_15]>(key2: K2_30) => {
-                                value: Required<T2_4>[K_15][K2_30];
-                                isDefined: boolean;
-                            };
-                            init: <K2_31 extends keyof Required<T2_4>[K_15]>(key2: K2_31, getter: () => Required<Required<T2_4>[K_15]>[K2_31]) => Required<Required<T2_4>[K_15]>[K2_31];
-                            set: <K2_32 extends keyof Required<T2_4>[K_15]>(key2: K2_32, v: Required<T2_4[K_15]>[K2_32]) => Required<T2_4[K_15]>[K2_32];
-                            get: <K2_33 extends keyof Required<T2_4>[K_15]>(key2: K2_33) => Required<T2_4>[K_15][K2_33] | undefined;
-                            has: <K2_34 extends keyof Required<T2_4>[K_15]>(key2: K2_34) => boolean;
-                            del: <K2_35 extends keyof Required<T2_4>[K_15]>(key2: K2_35) => void;
-                            entries: () => [string, unknown][];
-                            clear: () => void;
-                        };
-                        getStore: <K_16 extends keyof T2_4>(key: K_16) => T2_4[K_16];
-                        setStore: <K_17 extends keyof T2_4>(key: K_17, v: T2_4[K_17]) => void;
-                        setParentCtx: (parentCtx: unknown) => void;
-                        hasParentCtx: () => boolean;
-                        getParentCtx: <T2_5 = T2_4>() => {
-                            getCtx: () => T2_5;
-                            store: <K_18 extends keyof T2_5>(key: K_18) => {
-                                value: T2_5[K_18];
-                                hook: <K2_36 extends keyof Required<T2_5>[K_18]>(key2: K2_36) => {
-                                    value: Required<T2_5>[K_18][K2_36];
-                                    isDefined: boolean;
-                                };
-                                init: <K2_37 extends keyof Required<T2_5>[K_18]>(key2: K2_37, getter: () => Required<Required<T2_5>[K_18]>[K2_37]) => Required<Required<T2_5>[K_18]>[K2_37];
-                                set: <K2_38 extends keyof Required<T2_5>[K_18]>(key2: K2_38, v: Required<T2_5[K_18]>[K2_38]) => Required<T2_5[K_18]>[K2_38];
-                                get: <K2_39 extends keyof Required<T2_5>[K_18]>(key2: K2_39) => Required<T2_5>[K_18][K2_39] | undefined;
-                                has: <K2_40 extends keyof Required<T2_5>[K_18]>(key2: K2_40) => boolean;
-                                del: <K2_41 extends keyof Required<T2_5>[K_18]>(key2: K2_41) => void;
-                                entries: () => [string, unknown][];
-                                clear: () => void;
-                            };
-                            getStore: <K_19 extends keyof T2_5>(key: K_19) => T2_5[K_19];
-                            setStore: <K_20 extends keyof T2_5>(key: K_20, v: T2_5[K_20]) => void;
-                            setParentCtx: (parentCtx: unknown) => void;
-                            hasParentCtx: () => boolean;
-                            getParentCtx: <T2_6 = T2_5>() => {
-                                getCtx: () => T2_6;
-                                store: <K_21 extends keyof T2_6>(key: K_21) => {
-                                    value: T2_6[K_21];
-                                    hook: <K2_42 extends keyof Required<T2_6>[K_21]>(key2: K2_42) => {
-                                        value: Required<T2_6>[K_21][K2_42];
-                                        isDefined: boolean;
-                                    };
-                                    init: <K2_43 extends keyof Required<T2_6>[K_21]>(key2: K2_43, getter: () => Required<Required<T2_6>[K_21]>[K2_43]) => Required<Required<T2_6>[K_21]>[K2_43];
-                                    set: <K2_44 extends keyof Required<T2_6>[K_21]>(key2: K2_44, v: Required<T2_6[K_21]>[K2_44]) => Required<T2_6[K_21]>[K2_44];
-                                    get: <K2_45 extends keyof Required<T2_6>[K_21]>(key2: K2_45) => Required<T2_6>[K_21][K2_45] | undefined;
-                                    has: <K2_46 extends keyof Required<T2_6>[K_21]>(key2: K2_46) => boolean;
-                                    del: <K2_47 extends keyof Required<T2_6>[K_21]>(key2: K2_47) => void;
-                                    entries: () => [string, unknown][];
-                                    clear: () => void;
-                                };
-                                getStore: <K_22 extends keyof T2_6>(key: K_22) => T2_6[K_22];
-                                setStore: <K_23 extends keyof T2_6>(key: K_23, v: T2_6[K_23]) => void;
-                                setParentCtx: (parentCtx: unknown) => void;
-                                hasParentCtx: () => boolean;
-                                getParentCtx: <T2_7 = T2_6>() => {
-                                    getCtx: () => T2_7;
-                                    store: <K_24 extends keyof T2_7>(key: K_24) => {
-                                        value: T2_7[K_24];
-                                        hook: <K2_48 extends keyof Required<T2_7>[K_24]>(key2: K2_48) => {
-                                            value: Required<T2_7>[K_24][K2_48];
-                                            isDefined: boolean;
-                                        };
-                                        init: <K2_49 extends keyof Required<T2_7>[K_24]>(key2: K2_49, getter: () => Required<Required<T2_7>[K_24]>[K2_49]) => Required<Required<T2_7>[K_24]>[K2_49];
-                                        set: <K2_50 extends keyof Required<T2_7>[K_24]>(key2: K2_50, v: Required<T2_7[K_24]>[K2_50]) => Required<T2_7[K_24]>[K2_50];
-                                        get: <K2_51 extends keyof Required<T2_7>[K_24]>(key2: K2_51) => Required<T2_7>[K_24][K2_51] | undefined;
-                                        has: <K2_52 extends keyof Required<T2_7>[K_24]>(key2: K2_52) => boolean;
-                                        del: <K2_53 extends keyof Required<T2_7>[K_24]>(key2: K2_53) => void;
-                                        entries: () => [string, unknown][];
-                                        clear: () => void;
-                                    };
-                                    getStore: <K_25 extends keyof T2_7>(key: K_25) => T2_7[K_25];
-                                    setStore: <K_26 extends keyof T2_7>(key: K_26, v: T2_7[K_26]) => void;
-                                    setParentCtx: (parentCtx: unknown) => void;
-                                    hasParentCtx: () => boolean;
-                                    getParentCtx: <T2_8 = T2_7>() => {
-                                        getCtx: () => T2_8;
-                                        store: <K_27 extends keyof T2_8>(key: K_27) => {
-                                            value: T2_8[K_27];
-                                            hook: <K2_54 extends keyof Required<T2_8>[K_27]>(key2: K2_54) => {
-                                                value: Required<T2_8>[K_27][K2_54];
-                                                isDefined: boolean;
-                                            };
-                                            init: <K2_55 extends keyof Required<T2_8>[K_27]>(key2: K2_55, getter: () => Required<Required<T2_8>[K_27]>[K2_55]) => Required<Required<T2_8>[K_27]>[K2_55];
-                                            set: <K2_56 extends keyof Required<T2_8>[K_27]>(key2: K2_56, v: Required<T2_8[K_27]>[K2_56]) => Required<T2_8[K_27]>[K2_56];
-                                            get: <K2_57 extends keyof Required<T2_8>[K_27]>(key2: K2_57) => Required<T2_8>[K_27][K2_57] | undefined;
-                                            has: <K2_58 extends keyof Required<T2_8>[K_27]>(key2: K2_58) => boolean;
-                                            del: <K2_59 extends keyof Required<T2_8>[K_27]>(key2: K2_59) => void;
-                                            entries: () => [string, unknown][];
-                                            clear: () => void;
-                                        };
-                                        getStore: <K_28 extends keyof T2_8>(key: K_28) => T2_8[K_28];
-                                        setStore: <K_29 extends keyof T2_8>(key: K_29, v: T2_8[K_29]) => void;
-                                        setParentCtx: (parentCtx: unknown) => void;
-                                        hasParentCtx: () => boolean;
-                                        getParentCtx: <T2_9 = T2_8>() => {
-                                            getCtx: () => T2_9;
-                                            store: <K_30 extends keyof T2_9>(key: K_30) => {
-                                                value: T2_9[K_30];
-                                                hook: <K2_60 extends keyof Required<T2_9>[K_30]>(key2: K2_60) => {
-                                                    value: Required<T2_9>[K_30][K2_60];
-                                                    isDefined: boolean;
-                                                };
-                                                init: <K2_61 extends keyof Required<T2_9>[K_30]>(key2: K2_61, getter: () => Required<Required<T2_9>[K_30]>[K2_61]) => Required<Required<T2_9>[K_30]>[K2_61];
-                                                set: <K2_62 extends keyof Required<T2_9>[K_30]>(key2: K2_62, v: Required<T2_9[K_30]>[K2_62]) => Required<T2_9[K_30]>[K2_62];
-                                                get: <K2_63 extends keyof Required<T2_9>[K_30]>(key2: K2_63) => Required<T2_9>[K_30][K2_63] | undefined;
-                                                has: <K2_64 extends keyof Required<T2_9>[K_30]>(key2: K2_64) => boolean;
-                                                del: <K2_65 extends keyof Required<T2_9>[K_30]>(key2: K2_65) => void;
-                                                entries: () => [string, unknown][];
-                                                clear: () => void;
-                                            };
-                                            getStore: <K_31 extends keyof T2_9>(key: K_31) => T2_9[K_31];
-                                            setStore: <K_32 extends keyof T2_9>(key: K_32, v: T2_9[K_32]) => void;
-                                            setParentCtx: (parentCtx: unknown) => void;
-                                            hasParentCtx: () => boolean;
-                                            getParentCtx: <T2_10 = T2_9>() => any;
-                                        };
-                                    };
-                                };
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    };
-};
+declare function useCliContext<T extends TEmpty>(): _wooksjs_event_core.TCtxHelpers<TCliContextStore & T & _wooksjs_event_core.TGenericContextStore<TCliEventData>>;
 
 export { type TCliContextStore, type TCliEventData, type TCliHelpCustom, type TCliHelpRenderer, type TWooksCliEntry, type TWooksCliOptions, WooksCli, cliShortcuts, createCliApp, createCliContext, useAutoHelp, useCliContext, useCliHelp, useCliOption, useCliOptions, useCommandLookupHelp };