@bemoje/cli 0.0.2

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@bemoje/cli",
+  "version": "0.0.2",
+  "dependencies": {
+    "@bemoje/util": "latest",
+    "cli-table": "^0.3.11",
+    "commander": "^11.1.0",
+    "lookpath": "^1.2.2"
+  },
+  "type": "commonjs",
+  "main": "./index.cjs.js",
+  "module": "./index.esm.js",
+  "author": {
+    "name": "Benjamin Møller Jensen",
+    "email": "bemoje@bemoje.net",
+    "url": "https://github.com/bemoje/"
+  },
+  "license": "MIT",
+  "keywords": [],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bemoje/tsmono.git"
+  },
+  "funding": {
+    "type": "patreon",
+    "url": "https://www.patreon.com/user?u=40752770"
+  },
+  "bugs": {
+    "url": "https://github.com/bemoje/tsmono/issues"
+  },
+  "homepage": "https://github.com/bemoje/tsmono",
+  "devDependencies": {
+    "@types/cli-table": "^0.3.4",
+    "@types/prompts": "^2.4.9"
+  }
+}

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

@@ -0,0 +1,21 @@
+import { Argument } from 'commander';
+import { ArgumentParserSelector } from '../../parsers/selector/ArgumentParserSelector';
+import { ArgumentReader } from './ArgumentReader';
+import { ArgumentValidatorSelector } from '../../validators/selector/ArgumentValidatorSelector';
+import { Base } from './Base';
+import { CommandBuilder } from './CommandBuilder';
+/**
+ * Wrapper around the @see Argument class, for more intuitive construction.
+ */
+export declare class ArgumentBuilder extends Base {
+    readonly cmd: CommandBuilder;
+    readonly $: Argument;
+    readonly index: number;
+    constructor(cmd: CommandBuilder, name: string);
+    description(string: string): this;
+    default(value: unknown, description?: string): this;
+    choices(values: readonly string[]): this;
+    get parser(): ArgumentParserSelector;
+    get validator(): ArgumentValidatorSelector;
+    get get(): ArgumentReader;
+}

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

@@ -0,0 +1,15 @@
+import { ArgumentBuilder } from './ArgumentBuilder';
+import { Base } from './Base';
+export declare class ArgumentReader extends Base {
+    protected readonly parent: ArgumentBuilder;
+    constructor(parent: ArgumentBuilder);
+    get $(): import("commander").Argument;
+    get argument(): import("commander").Argument;
+    get name(): string;
+    get choices(): string[] | undefined;
+    get default(): any;
+    get description(): string;
+    get variadic(): boolean;
+    get required(): boolean;
+    get optional(): boolean;
+}

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

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

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

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

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

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

@@ -0,0 +1,17 @@
+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>[]>;
+}

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

@@ -0,0 +1,26 @@
+import { Base } from './Base';
+import { CommandBuilder } from './CommandBuilder';
+/**
+ *
+ */
+export declare class CommandFeatureSelector extends Base {
+    protected readonly cmd: CommandBuilder;
+    protected _utils: boolean;
+    protected _config: boolean;
+    protected _presets: boolean;
+    protected _autoAssignMissingOptionFlags: boolean;
+    protected _autoAssignSubCommandAliases: boolean;
+    constructor(cmd: CommandBuilder);
+    protected debugToggle(info: Record<string, boolean>): void;
+    utils(boolean?: boolean): this;
+    config(boolean?: boolean): this;
+    presets(boolean?: boolean): this;
+    autoAssignMissingOptionFlags(boolean?: boolean): this;
+    autoAssignSubCommandAliases(boolean?: boolean): this;
+    all(boolean?: boolean): CommandBuilder;
+    get isUtilsEnabled(): boolean;
+    get isConfigEnabled(): boolean;
+    get isPresetsEnabled(): boolean;
+    get isAutoAssignMissingOptionFlagsEnabled(): boolean;
+    get isAutoAssignSubCommandAliasesEnabled(): boolean;
+}

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

