import 'reflect-metadata';
import { CoreModels } from './core-models';
export declare namespace UtilsTerminal {
    export interface SelectChoice {
        /**
         * Title of the choice
         */
        name?: string;
        disabled?: boolean;
    }
    export interface SelectChoiceValue<T = string> extends SelectChoice {
        value?: T;
    }
    type SelectActionChoice = {
        [choice: string]: SelectChoice & {
            /**
             * Action to execute
             */
            action?: () => any;
        };
    };
    export const wait: (second: number) => Promise<void>;
    export const waitMilliseconds: (milliseconds: number) => Promise<void>;
    /**
     * Check if cli is running in verbose mode
     * @returns true if cli is running with arugment -verbose
     */
    export const isVerboseModeTaon: () => boolean;
    export const waitForUserAnyKey: (callback: () => void | Promise<void>, options?: {
        /**
         * by default, the action is only triggered once when a key is pressed.
         * if this option is set, the action will be triggered on every key press.
         * (Promise will not be resolved until process is killed)
         */
        triggerActionEveryKeypress?: boolean;
    }) => Promise<void>;
    export const getTerminalHeight: () => number;
    export const clearConsole: () => void;
    export const multiselect: <T = string>(options: {
        question?: string;
        /**
         * If true, then only one choice can be selected
         * @deprecated use select instead
         */
        onlyOneChoice?: boolean;
        choices: SelectChoiceValue<T>[] | {
            [choice: string]: SelectChoice;
        };
        autocomplete?: boolean;
        /**
         * at least one choice must be selected
         */
        required?: boolean;
        defaultSelected?: string[];
    }) => Promise<T[]>;
    /**
     * Similar to select but executes action if provided
     * @returns selected and executed value
     */
    export const multiselectActionAndExecute: <CHOICE extends SelectActionChoice = SelectActionChoice>(choices: CHOICE, options?: {
        question?: string;
        autocomplete?: boolean;
        defaultSelected?: string;
        hint?: string;
        executeActionsOnDefault?: boolean;
    }) => Promise<{
        selected: (keyof CHOICE)[];
        actionResults: unknown[];
        /**
         * object containing all selected actions
         */
        actions: (() => any)[];
    }>;
    /**
     * Similar to select but executes action if provided
     * @returns selected and executed value
     */
    export const selectActionAndExecute: <CHOICE extends SelectActionChoice = SelectActionChoice>(choices: CHOICE, options?: {
        question?: string;
        autocomplete?: boolean;
        defaultSelected?: string;
        hint?: string;
        executeActionOnDefault?: boolean;
    }) => Promise<{
        selected: any;
        action: () => Promise<any>;
        actionResult?: undefined;
    } | {
        selected: keyof CHOICE;
        actionResult: unknown;
        action: () => Promise<any>;
    }>;
    export const select: <T = string>(options: {
        question?: string;
        choices: SelectChoiceValue<T>[] | {
            [choice: string]: SelectChoice;
        };
        autocomplete?: boolean;
        defaultSelected?: string;
        hint?: string;
    }) => Promise<T | undefined>;
    export const pipeEnterToStdin: () => void;
    export const input: ({ defaultValue, question, required, validate, }: {
        defaultValue?: string;
        question: string;
        required?: boolean;
        validate?: (value: string) => boolean;
    }) => Promise<string>;
    export const confirm: (options?: {
        /**
         * default: Are you sure?
         */
        message?: string;
        callbackTrue?: () => any;
        callbackFalse?: () => any;
        /**
         * default: true
         */
        defaultValue?: boolean;
        engine?: "inquirer-toggle" | "prompts" | "enquirer" | "@inquirer/prompts";
    }) => Promise<boolean>;
    export const pressAnyKeyToContinueAsync: (options?: {
        message?: string;
    }) => Promise<void>;
    /**
     * @deprecated use UtilsTerminal.pressAnyKey
     */
    export const pressKeyAndContinueSync: (message?: string) => void;
    /**
     * @returns true if user wants to try again, false otherwise
     */
    export const pressAnyKeyToTryAgainErrorOccurred: (error: unknown) => Promise<boolean>;
    /**
     * @deprecated use UtilsTerminal.pressAnyKeyToContinueAsync()
     */
    export const pressAnyKey: (options?: {
        message?: string;
    }) => void;
    export const previewLongList: (list: string | string[], listName?: string) => Promise<void>;
    /**
     * Displays a long list in the console using a pager like `less`.
     * Returns a Promise that resolves when the user exits the pager.
     *
     * @param {string} list - The long string content to display.
     * @returns {Promise<void>} A Promise that resolves when the pager exits.
     */
    export const previewLongListGitLogLike: (list: string | string[]) => Promise<void>;
    export const drawBigText: (text: string, options?: {
        skipDrawing?: boolean;
        align?: CoreModels.CfontAlign;
        style?: CoreModels.CfontStyle;
    }) => Promise<string>;
    export const drawLine: (col?: number) => void;
    export {};
}