@bemoje/cli 0.0.2 → 0.0.3

package/src/util/fs/promptUserEditInTextEditor/IGetUserInputFromEditorOptions.d.ts

@@ -0,0 +1,15 @@
+export interface IGetUserInputFromEditorOptions {
+    /**
+     * The content to put in the temp file so that the user can edit it. Defaults to an empty file.
+     */
+    content?: string;
+    /**
+     * Launch command to start your editor. Defaults to VSCode: 'code -w' (if installed).
+     * Otherwise this logic: isWindows() ? 'notepad' : isOSX() ? 'open vi' : 'xdg-open'
+     */
+    editor?: string;
+    /**
+     * The file extension to use for the temporary file. Defaults to '.txt'.
+     */
+    extension?: string;
+}

package/src/util/fs/promptUserEditInTextEditor/promptUserEditInTextEditorSync.d.ts

@@ -0,0 +1,9 @@
+import { IGetUserInputFromEditorOptions } from './IGetUserInputFromEditorOptions';
+/**
+ * Prompts the user to edit a string in the user's text editor.
+ *
+ * @example ```ts
+ * promptUserEditInTextEditor({ editor: 'notepad' })
+ * ```
+ */
+export declare function promptUserEditInTextEditorSync(options?: IGetUserInputFromEditorOptions): string;

package/src/util/fs/promptUserEditInTextEditor/promptUserEditJsonInTextEditorSync.d.ts

@@ -0,0 +1,13 @@
+import { JsonValue } from '../../types/JsonValue';
+/**
+ * Edit a JSON-stringify-compatible value in the user's editor and return the (JSON.parse'd) result.
+ *
+ * @param value - The value to edit (NOT a json string). Defaults to an empty object.
+ * @param editor - Launch command to start your editor. Defaults to VSCode: 'code -w' (if installed).
+ * - Otherwise this logic: isWindows() ? 'notepad' : isOSX() ? 'open vi' : 'xdg-open'
+ *
+ * @example ```ts
+ * promptUserEditJsonInTextEditorSync([1, 2])
+ * ```
+ */
+export declare function promptUserEditJsonInTextEditorSync<T extends JsonValue = JsonValue, R extends T = T>(value?: T, editor?: string): R;

package/src/util/fs/readFile/readFileSafeSync.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+/**
+ * Reads a file and returns the file's contents.
+ *
+ * Identical to fs.readFileSync, except that:
+ * - it uses utf8 encoding by default
+ * - if operation fails, returns undefined instead of throwing
+ *
+ * @param filepath - The path to the file.
+ * @param encoding - The encoding to use when reading the file.
+ * @returns The file's contents or undefined if the file does not exist.
+ */
+export declare function readFileSafeSync(filepath: string, encoding?: BufferEncoding): string | undefined;

package/src/util/fs/readFile/readFileSync.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+/**
+ * Reads a file and returns the file's contents.
+ * Identical to fs.readFileSync, except that it uses utf8 encoding by default.
+ *
+ * @param filepath - The path to the file.
+ * @param encoding - The encoding to use when reading the file.
+ * @returns The file's contents.
+ */
+export declare function readFileSync(filepath: string, encoding?: BufferEncoding): string;

package/src/util/fs/readJsonFile/readJsonFileSafeSync.d.ts

@@ -0,0 +1,9 @@
+import { IReadJsonFileOptions } from '../types/IReadJsonFileOptions';
+/**
+ * Reads a JSON file and then parses it into an object.
+ * If an error occurs, it returns undefined.
+ *
+ * @param filepath - The path to the JSON file.
+ * @param options - Options for reading the JSON file.
+ */
+export declare function readJsonFileSafeSync<T>(filepath: string, options?: IReadJsonFileOptions): T | undefined;

package/src/util/fs/removeFile/removeFile.d.ts

@@ -0,0 +1 @@
+export { remove as removeFile } from 'fs-extra';

package/src/util/fs/tempFile/tempFileSync.d.ts