@@ -0,0 +1,15 @@
+export declare class ErrorParser {
+    readonly error: Error;
+    constructor(error: unknown);
+    get name(): string;
+    get message(): string;
+    get stack(): string;
+    summary(): string;
+    parseStackFrames(): [string, string][];
+    prettyStack(parsedStackFrames?: [string, string][]): string;
+    toObject(): any;
+    toJSON(): any;
+}
+export declare function errPrettyStack(error: Error, parsedStackFrames?: [string, string][]): string;
+export declare function errParseStack(stack: string): [string, string][];
+export declare function errToObject(error: Error): any;

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

@@ -0,0 +1,27 @@
+import { Base } from './Base';
+import { CommandBuilder } from './CommandBuilder';
+import { Option, OptionValues } from 'commander';
+import { OptionArgumentParserSelector } from '../../parsers/selector/OptionArgumentParserSelector';
+import { OptionArgumentValidatorSelector } from '../../validators/selector/OptionArgumentValidatorSelector';
+import { OptionReader } from './OptionReader';
+/**
+ * Wrapper around the @see Option class, for more intuitive construction.
+ * @remarks Options are one of boolean, negated, required argument, or optional argument.
+ */
+export declare class OptionBuilder extends Base {
+    readonly cmd: CommandBuilder;
+    readonly $: Option;
+    constructor(cmd: CommandBuilder, flags: string);
+    description(string: string): this;
+    hideHelp(hide?: boolean): this;
+    hidden(hidden?: boolean): this;
+    default(value: unknown, description?: string): this;
+    choices(values: readonly string[]): this;
+    conflicts(names: string | string[]): this;
+    implies(optionValues: OptionValues): this;
+    env(name: string): this;
+    short(short: string): this;
+    get parser(): OptionArgumentParserSelector;
+    get validator(): OptionArgumentValidatorSelector;
+    get get(): OptionReader;
+}

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

@@ -0,0 +1,24 @@
+import { Base } from './Base';
+import { OptionBuilder } from './OptionBuilder';
+export declare class OptionReader extends Base {
+    protected readonly parent: OptionBuilder;
+    constructor(parent: OptionBuilder);
+    get $(): import("commander").Option;
+    get option(): import("commander").Option;
+    get description(): string;
+    get optional(): boolean;
+    get mandatory(): boolean;
+    get hidden(): boolean;
+    get variadic(): boolean;
+    get short(): string | undefined;
+    get long(): string | undefined;
+    get default(): any;
+    get choices(): string[] | undefined;
+    get env(): string | undefined;
+    get flags(): string;
+    get name(): string;
+    get attributeName(): string;
+    get fullDescription(): string;
+    get defaultValueDescription(): string | undefined;
+    get hasArgument(): boolean;
+}

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

@@ -0,0 +1,47 @@
+import { Any } from '@bemoje/util';
+import { MethodDisabler } from '../util/MethodDisabler';
+/**
+ *
+ */
+export declare class OutputManager {
+    private static instance;
+    static getInstance(): OutputManager;
+    readonly colors: {
+        enable: () => void;
+        disable: () => void;
+        reset: (this: any, txt: string) => any;
+        bold: (this: any, txt: string) => any;
+        dim: (this: any, txt: string) => any;
+        italic: (this: any, txt: string) => any;
+        underline: (this: any, txt: string) => any;
+        inverse: (this: any, txt: string) => any;
+        hidden: (this: any, txt: string) => any;
+        strikethrough: (this: any, txt: string) => any;
+        black: (this: any, txt: string) => any;
+        red: (this: any, txt: string) => any;
+        green: (this: any, txt: string) => any;
+        yellow: (this: any, txt: string) => any;
+        blue: (this: any, txt: string) => any;
+        magenta: (this: any, txt: string) => any;
+        cyan: (this: any, txt: string) => any;
+        white: (this: any, txt: string) => any;
+        gray: (this: any, txt: string) => any;
+        grey: (this: any, txt: string) => any;
+        bgBlack: (this: any, txt: string) => any;
+        bgRed: (this: any, txt: string) => any;
+        bgGreen: (this: any, txt: string) => any;
+        bgYellow: (this: any, txt: string) => any;
+        bgBlue: (this: any, txt: string) => any;
+        bgMagenta: (this: any, txt: string) => any;
+        bgCyan: (this: any, txt: string) => any;
+        bgWhite: (this: any, txt: string) => any;
+    };
+    readonly stdout: MethodDisabler;
+    readonly stderr: MethodDisabler;
+    readonly debug: MethodDisabler;
+    debugMsgs: (() => Any)[];
+    private constructor();
+    reset(): this;
+    outputDebug(fn: () => Any): void;
+    outputDebugMessages(): void;
+}

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

