@bemoje/cli 0.0.2 → 0.0.3

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@bemoje/cli",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "dependencies": {
-    "@bemoje/util": "latest",
+    "ansi-colors": "^4.1.3",
     "cli-table": "^0.3.11",
     "commander": "^11.1.0",
-    "lookpath": "^1.2.2"
+    "fs-extra": "^11.2.0",
+    "is-async-function": "^2.0.0"
   },
   "type": "commonjs",
   "main": "./index.cjs.js",
@@ -31,6 +32,7 @@
   "homepage": "https://github.com/bemoje/tsmono",
   "devDependencies": {
     "@types/cli-table": "^0.3.4",
+    "@types/is-async-function": "^2.0.2",
     "@types/prompts": "^2.4.9"
   }
 }

package/src/{core/CommandBuilder → arg}/ArgumentBuilder.d.ts

@@ -1,13 +1,12 @@
 import { Argument } from 'commander';
-import { ArgumentParserSelector } from '../../parsers/selector/ArgumentParserSelector';
+import { ArgumentParserSelector } from './ArgumentParserSelector';
 import { ArgumentReader } from './ArgumentReader';
-import { ArgumentValidatorSelector } from '../../validators/selector/ArgumentValidatorSelector';
-import { Base } from './Base';
-import { CommandBuilder } from './CommandBuilder';
+import { ArgumentValidatorSelector } from './ArgumentValidatorSelector';
+import { CommandBuilder } from '../cmd/CommandBuilder';
 /**
- * Wrapper around the @see Argument class, for more intuitive construction.
+ * Wrapper around the @see Argument class from 'commander'.
  */
