import { Interfaces, Errors } from '@oclif/core';
import { Options as Options$1, SingleBar } from 'cli-progress';

declare const _default$2: {
    arc: {
        frames: string[];
        interval: number;
    };
    arrow: {
        frames: string[];
        interval: number;
    };
    arrow2: {
        frames: string[];
        interval: number;
    };
    arrow3: {
        frames: string[];
        interval: number;
    };
    balloon: {
        frames: string[];
        interval: number;
    };
    balloon2: {
        frames: string[];
        interval: number;
    };
    bounce: {
        frames: string[];
        interval: number;
    };
    bouncingBall: {
        frames: string[];
        interval: number;
    };
    bouncingBar: {
        frames: string[];
        interval: number;
    };
    boxBounce: {
        frames: string[];
        interval: number;
    };
    boxBounce2: {
        frames: string[];
        interval: number;
    };
    circle: {
        frames: string[];
        interval: number;
    };
    circleHalves: {
        frames: string[];
        interval: number;
    };
    circleQuarters: {
        frames: string[];
        interval: number;
    };
    clock: {
        frames: string[];
        interval: number;
    };
    dots: {
        frames: string[];
        interval: number;
    };
    dots2: {
        frames: string[];
        interval: number;
    };
    dots3: {
        frames: string[];
        interval: number;
    };
    dots4: {
        frames: string[];
        interval: number;
    };
    dots5: {
        frames: string[];
        interval: number;
    };
    dots6: {
        frames: string[];
        interval: number;
    };
    dots7: {
        frames: string[];
        interval: number;
    };
    dots8: {
        frames: string[];
        interval: number;
    };
    dots9: {
        frames: string[];
        interval: number;
    };
    dots10: {
        frames: string[];
        interval: number;
    };
    dots11: {
        frames: string[];
        interval: number;
    };
    earth: {
        frames: string[];
        interval: number;
    };
    flip: {
        frames: string[];
        interval: number;
    };
    growHorizontal: {
        frames: string[];
        interval: number;
    };
    growVertical: {
        frames: string[];
        interval: number;
    };
    hamburger: {
        frames: string[];
        interval: number;
    };
    hearts: {
        frames: string[];
        interval: number;
    };
    hexagon: {
        frames: string[];
        interval: number;
    };
    line: {
        frames: string[];
        interval: number;
    };
    line2: {
        frames: string[];
        interval: number;
    };
    monkey: {
        frames: string[];
        interval: number;
    };
    moon: {
        frames: string[];
        interval: number;
    };
    noise: {
        frames: string[];
        interval: number;
    };
    pipe: {
        frames: string[];
        interval: number;
    };
    pong: {
        frames: string[];
        interval: number;
    };
    runner: {
        frames: string[];
        interval: number;
    };
    simpleDots: {
        frames: string[];
        interval: number;
    };
    simpleDotsScrolling: {
        frames: string[];
        interval: number;
    };
    smiley: {
        frames: string[];
        interval: number;
    };
    squareCorners: {
        frames: string[];
        interval: number;
    };
    squish: {
        frames: string[];
        interval: number;
    };
    star: {
        frames: string[];
        interval: number;
    };
    star2: {
        frames: string[];
        interval: number;
    };
    toggle: {
        frames: string[];
        interval: number;
    };
    toggle2: {
        frames: string[];
        interval: number;
    };
    toggle3: {
        frames: string[];
        interval: number;
    };
    toggle4: {
        frames: string[];
        interval: number;
    };
    toggle5: {
        frames: string[];
        interval: number;
    };
    toggle6: {
        frames: string[];
        interval: number;
    };
    toggle7: {
        frames: string[];
        interval: number;
    };
    toggle8: {
        frames: string[];
        interval: number;
    };
    toggle9: {
        frames: string[];
        interval: number;
    };
    toggle10: {
        frames: string[];
        interval: number;
    };
    toggle11: {
        frames: string[];
        interval: number;
    };
    toggle12: {
        frames: string[];
        interval: number;
    };
    toggle13: {
        frames: string[];
        interval: number;
    };
    triangle: {
        frames: string[];
        interval: number;
    };
};

type Options = {
    stdout?: boolean;
    style?: keyof typeof _default$2;
};