@@ -0,0 +1 @@
+export declare function assertCommandNameNotReserved(name: string): void;

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

@@ -0,0 +1,7 @@
+import { CommandBuilder } from './CommandBuilder';
+export declare function ensureBackRefToCommandBuilder(cmd: CommandBuilder): void;
+declare module 'commander' {
+    interface Command {
+        get builder(): CommandBuilder;
+    }
+}

package/src/core/CommandBuilder/features/action/actionWrapper.d.ts

@@ -0,0 +1,5 @@
+import { CommandBuilder } from '../../CommandBuilder';
+/**
+ *
+ */
+export declare function actionWrapper(cmd: CommandBuilder): void;

package/src/core/CommandBuilder/features/action/combineVariadicArgs.d.ts

@@ -0,0 +1,3 @@
+import { Any } from '@bemoje/util';
+import { CommandBuilder } from '../../CommandBuilder';
+export declare function combineVariadicArgs(cmd: CommandBuilder, result: Any[]): any[];

package/src/core/CommandBuilder/features/action/debugLogArgsOpts.d.ts

@@ -0,0 +1,4 @@
+import { Any } from '@bemoje/util';
+import { CommandBuilder } from '../../CommandBuilder';
+import { OptionValues } from 'commander';
+export declare function debugLogArgsOpts(cb: CommandBuilder, args: Any[], opts: OptionValues, presetArgs: string[][], presetOpts: OptionValues[], presetOrder: string[]): void;

package/src/core/CommandBuilder/features/action/deleteOptionsWithDefaultOrNoValue.d.ts

@@ -0,0 +1,3 @@
+import { CommandBuilder } from '../../CommandBuilder';
+import { OptionValues } from 'commander';
+export declare function deleteOptionsWithDefaultOrNoValue(cmd: CommandBuilder, opts: OptionValues): OptionValues;

package/src/core/CommandBuilder/features/action/getPresetArgsAndOpts.d.ts

@@ -0,0 +1,3 @@
+import { CommandBuilder } from '../../CommandBuilder';
+import { OptionValues } from 'commander';
+export declare function getPresetArgsAndOpts(cmd: CommandBuilder): [presetArgs: string[][], presetOpts: OptionValues[], presetOrder: string[]];

package/src/core/CommandBuilder/features/action/handleError.d.ts

@@ -0,0 +1,2 @@
+import { CommandBuilder } from '../../CommandBuilder';
+export declare function handleError(cmd: CommandBuilder, error: unknown): void;

package/src/core/CommandBuilder/features/action/handleOutputOptions.d.ts

@@ -0,0 +1,2 @@
+import { CommandBuilder } from '../../CommandBuilder';
+export declare function handleOutputOptions(cmd: CommandBuilder): void;

package/src/core/CommandBuilder/features/action/optsWithGlobalsParsed.d.ts

@@ -0,0 +1,2 @@
+import { CommandBuilder } from '../../CommandBuilder';
+export declare function optsWithGlobalsParsed(cmd: CommandBuilder): import("commander").OptionValues;

package/src/core/CommandBuilder/features/action/padArgsWithUndefinedUntilExpectedLength.d.ts