-export declare class ArgumentBuilder extends Base {
+export declare class ArgumentBuilder {
     readonly cmd: CommandBuilder;
     readonly $: Argument;
     readonly index: number;

package/src/arg/ArgumentParserSelector.d.ts

@@ -0,0 +1,8 @@
+import { ArgumentBuilder } from './ArgumentBuilder';
+import { JsonValue } from '../util/types/JsonValue';
+import { ParserSelector } from '../core/ParserSelector';
+import { TStringParser } from '../util/types/TStringParser';
+export declare class ArgumentParserSelector extends ParserSelector<ArgumentBuilder> {
+    constructor(builder: ArgumentBuilder);
+    custom<T extends JsonValue>(parser: TStringParser<T>): ArgumentBuilder;
+}

package/src/{core/CommandBuilder → arg}/ArgumentReader.d.ts

@@ -1,6 +1,5 @@
 import { ArgumentBuilder } from './ArgumentBuilder';
-import { Base } from './Base';
-export declare class ArgumentReader extends Base {
+export declare class ArgumentReader {
     protected readonly parent: ArgumentBuilder;
     constructor(parent: ArgumentBuilder);
     get $(): import("commander").Argument;

package/src/arg/ArgumentValidatorSelector.d.ts

@@ -0,0 +1,7 @@
+import { ArgumentBuilder } from './ArgumentBuilder';
+import { TValidator } from '../util/types/TValidator';
+import { ValidatorSelector } from '../core/ValidatorSelector';
+export declare class ArgumentValidatorSelector extends ValidatorSelector<ArgumentBuilder> {
+    constructor(builder: ArgumentBuilder);
+    custom<O>(validator: TValidator<O>): ArgumentBuilder;
+}

package/src/cmd/CLI.d.ts

@@ -0,0 +1,2 @@
+import { CommandBuilder } from './CommandBuilder';
+export declare function CLI(name: string, callback: (this: CommandBuilder, cmd: CommandBuilder) => void): () => import("commander").Command;

package/src/cmd/CommandBuilder.d.ts

@@ -0,0 +1,238 @@
+import { AddHelpTextPosition, Argument, Command, CommanderError, ErrorOptions, HelpConfiguration, HookEvent, Option, OptionValues, OptionValueSource } from 'commander';
+import { Any } from '../util/types/Any';
+import { ArgumentBuilder } from '../arg/ArgumentBuilder';
+import { CommandBuilderMetaData } from './CommandBuilderMetaData';
+import { CommandFeatureSelector } from './CommandFeatureSelector';
+import { IConfig } from '../types/IConfig';
+import { IPreset, IPresetPartial } from '../types/IPreset';
+import { JsonFile } from '../db/JsonFile';
+import { JsonValue } from '../util/types/JsonValue';
+import { OptionBuilder } from '../opt/OptionBuilder';
+export * from 'commander';
+/**
+ * Wrapper around the @see Command class, for more intuitive construction.
+ */
+export declare class CommandBuilder {
+    static dataDirectory: string;
+    protected readonly features: CommandFeatureSelector;
+    readonly parent: CommandBuilder | null;
+    readonly $: Command;
+    readonly meta: CommandBuilderMetaData;
+    get db(): JsonFile;
+    constructor(name: string, callback?: (this: CommandBuilder, cmd: CommandBuilder) => void, parent?: CommandBuilder, isNative?: boolean);
+    setRecommended(): void;
+    deleteDataFile(): void;
+    version(string: string): this;
+    description(...lines: string[]): this;
+    alias(alias: string): this;
+    aliases(...aliases: string[]): this;
+    enableBuiltinOptions(options?: {
+        debug?: boolean;
+        disableColor?: boolean;
+        disableStderr?: boolean;
+        disableStdout?: boolean;
+    }): 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: (this: CommandBuilder, cmd: CommandBuilder) => void): this;
+    nativeCommand(name: string, cb: (this: CommandBuilder, cmd: CommandBuilder) => void): this;
+    action<T extends (...args: Any[]) => void | Promise<void>>(fn: T): this;
+    errorHandler(fn: (this: Command, error: unknown, cmd: CommandBuilder) => void): this;
+    appData(key: string, value: JsonValue): this;
+    config(key: string, entry: IConfig<JsonValue>): this;
+    preset(name: string, preset: IPresetPartial): this;
+    presetsEnabled(boolean?: boolean): this;
+    autoAssignMissingOptionFlags(boolean?: boolean): this;
+    autoAssignSubCommandAliases(boolean?: boolean): 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;
+    throwInsteadOfProcessExit(): void;
+    /**
+     * Add hook for life cycle event.
+     */
+    hook(event: HookEvent, listener: (thisCommand: Command, actionCommand: Command) => void | Promise<void>): this;
+    /**
+     * You can customise the help by overriding Help properties using configureHelp(),
+     * or with a subclass of Help by overriding createHelp().
+     */
+    configureHelp(configuration: HelpConfiguration): this;
+    /**
+     * Display the help or a custom message after an error occurs.
+     */
+    showHelpAfterError(displayHelp?: boolean | string): this;
+    /**
+     * Display suggestion of similar commands for unknown commands, or options for unknown options.
+     */
+    showSuggestionAfterError(displaySuggestion?: boolean): this;
+    /**
+     * Add additional text to be displayed with the built-in help.
+     *
+     * Position is 'before' or 'after' to affect just this command,
+     * and 'beforeAll' or 'afterAll' to affect this command and all its subcommands.
+     */
+    addHelpText(position: AddHelpTextPosition, text: string): this;
+    throwCommanderError(message: string, exitCode?: number, type?: string): never;
+    hideGlobalOptions(...names: string[]): this;
+    unhideGlobalOptions(...names: string[]): this;
+    /**
+     * Set the directory for searching for executable subcommands of this command.
+     */
+    executableDir(path: string): this;
+    /**
+     * Store option value.
+     */
+    setOptionValue(key: string, value: unknown): this;
+    /**
+     * Store option value and where the value came from.
+     */
+    setOptionValueWithSource(key: string, value: unknown, source: OptionValueSource): this;
+    setDataFilepath(filepath: string): void;
+    /**
+     * Display error message and exit (or call exitOverride).
+     */
+    outputError(message: string, options?: ErrorOptions): void;
+    /**
+     * Output help information for this command.
+     */
+    outputHelp(): void;
+    /**
+     * Display error message and exit (or call exitOverride).
+     */
+    outputDebugMessage(event: string, getProps?: () => Record<string, unknown>): void;
+    parseArguments(args: string[]): any[];
+    /**
+     * Parses (and validates) options using the parsers defined in the command builder.
+     */
+    parseOptions(opts: OptionValues): OptionValues;
+    /**
+     * Validate ALREADY PARSED args using the validators defined in the command builder.
+     */
+    assertValidArguments(parsedArgs: Any[]): any[];
+    /**
+     * Validate ALREADY PARSED options using the validators defined in the command builder.
+     */
+    assertValidOptions(parsedOptions: OptionValues): OptionValues;
+    assertValidPreset(key: string, preset: IPreset): void;
+    get name(): string;
+    /**
+     * Get the command at the root of the command tree.
+     */
+    get root(): CommandBuilder;
+    get isRoot(): boolean;
+    get arguments(): readonly Argument[];
+    get options(): readonly Option[];
+    get commander(): Command;
+    get hasGrandChildren(): boolean;
+    /**
+     * Returns whether a command's last argument is variadic.
+     */
+    get isLastArgVariadic(): boolean;
+    get dataFilepath(): string;
+    /**
+     * Get the executable search directory.
+     */
+    getExecutableDir(): string | null;
+    /**
+     * Retrieve option value.
+     */
+    getOptionValue(key: string): Any;
+    /**
+     * Get source of option value.
+     */
+    getOptionValueSource(key: string): OptionValueSource | undefined;
+    /**
+     * Get source of option value. See also .optsWithGlobals().
+     */
+    getOptionValueSourceWithGlobals(key: string): OptionValueSource | undefined;
+    getActionHandler(): (this: CommandBuilder, ...args: any[]) => void | Promise<void>;
+    getDescription(): string;
+    getSummary(): string;
+    getVersion(): string | undefined;
+    getAlias(): string;
+    getAliases(): string[];
+    /**
+     * Get a commands prefix array based on all its parent/ancestor commands.
+     */
+    getPrefixArray(): string[];
+    /**
+     * Get a commands prefix string based on all its parent/ancestor commands.
+     */
+    getPrefixString(): string;
+    getGlobalOptions(): Option[];
+    getOwnAndGlobalOptions(): Option[];
+    getChildrenIterator(options?: {
+        includeSelf?: boolean;
+    }): Generator<CommandBuilder>;
+    getChildren(options?: {
+        includeSelf?: boolean;
+    }): CommandBuilder[];
+    getAncestorsIterator(options?: {
+        includeSelf?: boolean;
+    }): Generator<CommandBuilder>;
+    /**
+     * Get a command's ancestors, optionally starting from the command itself.
+     */
+    getAncestors(options?: {
+        includeSelf?: boolean;
+    }): CommandBuilder[];
+    getSiblingsIterator(): Generator<CommandBuilder, void, unknown>;
+    /**
+     * Returns an array of sibling CommandBuilder objects.
+     */
+    getSiblings(): CommandBuilder[];
+    getClosestNonNativeParent(): CommandBuilder;
+    getRenderedHelp(): string;
+    getOptsWithGlobalsParsed(): OptionValues;
+    getParsedValidArgsOptsWithPresets(): [Any[], OptionValues];
+    getParsedValidArgsWithPresets<T>(presetArgs: T[][]): any[];
+    getParsedValidOptsWithPresets(presetOpts: OptionValues[]): OptionValues;
+    getPresetArgsAndOpts(): [presetArgs: string[][], presetOpts: OptionValues[], presetOrder: string[]];
+    protected combineVariadicArgs(result: Any[]): any[];
+    protected debugLogArgsOpts(args: Any[], opts: OptionValues, presetArgs: string[][], presetOpts: OptionValues[], presetOrder: string[]): void;
+    protected deleteOptionsWithDefaultOrNoValue(opts: OptionValues): OptionValues;
+    protected handleOutputOptions(): void;
+    protected padArgsWithUndefinedUntilExpectedLength(args: Any[]): any[];
+    protected assertPresetArgsOptional(args: Any[]): void;
+    protected addUtilCommands(): void;
+    /**
+     * 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.
+     */
+    protected assignSubCommandAliases(): this;
+    /**
+     * 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.
+     */
+    protected assignMissingOptionFlags(): void;
+    protected assertNoDuplicateCommandNames(): void;
+    protected hasIdenticalParentOption(option: Option): boolean;
+    protected assertNoDuplicateOptionNames(): void;
+    protected initializeActionWrapper(): void;
+    protected initializeHelp(): void;
+    protected inheritParentHiddenGlobals(): void;
+    protected assertCommandNameNotReserved(name: string): void;
+    protected assertNotInitialized(): void;
+}

package/src/cmd/CommandBuilderMetaData.d.ts

@@ -0,0 +1,23 @@
+import { Any } from '../util/types/Any';
+import { CommandBuilder } from './CommandBuilder';
+import { Option } from 'commander';
+import { TStringParser } from '../util/types/TStringParser';
+import { TValidator } from '../util/types/TValidator';
+export declare class CommandBuilderMetaData {
+    subcommands: CommandBuilder[];
+    globalOptions: Option[];
+    hiddenGlobalOptions: Set<Option>;
+    presetOptionKeys: string[];
+    argParsers: TStringParser<Any>[];
+    argValidators: TValidator<Any>[][];
+    optParsers: Record<string, TStringParser<Any>>;
+    optValidators: Record<string, TValidator<Any>[]>;
+    rawArgs: string[];
+    isNative: boolean;
+    isInitialized: boolean;
+    constructor();
+    get actionHandler(): (this: CommandBuilder, ...args: any[]) => void | Promise<void>;
+    get errorHandler(): (this: CommandBuilder, error: unknown, cmd: CommandBuilder) => void;
+    get hasCustomActionHandler(): boolean;
+    get hasCustomErrorHandler(): boolean;
+}

package/src/cmd/CommandFeatureSelector.d.ts

@@ -0,0 +1,79 @@
+import { CommandBuilder } from './CommandBuilder';
+/**
+ * Represents a selector for enabling or disabling command features.
+ */
+export declare class CommandFeatureSelector {
+    protected readonly cmd: CommandBuilder;
+    /**
+     * Indicates whether the app data feature is enabled.
+     */
+    isAppDataEnabled: boolean;
+    /**
+     * Indicates whether the config feature is enabled.
+     */
+    isConfigEnabled: boolean;
+    /**
+     * Indicates whether the presets feature is enabled.
+     */
+    isPresetsEnabled: boolean;
+    /**
+     * Indicates whether the auto assign missing option flags feature is enabled.
+     */
+    isAutoAssignMissingOptionFlagsEnabled: boolean;
+    /**
+     * Indicates whether the auto assign sub command aliases feature is enabled.
+     */
+    isAutoAssignSubCommandAliasesEnabled: boolean;
+    /**
+     * Creates a new instance of the CommandFeatureSelector class.
+     * @param cmd - The command builder instance.
+     */
+    constructor(cmd: CommandBuilder);
+    /**
+     * Inherits the feature settings from a parent CommandFeatureSelector instance.
+     * @param parentFeatures - The parent CommandFeatureSelector instance to inherit from.
+     */
+    inheritFrom(parentFeatures: CommandFeatureSelector): void;
+    /**
+     * Enables or disables the app data feature.
+     * @param boolean - Indicates whether the app data feature should be enabled or disabled.
+     * @returns The current CommandFeatureSelector instance.
+     * @throws Error if the command is native and the app data feature is being configured.
+     */
+    appData(boolean?: boolean): this;
+    /**
+     * Enables or disables the config feature.
+     * @param boolean - Indicates whether the config feature should be enabled or disabled.
+     * @returns The current CommandFeatureSelector instance.
+     * @throws Error if the command is native and the config feature is being configured.
+     */
+    config(boolean?: boolean): this;
+    /**
+     * Enables or disables the presets feature.
+     * @param boolean - Indicates whether the presets feature should be enabled or disabled.
+     * @returns The current CommandFeatureSelector instance.
+     * @throws Error if the command is native and the presets feature is being configured.
+     */
+    presets(boolean?: boolean): this;
+    /**
+     * Enables or disables the auto assign missing option flags feature.
+     * @param boolean - Indicates whether the auto assign missing option flags feature should be enabled or disabled.
+     * @returns The current CommandFeatureSelector instance.
+     */
+    autoAssignMissingOptionFlags(boolean?: boolean): this;
+    /**
+     * Enables or disables the auto assign sub command aliases feature.
+     * @param boolean - Indicates whether the auto assign sub command aliases feature should be enabled or disabled.
+     * @returns The current CommandFeatureSelector instance.
+     */
+    autoAssignSubCommandAliases(boolean?: boolean): this;
+    /**
+     * Helper method to enable or disable a feature.
+     * @param boolean - Indicates whether the auto assign sub command aliases feature should be enabled or disabled.
+     * @param prop - The property name to set.
+     * @param method - The method name to output in the debug message.
+     * @param throwIfNative - Indicates whether an error should be thrown if the command is native.
+     * @returns The current CommandFeatureSelector instance.
+     */
+    protected setProperty(boolean: boolean | undefined, prop: keyof this, method: string, throwIfNative: boolean): this;
+}

package/src/cmd/DefaultHelpConfig.d.ts

@@ -0,0 +1,2 @@
+import { Help } from 'commander';
+export declare const DefaultHelpConfig: Partial<Help>;

package/src/core/OutputManager.d.ts

@@ -0,0 +1,63 @@
+import colors from 'ansi-colors';
+import { Any } from '../util/types/Any';
+import { MethodDisabler } from '../util/function/MethodDisabler';
+/**
+ * The OutputManager class manages the output of debug messages to the console.
+ */
+export declare class OutputManager {
+    /**
+     * The singleton instance of the OutputManager class.
+     */
+    private static instance;
+    /**
+     * Returns the singleton instance of the OutputManager class.
+     * If the instance does not exist, it creates a new one.
+     */
+    static getInstance(): OutputManager;
+    /**
+     * Ansi-colors object
+     */
+    readonly colors: typeof colors;
+    /**
+     * A MethodDisabler instance for disabling the write method of the process.stdout object.
+     */
+    readonly stdout: MethodDisabler;
+    /**
+     * A MethodDisabler instance for disabling the write method of the process.stderr object.
+     */
+    readonly stderr: MethodDisabler;
+    /**
+     * A MethodDisabler instance for disabling the debug method of the console object.
+     */
+    readonly debug: MethodDisabler;
+    /**
+     * An array that holds queued debug messages.
+     */
+    protected readonly debugMsgQueue: (() => Any)[];
+    /**
+     * Constructs a new instance of the OutputManager class.
+     * console.debug is disabled by default.
+     */
+    constructor();
+    get queueSize(): number;
+    /**
+     * Resets the OutputManager to its default state.
+     * - Enables colors.
+     * - Enables the write method of the process.stdout object.
+     * - Enables the write method of the process.stderr object.
+     * - Disables the debug method of the console object.
+     * @returns The OutputManager instance.
+     */
+    reset(): this;
+    /**
+     * Outputs a debug message to the console.
+     * If the debug method is enabled, the message is immediately logged to the console.
+     * Otherwise, the message is added to the debug message queue.
+     * @param fn - A function that returns the debug message.
+     */
+    outputDebug(fn: () => Any): void;
+    /**
+     * Drains the debug message queue by logging all the messages to the console.
+     */
+    drainDebugMessageQueue(): void;
+}

package/src/{parsers/selector/AbstractStringParserSelector.d.ts → core/ParserSelector.d.ts}

@@ -1,9 +1,8 @@
-import { ArgumentBuilder } from '../../core/CommandBuilder/ArgumentBuilder';
-import { Base } from '../../core/CommandBuilder/Base';
-import { JsonValue } from '@bemoje/util';
-import { OptionBuilder } from '../../core/CommandBuilder/OptionBuilder';
-import { TStringParser } from '../../types/TStringParser';
-export declare abstract class AbstractStringParserSelector<Builder extends ArgumentBuilder | OptionBuilder> extends Base {
+import { ArgumentBuilder } from '../arg/ArgumentBuilder';
+import { JsonValue } from '../util/types/JsonValue';
+import { OptionBuilder } from '../opt/OptionBuilder';
+import { TStringParser } from '../util/types/TStringParser';
+export declare abstract class ParserSelector<Builder extends ArgumentBuilder | OptionBuilder> {
     protected readonly builder: Builder;
     constructor(builder: Builder);
     abstract custom<T extends JsonValue>(parser: TStringParser<T>): Builder;

package/src/core/ValidatorSelector.d.ts

@@ -0,0 +1,16 @@
+import { ArgumentBuilder } from '../arg/ArgumentBuilder';
+import { JsonValue } from '../util/types/JsonValue';
+import { OptionBuilder } from '../opt/OptionBuilder';
+import { TValidator } from '../util/types/TValidator';
+export declare abstract class ValidatorSelector<Builder extends OptionBuilder | ArgumentBuilder> {
+    protected readonly builder: Builder;
+    constructor(builder: Builder);
+    abstract custom<O>(validator: TValidator<O>): typeof this.builder;
+    isString(): Builder;
+    isNumber(): Builder;
+    isInteger(): Builder;
+    isStringArray(): Builder;
+    isNumberArray(): Builder;
+    isIntegerArray(): Builder;
+    arrayWhereEach<O extends JsonValue = JsonValue>(...validators: TValidator<O>[]): Builder;
+}

package/src/core/counter.d.ts

@@ -0,0 +1,3 @@
+import { TConstructor } from '../util/types/TConstructor';
+export declare function countInstance(ctor: TConstructor): void;
+export declare function printCounts(): void;

package/src/db/AbstractJsonFileSection.d.ts

@@ -0,0 +1,136 @@
+import { Any } from '../util/types/Any';
+import { JsonFile } from './JsonFile';
+import { JsonValue } from '../util/types/JsonValue';
+/**
+ * A class that represents a section of the JSON file used as a simple database.
+ */
+export declare abstract class AbstractJsonFileSection<Val = JsonValue> {
+    readonly file: JsonFile;
+    protected readonly name: string;
+    protected readonly keysAreFixed: boolean;
+    /**
+     * Indicates whether the section has been initialized.
+     */
+    protected isInitialized: boolean;
+    /**
+     * The default values for the section.
+     */
+    readonly defaultValues: Record<string, Val>;
+    /**
+     * The base string used as a prefix for the section.
+     */
+    readonly prefixBaseString: string;
+    /**
+     * Creates an instance of AbstractJsonFileSection.
+     * @param file - The parent JsonFile instance.
+     * @param name - The name of the section.
+     * @param keysAreFixed - Indicates whether the keys in the section are fixed.
+     */
+    constructor(file: JsonFile, name: string, keysAreFixed: boolean);
+    /**
+     * Asserts that a key-value pair is valid.
+     * @param key - The key to assert.
+     * @param value - The value to assert.
+     */
+    abstract assertValid(key: string, value: Val): void;
+    /**
+     * Defines a property for the section.
+     * @param key - The key of the property.
+     * @param options - The options for the property.
+     */
+    abstract defineProperty(key: string, options: Any): void;
+    /**
+     * Initializes the section.
+     * @param save - Indicates whether to save the section after initialization.
+     * @returns A string if an error occurred during initialization, otherwise void.
+     */
+    abstract initialize(save?: boolean): void | string;
+    /**
+     * The JsonDB associated with the section.
+     */
+    get db(): import("..").JsonDB;
+    /**
+     * The CommandBuilder associated with the section.
+     */
+    get cmd(): import("..").CommandBuilder;
+    /**
+     * Saves the section.
+     * @returns A promise that resolves when the section is saved.
+     */
+    save(): Promise<void>;
+    /**
+     * Gets the object path prefix as dot-separated keys for this section of the JSON file database.
+     * @param key - An optional key to append to the prefix path.
+     * @returns The object path prefix.
+     * @throws An error if the keys are fixed and the specified key does not exist in the default values.
+     */
+    prefix(key?: string): string;
+    /**
+     * Gets the value associated with the specified key.
+     * @param key - The key to get the value for.
+     * @returns The value associated with the key.
+     */
+    get<T extends Val = Val>(key: string): T;
+    /**
+     * Gets all the values in the section.
+     * @returns All the values in the section.
+     */
+    getAll(): Record<string, Val>;
+    /**
+     * Gets the keys in the section.
+     * @returns The keys in the section.
+     */
+    get keys(): string[];
+    /**
+     * Gets the number of keys in the section.
+     * @returns The number of keys in the section.
+     */
+    count(): number;
+    /**
+     * Sets the value associated with the specified key.
+     * @param key - The key to set the value for.
+     * @param value - The value to set.
+     * @param save - Indicates whether to save the section after setting the value.
+     */
+    set(key: string, value: Val, save?: boolean): void;
+    /**
+     * Sets all the values in the section.
+     * @param values - The values to set.
+     * @param save - Indicates whether to save the section after setting the values.
+     */
+    setAll(values: typeof this.defaultValues, save?: boolean): void;
+    /**
+     * Updates the value associated with the specified key.
+     * @param key - The key to set the value for.
+     * @param callback - The callback function that returns the new value.
+     * @param save - Indicates whether to save the section after setting the value.
+     */
+    update(key: string, callback: (val: Val, key: string) => Val, save?: boolean): void;
+    /**
+     * Resets the value associated with the specified key to its default value.
+     * @param key - The key to reset.
+     * @param save - Indicates whether to save the section after resetting the value.
+     */
+    reset(key: string, save?: boolean): void;
+    /**
+     * Resets all the values in the section to their default values.
+     * @param save - Indicates whether to save the section after resetting the values.
+     */
+    resetAll(save?: boolean): void;
+    /**
+     * Deletes the value associated with the specified key.
+     * @param key - The key to delete.
+     * @param save - Indicates whether to save the section after deleting the value.
+     */
+    delete(key: string, save?: boolean): void;
+    /**
+     * Deletes all the values in the section.
+     * @param save - Indicates whether to save the section after deleting the values.
+     */
+    deleteAll(save?: boolean): void;
+    /**
+     * Edits the values in the section using a text editor.
+     * @param editor - The text editor to use. If not specified, the default text editor command will be used.
+     */
+    edit(editor?: string): void;
+}