interface ITask {
    action: string;
    active: boolean;
    status: string | undefined;
}
type ActionType = 'debug' | 'simple' | 'spinner';
declare class ActionBase {
    std: 'stderr' | 'stdout';
    protected stdmocks?: Array<['stderr' | 'stdout', string[]]>;
    type: ActionType;
    private stdmockOrigs;
    protected get output(): string | undefined;
    protected set output(output: string | undefined);
    get running(): boolean;
    get status(): string | undefined;
    set status(status: string | undefined);
    get task(): ITask | undefined;
    set task(task: ITask | undefined);
    pause(fn: () => any, icon?: string): Promise<any>;
    pauseAsync<T>(fn: () => Promise<T>, icon?: string): Promise<T>;
    start(action: string, status?: string, opts?: Options): void;
    stop(msg?: string): void;
    protected _flushStdout(): void;
    protected _pause(_?: string): void;
    protected _resume(): void;
    protected _start(_opts: Options): void;
    protected _stdout(toggle: boolean): void;
    protected _stop(_: string): void;
    protected _updateStatus(_: string | undefined, __?: string): void;
    protected _write(std: 'stderr' | 'stdout', s: string | string[]): void;
    private get globals();
}

type Levels = 'debug' | 'error' | 'fatal' | 'info' | 'trace' | 'warn';
declare class Config {
    action: ActionBase;
    errorsHandled: boolean;
    outputLevel: Levels;
    showStackTrace: boolean;
    get context(): any;
    set context(v: unknown);
    get debug(): boolean;
    set debug(v: boolean);
}
declare const config: Config;

interface IPromptOptions {
    default?: string;
    prompt?: string;
    /**
     * Requires user input if true, otherwise allows empty input
     */
    required?: boolean;
    timeout?: number;
    type?: 'hide' | 'mask' | 'normal' | 'single';
}
/**
 * prompt for input
 * @param name - prompt text
 * @param options - @see IPromptOptions
 * @returns Promise<string>
 */
declare function prompt$1(name: string, options?: IPromptOptions): Promise<string>;
/**
 * confirmation prompt (yes/no)
 * @param message - confirmation text
 * @returns Promise<boolean>
 */
declare function confirm$1(message: string): Promise<boolean>;
/**
 * "press anykey to continue"
 * @param message - optional message to display to user
 * @returns Promise<string>
 */
declare function anykey$1(message?: string): Promise<string>;

declare function progress$1(options?: Options$1): SingleBar;

declare function table$1<T extends Record<string, unknown>>(data: T[], columns: table$1.Columns<T>, options?: table$1.Options): void;
declare namespace table$1 {
    export const Flags: {
        columns: Interfaces.OptionFlag<string | undefined>;
        csv: Interfaces.BooleanFlag<boolean>;
        extended: Interfaces.BooleanFlag<boolean>;
        filter: Interfaces.OptionFlag<string | undefined>;
        'no-header': Interfaces.BooleanFlag<boolean>;
        'no-truncate': Interfaces.BooleanFlag<boolean>;
        output: Interfaces.OptionFlag<string | undefined>;
        sort: Interfaces.OptionFlag<string | undefined>;
    };
    type IFlags = typeof Flags;
    type ExcludeFlags<T, Z> = Pick<T, Exclude<keyof T, Z>>;
    type IncludeFlags<T, K extends keyof T> = Pick<T, K>;
    export function flags(): IFlags;
    export function flags<Z extends keyof IFlags = keyof IFlags>(opts: {
        except: Z | Z[];
    }): ExcludeFlags<IFlags, Z>;
    export function flags<K extends keyof IFlags = keyof IFlags>(opts: {
        only: K | K[];
    }): IncludeFlags<IFlags, K>;
    export interface Column<T extends Record<string, unknown>> {
        extended: boolean;
        get(row: T): any;
        header: string;
        minWidth: number;
    }
    export type Columns<T extends Record<string, unknown>> = Record<string, Partial<Column<T>>>;
    export interface Options {
        [key: string]: any;
        columns?: string;
        extended?: boolean;
        filter?: string;
        'no-header'?: boolean;
        'no-truncate'?: boolean;
        output?: string;
        printLine?(s: any): any;
        sort?: string;
    }
    export {  };
}