@@ -0,0 +1,3 @@
+import { Any } from '@bemoje/util';
+import { CommandBuilder } from '../../CommandBuilder';
+export declare function padArgsWithUndefinedUntilExpectedLength(cmd: CommandBuilder, args: Any[]): any[];

package/src/core/CommandBuilder/features/action/parseArguments.d.ts

@@ -0,0 +1,2 @@
+import { CommandBuilder } from '../../CommandBuilder';
+export declare function parseArguments(cmd: CommandBuilder, args: string[]): any[];

package/src/core/CommandBuilder/features/action/parseOptions.d.ts

@@ -0,0 +1,6 @@
+import { CommandBuilder } from '../../CommandBuilder';
+import { OptionValues } from 'commander';
+/**
+ * Parses (and validates) options using the parsers defined in the command builder.
+ */
+export declare function parseOptions(cmd: CommandBuilder, opts: OptionValues): OptionValues;

package/src/core/CommandBuilder/features/action/parsedValidArgsOptsWithPresets.d.ts

@@ -0,0 +1,2 @@
+import { CommandBuilder } from '../../CommandBuilder';
+export declare function parsedValidArgsOptsWithPresets(cmd: CommandBuilder): any[];

package/src/core/CommandBuilder/features/action/parsedValidArgsWithPresets.d.ts

@@ -0,0 +1,2 @@
+import { CommandBuilder } from '../../CommandBuilder';
+export declare function parsedValidArgsWithPresets<T>(cmd: CommandBuilder, presetArgs: T[][]): any[];

package/src/core/CommandBuilder/features/action/parsedValidOptsWithPresets.d.ts

@@ -0,0 +1,3 @@
+import { CommandBuilder } from '../../CommandBuilder';
+import { OptionValues } from 'commander';
+export declare function parsedValidOptsWithPresets(cb: CommandBuilder, presetOpts: OptionValues[]): any;

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

@@ -0,0 +1,3 @@
+import { CommandBuilder } from '../CommandBuilder';
+export declare function addConfigCommands(cmd: CommandBuilder): void;
+export declare const createConfig: (config: CommandBuilder) => void;

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

@@ -0,0 +1,3 @@
+import { CommandBuilder } from '../CommandBuilder';
+export declare function addPresetsCommands(cmd: CommandBuilder): void;
+export declare const createPresets: (presets: CommandBuilder) => void;

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

@@ -0,0 +1,2 @@
+import { CommandBuilder } from '../CommandBuilder';
+export declare function addUtilCommands(cmd: CommandBuilder): void;

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

@@ -0,0 +1,2 @@
+import { CommandBuilder } from '../CommandBuilder';
+export declare function assertNoDuplicateCommandNames(cmd: CommandBuilder): void;

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

@@ -0,0 +1,2 @@
+import { CommandBuilder } from '../CommandBuilder';
+export declare function assertNoDuplicateOptionNames(cmd: CommandBuilder): void;

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

@@ -0,0 +1,14 @@
+import { CommandBuilder } from '../CommandBuilder';
+/**
+ * Automatically set 'short' and 'long' names to options that don't have one assigned yet.
+ *
+ * First, it tries to assign a short name based on the first letter of the option's attribute name
+ * Both lower and upper case are tried. If these is not available, the next letter of the option name is tried.
+ *
+ * If none of the letters of the option name are available, the option is skipped until all other
+ * options have had letters from their names attempted assigned.
+ * Those that remain are assigned the first available letter of the alphabet + 0-9.
+ * If there are 64 options for the command and no more alphanumeric characters are available,
+ * the option is not assigned a short name.
+ */
+export declare function autoAssignMissingOptionFlags(cmd: CommandBuilder): void;

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