@@ -0,0 +1,7 @@
+import { Any } from '../../types/Any';
+/**
+ * Syncrhonously creates a temporary file and deletes it after the callback has finished.
+ * @param fileExtension - The file extension to use for the temporary file.
+ * @param callback - The callback to execute with the temporary file path. The callback can return a promise and the temporary file will not be deleted until the promise has resolved or rejected.
+ */
+export declare function tempFileSync(fileExtension: string, callback: (fpath: string) => Any): any;

package/src/util/fs/types/IReadJsonFileOptions.d.ts

@@ -0,0 +1 @@
+export type { JFReadOptions as IReadJsonFileOptions } from 'jsonfile';

package/src/util/fs/writeFile/writeFileSafeSync.d.ts

@@ -0,0 +1 @@
+export { outputFileSync as writeFileSafeSync } from 'fs-extra';

package/src/util/fs/writeFile/writeFileSync.d.ts

@@ -0,0 +1 @@
+export { writeFileSync } from 'fs-extra';

package/src/util/fs/writeJsonFile/writeJsonFileSafe.d.ts

@@ -0,0 +1 @@
+export { outputJson as writeJsonFileSafe } from 'fs-extra';

package/src/{core/util → util/function}/MethodDisabler.d.ts

@@ -1,5 +1,6 @@
-import { Any, ObjectKey, TFunctionNoNew } from '@bemoje/util';
-import { Base } from '../CommandBuilder/Base';
+import { Any } from '../types/Any';
+import { ObjectKey } from '../types/ObjectKey';
+import { TFunctionNoNew } from '../types/TFunctionNoNew';
 /**
  * A class that creates an object with methods for disabling/enabling a given method on a given object.
  *
@@ -16,7 +17,7 @@ import { Base } from '../CommandBuilder/Base';
  *
  * assert(md.original === process.stdout.write)
  */