declare namespace table$2 {
  export { table$1 as table };
}

declare class Tree {
    nodes: Record<string, Tree>;
    display(logger?: any): void;
    insert(child: string, value?: Tree): this;
    search(key: string): Tree | undefined;
}
declare function tree$1(): Tree;

declare const _default$1: (ms?: number) => Promise<void>;

declare class ExitError extends Error {
    code: 'EEXIT';
    error?: Error;
    ux: {
        exit: number;
    };
    constructor(status: number, error?: Error);
}

declare const STANDARD_CHALK: readonly ["white", "black", "blue", "yellow", "green", "red", "magenta", "cyan", "gray", "blackBright", "redBright", "greenBright", "yellowBright", "blueBright", "magentaBright", "cyanBright", "whiteBright", "bgBlack", "bgRed", "bgGreen", "bgYellow", "bgBlue", "bgMagenta", "bgCyan", "bgWhite", "bgGray", "bgBlackBright", "bgRedBright", "bgGreenBright", "bgYellowBright", "bgBlueBright", "bgMagentaBright", "bgCyanBright", "bgWhiteBright", "bold", "underline", "dim", "italic", "strikethrough"];
type StandardChalk = (typeof STANDARD_CHALK)[number];
/**
 * Add color to text.
 * @param color color to use. Can be hex code (e.g. `#ff0000`), rgb (e.g. `rgb(255, 255, 255)`) or a chalk color (e.g. `red`)
 * @param text string to colorize
 * @returns colorized string
 */
declare function colorize(color: string | StandardChalk | undefined, text: string): string;

declare const _default: {
    stderr: (msg: string) => void;
    stdout: (msg: string) => void;
};

declare class ux {
    static config: Config;
    static get action(): ActionBase;
    static annotation(text: string, annotation: string): void;
    /**
     * "press anykey to continue"
     */
    static get anykey(): typeof anykey$1;
    static get confirm(): typeof confirm$1;
    static debug(format: string, ...args: string[]): void;
    static done(): Promise<void>;
    static flush(ms?: number): Promise<void>;
    static info(format: string, ...args: string[]): void;
    static log(format?: string, ...args: string[]): void;
    static logToStderr(format?: string, ...args: string[]): void;
    static get progress(): typeof progress$1;
    static get prompt(): typeof prompt$1;
    static styledHeader(header: string): void;
    static styledJSON(obj: unknown): void;
    static styledObject(obj: any, keys?: string[]): void;
    static get table(): typeof table$1;
    static trace(format: string, ...args: string[]): void;
    static get tree(): typeof tree$1;
    static url(text: string, uri: string, params?: {}): void;
    static hyperlink(text: string, uri: string, params?: {}): string;
    static get wait(): typeof _default$1;
}
declare const action: ActionBase;
declare const annotation: typeof ux.annotation;
declare const anykey: typeof anykey$1;
declare const confirm: typeof confirm$1;
declare const debug: typeof ux.debug;
declare const done: typeof ux.done;
declare const flush: typeof ux.flush;
declare const hyperlink: typeof ux.hyperlink;
declare const info: typeof ux.info;
declare const log: typeof ux.log;
declare const logToStderr: typeof ux.logToStderr;
declare const progress: typeof progress$1;
declare const prompt: typeof prompt$1;
declare const styledHeader: typeof ux.styledHeader;
declare const styledJSON: typeof ux.styledJSON;
declare const styledObject: typeof ux.styledObject;
declare const table: typeof table$1;
declare const trace: typeof ux.trace;
declare const tree: typeof tree$1;
declare const url: typeof ux.url;
declare const wait: (ms?: number) => Promise<void>;
declare const error: typeof Errors.error;
declare const exit: typeof Errors.exit;
declare const warn: typeof Errors.warn;

export { ActionBase, Config, ExitError, type IPromptOptions, table$2 as Table, action, annotation, anykey, colorize, config, confirm, debug, done, error, exit, flush, hyperlink, info, log, logToStderr, progress, prompt, styledHeader, styledJSON, styledObject, table, trace, tree, url, ux, wait, warn, _default as write };