@@ -0,0 +1,13 @@
+import { CommandBuilder } from '../CommandBuilder';
+/**
+ * Makes aliases for the command.
+ * The idea is to be able to navigate the command tree by only typing the first letter(s) of the command names.
+ *
+ * Example: A command 'cola' would get these aliases: ['c', 'co', 'col'].
+ * However, if there are namespace clashes with sibling subcommands that start with the same letter,
+ * eg. like 'cola' and 'coal' where the first two letters clash, cola's aliases are reduced to only ['col'] and similarly for 'coal'.
+ *
+ * This method creates the aliases, ensuring there are no clashes with sublings, why it is important that the
+ * entire command tree is built before invoking this method.
+ */
+export declare function autoAssignSubCommandAliases(cmd: CommandBuilder): void;

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

@@ -0,0 +1 @@
+export declare function formatTableForTerminal(rows: string[][], headers?: string[]): string;

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

@@ -0,0 +1,2 @@
+import { CommandBuilder } from '../CommandBuilder';
+export declare function getClosestNonNativeParent(cmd: CommandBuilder): CommandBuilder;

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

@@ -0,0 +1,3 @@
+import { CommandBuilder } from './CommandBuilder';
+import { Option } from 'commander';
+export declare function getGlobalOptions(cmd: CommandBuilder): Option[];

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

@@ -0,0 +1,3 @@
+import { CommandBuilder } from './CommandBuilder';
+import { Option } from 'commander';
+export declare function getOwnAndGlobalOptions(cmd: CommandBuilder): Option[];

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

@@ -0,0 +1,2 @@
+import { CommandBuilder } from './CommandBuilder';
+export declare function initializeCommand(cmd: CommandBuilder, callback?: (cmd: CommandBuilder) => void): CommandBuilder;

package/src/core/db/AbstractJsonFileSection.d.ts

@@ -0,0 +1,45 @@
+import { Any, JsonValue } from '@bemoje/util';
+import { Base } from '../CommandBuilder/Base';
+import { JsonFile } from './JsonFile';
+/**
+ * A class that represents the a section of the JSON file used as simple database.
+ */
+export declare abstract class AbstractJsonFileSection<Val = JsonValue> extends Base {
+    protected readonly file: JsonFile;
+    protected readonly name: string;
+    protected readonly hasFixedKeysForUser: boolean;
+    protected isInitialized: boolean;
+    protected isInitializing: boolean;
+    protected readonly _defaultValues: Record<string, Val>;
+    /**
+     * @param file The parent JsonFile instance.
+     * @param name The name of the section.
+     */
+    constructor(file: JsonFile, name: string, hasFixedKeysForUser: boolean);
+    abstract assertValid(key: string, value: Val): void;
+    abstract defineProperty(key: string, options: Any): void;
+    abstract initialize(save?: boolean): void | string;
+    get defaultValues(): Record<string, Val>;
+    /**
+     * Get the db lookup prefix for this section.
+     * @param key An optional key to append to the prefix.
+     */
+    protected prefix(key?: string): string;
+    get<T extends Val = Val>(key: string): T;
+    getAll(): typeof this.defaultValues;
+    count(): number;
+    set(key: string, value: Val, save?: boolean): void;
+    setAll(values: typeof this.defaultValues, save?: boolean): void;
+    reset(key: string, save?: boolean): void;
+    resetAll(save?: boolean): void;
+    /**
+     * Actions:
+     * - save the database to disk
+     * - verify that the JSON file is valid JSON data
+     * - format as human readable with 2 indents
+     */
+    protected save(): void;
+    delete(key: string, save?: boolean): void;
+    deleteAll(save?: boolean): void;
+    edit(editor?: string): void;
+}

package/src/core/db/ConfigSection.d.ts