-export declare class MethodDisabler extends Base {
+export declare class MethodDisabler {
     #private;
     /**
      * @param obj - The object on which the method is defined.

package/src/util/function/funSetName.d.ts

@@ -0,0 +1,13 @@
+/**
+ * This function sets the name of a function and returns the function with the new name.
+ * @template T - The type of the function.
+ * @param name The new name to be set for the function.
+ * @param fun The function whose name is to be set.
+ * @returns The function with the new name.
+ * @example ```ts
+ * const myFun = () => 'Hello World';
+ * funSetName('newFun', myFun).name;;
+ * //=> 'newFun'
+ * ```
+ */
+export declare function funSetName<T>(name: string, fun: T): T;

package/src/util/node/execInherit.d.ts

@@ -0,0 +1 @@
+export declare function execInherit(command: string): Promise<string>;

package/src/{core/util → util/object}/createArrayMerger.d.ts

@@ -1 +1,4 @@
+/**
+ * Creates a function that merges arrays based on a predicate function.
+ */
 export declare function createArrayMerger<T>(predicate: (value: T, index: number, arr: T[]) => boolean): <E extends T>(target: E[], ...sources: E[][]) => E[];

package/src/{core/util → util/object}/createObjectMerger.d.ts

@@ -1,2 +1,5 @@
-import { Any } from '@bemoje/util';
+import { Any } from '../types/Any';
+/**
+ * Creates a function that merges objects based on a predicate function.
+ */
 export declare function createObjectMerger(predicate: (value: Any, key: string, obj: Record<string, Any>) => boolean): (target: Record<string, Any>, ...sources: Record<string, Any>[]) => Record<string, any>;

package/src/util/object/objUpdatePropertyDescriptors.d.ts

@@ -0,0 +1,16 @@
+import { ObjectKey } from '../types/ObjectKey';
+/**
+ * Updates the property descriptors of the specified properties on the given object.
+ * @param object - The object whose property descriptors are to be updated.
+ * @param properties - An array of property names for which the descriptors are to be updated.
+ * @param update - A function that takes a property descriptor and a property name, and returns a new property descriptor.
+ * @throws Will throw an error if any of the specified properties do not exist on the object.
+ * @example ```ts
+ * const obj = { a: 1, b: 2 };
+ * objUpdatePropertyDescriptors(obj, ['a', 'b'], (descriptor, property) => {
+ *   descriptor.writable = true;
+ *   return obj;
+ * });
+ * ```
+ */
+export declare function objUpdatePropertyDescriptors<V>(object: Record<ObjectKey, V>, properties: string[], update: <T extends PropertyDescriptor>(descriptor: T, property: string) => T): void;

package/src/util/object/setNonEnumerable.d.ts

@@ -0,0 +1,15 @@
+import { ObjectKey } from '../types/ObjectKey';
+/**
+ * Sets the specified properties of an object as non-enumerable.
+ * @remarks This function modifies the original object by setting the specified properties as non-enumerable.
+ * If the object or any of the property names are not valid, it throws an error.
+ * @param object The object whose properties are to be set as non-enumerable.
+ * @param properties The names of the properties to be set as non-enumerable.
+ * @throws Will throw an error if any of the specified properties do not exist on the object.
+ * @example ```ts
+ * setNonEnumerable({ a: 1, b: 2, c: 3 }, 'a', 'b');
+ * Object.keys({ a: 1, b: 2, c: 3 });;
+ * //=> ['c']
+ * ```
+ */
+export declare function setNonEnumerable(object: Record<ObjectKey, any>, ...properties: string[]): void;

package/src/util/os/defaultOpenInEditorCommand.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Get the default command to open a file in in a text editor.
+ * If VSCode is installed, this is used. Otherwise, the default text editor of the OS is used.
+ */
+export declare function defaultOpenInEditorCommand(): string;

package/src/util/os/isOSX.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Checks if the current platform is OSX.
+ * It checks the 'process' object and the 'platform' property to determine if the platform is 'darwin'.
+ * @returns A boolean indicating whether the current platform is OSX.
+ */
+export declare function isOSX(): boolean;

package/src/util/os/isVsCodeInstalled.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns whether Visual Studio Code is installed on the system.
+ * @example isVsCodeInstalled() //=> true
+ */
+export declare function isVsCodeInstalled(): boolean;

package/src/util/os/isWindows.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Checks if the current platform is Windows.
+ * @remarks
+ * It checks the 'process' object and the 'platform' property to determine if the platform is 'win32'.
+ * It also checks the 'OSTYPE' environment variable to see if it matches 'msys' or 'cygwin'.
+ * @returns A boolean indicating whether the current platform is Windows.
+ */
+export declare function isWindows(): boolean;

package/src/util/path/getTempDataPath.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns a path to the os tmpdir location.
+ *
+ * @param paths - The paths to join to the os tmpdir location.
+ */
+export declare function getTempDataPath(...paths: string[]): string;

package/src/util/regex/regexEscapeString.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Escapes special characters in a string to be used in a regular expression.
+ * @param str The input string to escape.
+ * @returns The escaped string.
+ * @example ```ts
+ * const input = 'Hello, world!';
+ * regexEscapeString(input);;
+ * //=> 'Hello, world!'
+ * ```
+ */
+export declare function regexEscapeString(str: string): string;

package/src/util/string/strEnsureStartsWith.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Ensures that a string starts with a specified substring. If the string already starts with the specified substring, it is returned as is. Otherwise, the substring is appended to the end of the string.
+ * @param string The string to be processed.
+ * @param startsWith The substring that the string should end with.
+ * @example ```ts
+ * strEnsureStartsWith('json', '.');
+ * //=> '.json'
+ * strEnsureStartsWith('.json', '.');
+ * //=> '.json'
+ * ```
+ */
+export declare function strEnsureStartsWith(string: string, startsWith: string): string;

package/src/util/string/strFirstCharToUpperCase.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Converts the first character of a string to uppercase.
+ * @param string The string to be converted.
+ * @example ```ts
+ * strFirstCharToUpperCase('hello');
+ * //=> 'Hello'
+ * ```
+ */
+export declare function strFirstCharToUpperCase(string: string): string;

package/src/util/string/strIsLowerCase.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Checks if the given string is in lower case.
+ * @param input The string to be checked.
+ * @example ```ts
+ * strIsLowerCase('hello');
+ * //=> true
+ * strIsLowerCase('Hello');
+ * //=> false
+ * ```
+ */
+export declare function strIsLowerCase(input: string): boolean;

package/src/util/string/strIsUpperCase.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Checks if the given string is in upper case.
+ * @param input The string to be checked.
+ * @example ```ts
+ * strIsUpperCase('HELLO');;
+ * //=> true
+ * strIsUpperCase('HEllo');;
+ * //=> false
+ * ```
+ */
+export declare function strIsUpperCase(input: string): boolean;

package/src/util/string/strSplitCamelCase.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns an array of words in the string
+ * @param word The camel case word to split.
+ * @throws Throws an error if the input is not a string.
+ * @param input input string
+ * @example ```ts
+ * strSplitCamelCase('someCamel10Case')
+ * //=> ['some', 'Camel10', 'Case']
+ * ```
+ */
+export declare function strSplitCamelCase(word: string): string[];

package/src/util/types/Any.d.ts

@@ -0,0 +1 @@
+export type Any = any;

package/src/util/types/DeepArray.d.ts

@@ -0,0 +1,10 @@
+import { DeepObject } from './DeepObject';
+import { ObjectKey } from './ObjectKey';
+/**
+ * Recursively defined array that can contain objects+arrays with values of a given type V.
+ */
+export type DeepArray<V, K extends ObjectKey = string | symbol> = Array<V | DeepObject<V, K> | DeepArray<V, K>> | [];
+/**
+ * Recursively defined array that can contain only arrays (excl. objects) with values of a given type V.
+ */
+export type StrictlyDeepArray<V> = Array<V | StrictlyDeepArray<V>>;

package/src/util/types/DeepObject.d.ts

@@ -0,0 +1,14 @@
+import { DeepArray } from './DeepArray';
+import { ObjectKey } from './ObjectKey';
+/**
+ * Recursively defined object with objects+arrays with values of a given type V.
+ */
+export type DeepObject<V, K extends ObjectKey = string | symbol> = {
+    [_ in K]?: V | DeepObject<V, K> | DeepArray<V, K>;
+};
+/**
+ * Recursively defined array that can contain only objects (excl. arrays) with values of a given type V.
+ */
+export type StrictlyDeepObject<V, K extends string | symbol = string | symbol> = {
+    [_ in K]?: V | StrictlyDeepObject<V, K>;
+};

package/src/util/types/JsonArray.d.ts

@@ -0,0 +1,6 @@
+import { DeepArray } from './DeepArray';
+import { JsonRawPrimitive } from './JsonRawPrimitive';
+/**
+ * Return-type of parsed JSON array.
+ */
+export type JsonArray<P extends JsonRawPrimitive = JsonRawPrimitive> = DeepArray<P, string> | P[];

package/src/util/types/JsonDefinedPrimitive.d.ts

@@ -0,0 +1,4 @@
+/**
+ * All supported defined (!= null) primitive types in JSON.
+ */
+export type JsonDefinedPrimitive = string | number | boolean;

package/src/util/types/JsonObject.d.ts

@@ -0,0 +1,6 @@
+import { DeepObject } from './DeepObject';
+import { JsonRawPrimitive } from './JsonRawPrimitive';
+/**
+ * Return-type of parsed JSON object.
+ */
+export type JsonObject<P extends JsonRawPrimitive = JsonRawPrimitive> = DeepObject<P, string> | Record<string, P>;

package/src/util/types/JsonRawPrimitive.d.ts

@@ -0,0 +1,5 @@
+import { JsonDefinedPrimitive } from './JsonDefinedPrimitive';
+/**
+ * All supported primitive types in JSON.
+ */
+export type JsonRawPrimitive = null | JsonDefinedPrimitive;

package/src/util/types/JsonValue.d.ts

@@ -0,0 +1,7 @@
+import { JsonArray } from './JsonArray';
+import { JsonObject } from './JsonObject';
+import { JsonRawPrimitive } from './JsonRawPrimitive';
+/**
+ * Any JSON value. Any JSON.parse() return value.
+ */
+export type JsonValue<P extends JsonRawPrimitive = JsonRawPrimitive> = P | JsonObject<P> | JsonArray<P> | P[] | Record<string, P>;

package/src/util/types/ObjectKey.d.ts

@@ -0,0 +1 @@
+export type ObjectKey = string | number | symbol;

package/src/util/types/TConstructor.d.ts

@@ -0,0 +1,5 @@
+import { Any } from './Any';
+/**
+ * This type represents a constructor function. It is a function that can be called with the `new` keyword to create an instance of a certain type.
+ */
+export type TConstructor<R = Any, A extends Any[] = Any[]> = new (...args: A) => R;

package/src/util/types/TFunction.d.ts

@@ -0,0 +1,4 @@
+import { Any } from './Any';
+import { TConstructor } from './TConstructor';
+import { TFunctionNoNew } from './TFunctionNoNew';
+export type TFunction<R = Any, A extends Any[] = Any[]> = TConstructor<R, A> | TFunctionNoNew<R, A>;

package/src/util/types/TFunctionNoNew.d.ts

@@ -0,0 +1,2 @@
+import { Any } from './Any';
+export type TFunctionNoNew<R = Any, A extends Any[] = Any[]> = (...args: A) => R;

package/src/util/types/TPlainObject.d.ts

@@ -0,0 +1,2 @@
+import { ObjectKey } from './ObjectKey';
+export type TPlainObject<K extends ObjectKey = ObjectKey, V = any> = Record<K, V>;

package/src/util/types/TPrimitive.d.ts

@@ -0,0 +1 @@
+export type TPrimitive = null | undefined | bigint | boolean | number | string | symbol;

package/src/util/types/TValidator.d.ts

@@ -0,0 +1 @@
+export type TValidator<T> = (value: T) => boolean;

package/src/{validators → util/validation}/createTypedArrayValidator.d.ts

@@ -1,5 +1,3 @@
-import { JsonValue } from '@bemoje/util';
-import { TValidator } from '../types/TValidator';
 /**
  * Creates a validator function that checks whether the input is an array where all elements are valid according to every validator provided.
  *
@@ -8,4 +6,4 @@ import { TValidator } from '../types/TValidator';
  *
  * @throws TypeError - if no name is provided and not all validators are named functions.
  */
-export declare function createTypedArrayValidator<O extends JsonValue = JsonValue>(validators: TValidator<O>[], name?: string): (array: unknown) => boolean;
+export declare function createTypedArrayValidator<O>(validators: ((value: O) => boolean)[], name?: string): (array: unknown) => boolean;

package/src/util/validation/ensureThat.d.ts

@@ -0,0 +1,6 @@
+import { Any } from '../types/Any';
+import { TConstructor } from '../types/TConstructor';
+export declare function ensureThat<T>(value: T, validator: ((value: T, ...args: any[]) => boolean | string) | ((value: T, ...args: any[]) => boolean), options?: {
+    Err?: TConstructor;
+    args?: Any[];
+}): T;

package/src/util/validation/isFunction.d.ts

@@ -0,0 +1,11 @@
+import { TFunction } from '../types/TFunction';
+/**
+ * Checks if the given value is a function.
+ *
+ * @example ```ts
+ * isFunction(class {}); //=> true
+ * isFunction(function () {}); //=> true
+ * isFunction(() => {}); //=> true
+ * ```
+ */
+export declare function isFunction(value: unknown): value is TFunction;

package/src/{validators → util/validation}/isNamedFunction.d.ts

@@ -1,4 +1,4 @@
-import { TFunction } from '@bemoje/util';
+import { TFunction } from '../types/TFunction';
 /**
  * Checks if the provided value is a named function.
  */

package/src/util/validation/isObject.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Checks if the provided value is an object (null, arrays and functions not included).
+ * @template T - The type of the value to check.
+ * @param value The value to check.
+ * @returns A boolean indicating whether the provided value is an object.
+ * @example ```ts
+ * isObject({});;
+ * //=> true
+ * isObject([1]);;
+ * //=> false
+ * isObject(123);;
+ * //=> false
+ * ```
+ */
+export declare function isObject(value: unknown): boolean;

package/src/util/validation/isPlainObject.d.ts

@@ -0,0 +1,6 @@
+import { ObjectKey } from '../types/ObjectKey';
+import { TPlainObject } from '../types/TPlainObject';
+/**
+ * Checks if the provided value is a plain object, i.e. an object created by the native base `Object` constructor.
+ */
+export declare function isPlainObject<K extends ObjectKey = ObjectKey, V = unknown>(value: unknown): value is TPlainObject<K, V>;

package/src/util/validation/isPrimitive.d.ts

@@ -0,0 +1,12 @@
+import { TPrimitive } from '../types/TPrimitive';
+/**
+ * Checks if the provided value is a primitive type (null, undefined, bigint, boolean, number, string or symbol).
+ * @param value The value to check.
+ * @returns A boolean indicating whether the provided value is a primitive type.
+ * @example
+ * isPrimitive(123);
+ * //=> true
+ * isPrimitive({});
+ * //=> false
+ */
+export declare function isPrimitive(value: unknown): value is TPrimitive;

package/src/util/validation/numbers/isInteger.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Checks if the provided number is an integer.
+ * @remarks This function uses the built-in `Number.isInteger` method.
+ * @param int The number to check.
+ * @returns A boolean indicating whether the provided number is an integer.
+ * @example ```ts
+ * isInteger(5);
+ * //=> true
+ * isInteger(5.5);
+ * //=> false
+ * ```
+ */
+export declare const isInteger: (number: unknown) => boolean;

package/src/util/validation/numbers/isValidNumber.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Checks if the provided value is a valid number.
+ * @remarks This function checks if the provided value is a finite number and not NaN.
+ * @param number The value to check.
+ * @returns A boolean indicating whether the provided value is a valid number.
+ * @example ```ts
+ * isValidNumber(123);
+ * //=> true
+ * isValidNumber(NaN);
+ * //=> false
+ * isValidNumber(Infinity);
+ * //=> false
+ * ```
+ */
+export declare function isValidNumber(number: number): boolean;

package/src/core/CommandBuilder/Base.d.ts

@@ -1,5 +0,0 @@
-export declare class Base {
-    static nextIndex: Record<string, number>;
-    id: number;
-    constructor();
-}

package/src/core/CommandBuilder/CommandBuilder.d.ts

@@ -1,80 +0,0 @@
-import { Any, JsonValue } from '@bemoje/util';
-import { ArgumentBuilder } from './ArgumentBuilder';
-import { Base } from './Base';
-import { Command, CommanderError, ErrorOptions } from 'commander';
-import { CommandBuilderMetaData } from './CommandBuilderMetaData';
-import { CommandFeatureSelector } from './CommandFeatureSelector';
-import { IConfigDefinePropertyOptions } from '../../types/IDefinePropertyOptions';
-import { IPresetPartial } from '../../types/IPreset';
-import { JsonFile } from '../db/JsonFile';
-import { OptionBuilder } from './OptionBuilder';
-/**
- * Wrapper around the @see Command class, for more intuitive construction.
- */
-export declare class CommandBuilder extends Base {
-    static dataDirectory: string;
-    readonly $: Command;
-    readonly parent: CommandBuilder | null;
-    readonly meta: CommandBuilderMetaData;
-    readonly get: CommandReader;
-    readonly features: CommandFeatureSelector;
-    constructor(name: string, callback?: (cmd: CommandBuilder) => void, parent?: CommandBuilder | null);
-    get db(): JsonFile;
-    get name(): string;
-    version(string: string): this;
-    alias(alias: string): this;
-    aliases(...aliases: string[]): this;
-    get isRoot(): boolean;
-    get arguments(): readonly import("commander").Argument[];
-    get options(): readonly import("commander").Option[];
-    enableBuiltinOptions(options?: {
-        help?: true;
-        debug?: true;
-        disableColor?: true;
-        disableStderr?: true;
-        disableStdout?: true;
-    }): void;
-    outputHelp(): void;
-    /**
-     * Display error message and exit (or call exitOverride).
-     */
-    outputUserError(message: string, options?: ErrorOptions): void;
-    description(...lines: string[]): this;
-    allowExcessArguments(bool?: boolean): this;
-    allowUnknownOption(bool?: boolean): this;
-    /**
-     * Register callback to use as replacement for calling process.exit.
-     */
-    exitOverride(callback?: (err: CommanderError) => never | void): this;
-    get root(): CommandBuilder;
-    /**
-     * Display error message and exit (or call exitOverride).
-     */
-    outputDebugInfo(event: string, getProps?: () => Record<string, unknown>): void;
-    hideGlobalOptions(...names: string[]): this;
-    unhideGlobalOptions(...names: string[]): this;
-    argument(name: string, description?: string): this;
-    argument(name: string, cb: (opt: ArgumentBuilder, cmd: this) => void): this;
-    option(flags: string, description?: string): this;
-    option(flags: string, cb?: (opt: OptionBuilder, cmd: this) => void): this;
-    globalOption(flags: string, description?: string): this;
-    globalOption(flags: string, cb?: (opt: OptionBuilder, cmd: this) => void): this;
-    command(name: string, cb: (cmd: CommandBuilder) => void): this;
-    nativeCommand(name: string, cb: (cmd: CommandBuilder) => void): this;
-    action<T extends (...args: Any[]) => Promise<void>>(fn: T): this;
-    config(key: string, entry: IConfigDefinePropertyOptions<JsonValue>): this;
-    preset(name: string, preset: IPresetPartial): this;
-    createMain(): (argv?: string[]) => Promise<void>;
-}
-export declare function CLI(name: string, callback: (cmd: CommandBuilder) => void): CommandBuilder;
-export declare class CommandReader extends Base {
-    protected readonly cmd: CommandBuilder;
-    constructor(cmd: CommandBuilder);
-    get action(): ((...args: any[]) => Promise<void>) | undefined;
-    get description(): string;
-    get summary(): string;
-    get version(): string | undefined;
-    get alias(): string;
-    get aliases(): string[];
-    get renderHelp(): string;
-}

package/src/core/CommandBuilder/CommandBuilder.example.d.ts

@@ -1 +0,0 @@
-export {};

package/src/core/CommandBuilder/CommandBuilderMetaData.d.ts

@@ -1,17 +0,0 @@
-import { Any } from '@bemoje/util';
-import { Base } from './Base';
-import { CommandBuilder } from './CommandBuilder';
-import { Option } from 'commander';
-import { TStringParser } from '../../types/TStringParser';
-import { TValidator } from '../../types/TValidator';
-export declare class CommandBuilderMetaData extends Base {
-    subcommands: CommandBuilder[];
-    globalOptions: Option[];
-    hiddenGlobalOptions: Set<Option>;
-    isNative: boolean;
-    actionHandler?: (...args: Any[]) => Promise<void>;
-    get argParsers(): TStringParser<Any>[];
-    get argValidators(): TValidator<Any>[][];
-    get optParsers(): Record<string, TStringParser<Any>>;
-    get optValidators(): Record<string, TValidator<Any>[]>;
-}