@@ -0,0 +1,19 @@
+import { AbstractJsonFileSection } from './AbstractJsonFileSection';
+import { JsonValue } from '@bemoje/util';
+import { IConfigDefinePropertyOptions } from '../../types/IDefinePropertyOptions';
+import { JsonFile } from './JsonFile';
+import { TStringParser } from '../../types/TStringParser';
+import { TValidator } from '../../types/TValidator';
+/**
+ * A class that represents the user-config section of the JSON file used as simple database.
+ */
+export declare class ConfigSection<Val extends JsonValue = JsonValue> extends AbstractJsonFileSection<Val> {
+    readonly descriptions: Record<string, string>;
+    readonly validators: Record<string, TValidator<Val>>;
+    readonly parsers: Record<string, TStringParser<Val>>;
+    constructor(file: JsonFile, name: string, hasFixedKeysForUser?: boolean);
+    assertValid(key: string, value: Val): void;
+    defineProperty(key: string, options: IConfigDefinePropertyOptions<Val>): void;
+    initialize(save?: boolean): void;
+    get keys(): string[];
+}

package/src/core/db/JsonDB.d.ts

@@ -0,0 +1,19 @@
+import { JsonObject, JsonValue } from '@bemoje/util';
+import { Base } from '../CommandBuilder/Base';
+import { JsonFile } from './JsonFile';
+export declare class JsonDB extends Base {
+    protected readonly file: JsonFile;
+    protected data: JsonObject;
+    readonly save: () => void;
+    /**
+     * @param filepath The path to the JSON file.
+     */
+    constructor(file: JsonFile);
+    get filepath(): string;
+    set(prefix?: string, value?: JsonValue, save?: boolean): void;
+    get<T = JsonValue>(prefix?: string): T;
+    getSafe<T = JsonValue>(prefix?: string): T | undefined;
+    has(prefix?: string): boolean;
+    delete(prefix?: string, save?: boolean): void;
+    protected cloneDeep(obj: JsonValue): any;
+}

package/src/core/db/JsonFile.d.ts

@@ -0,0 +1,25 @@
+import { Base } from '../CommandBuilder/Base';
+import { CommandBuilder } from '../CommandBuilder/CommandBuilder';
+import { ConfigSection } from './ConfigSection';
+import { JsonDB } from './JsonDB';
+import { PresetsSection } from './PresetsSection';
+/**
+ * A class that represents the JSON file used as a simple database.
+ */
+export declare class JsonFile extends Base {
+    readonly cmd: CommandBuilder;
+    db: JsonDB;
+    /**
+     * @param cmd The parent CommandBuilder instance.
+     */
+    constructor(cmd: CommandBuilder);
+    /**
+     * A lazy-loaded instance of the `config` section of the JSON file.
+     * Upon first property access, it is stored as a property on the instance.
+     */
+    get config(): ConfigSection<import("dist/packages/util/src").JsonValue>;
+    /**
+     * A lazy-loaded instance of the `presets` section of the JSON file.
+     */
+    get presets(): PresetsSection;
+}

package/src/core/db/JsonFileError.d.ts

@@ -0,0 +1,6 @@
+import { XtError } from '@bemoje/util';
+/**
+ * An error class for errors related to the JSON file used as simple database.
+ */
+export declare class JsonFileError extends XtError {
+}

package/src/core/db/PresetsSection.d.ts

@@ -0,0 +1,14 @@
+import { AbstractJsonFileSection } from './AbstractJsonFileSection';
+import { IPreset } from '../../types/IPreset';
+import { JsonFile } from './JsonFile';
+/**
+ * A class that represents the user-presets section of the JSON file used as simple database.
+ */
+export declare class PresetsSection extends AbstractJsonFileSection<IPreset> {
+    constructor(file: JsonFile, name: string, hasFixedKeysForUser?: boolean);
+    assertValid(key: string, value: IPreset): void;
+    defineProperty(key: string, options: IPreset): void;
+    initialize(save?: boolean): void;
+    delete(name: string, save?: boolean): void;
+    setAll(presets: typeof this.defaultValues, save?: boolean): Promise<void>;
+}

package/src/core/help/configureHelp.d.ts

@@ -0,0 +1,2 @@
+import { CommandBuilder } from '../CommandBuilder/CommandBuilder';
+export declare function configureHelp(cmd: CommandBuilder): void;