export declare enum CommandOutputModeEnum {
    /** Instructs the executor to capture the entire stdout stream as a string and return it with the command response.  */
    "capture" = "capture",
    /** Instructs the executor to stream stdout to a log without returning it in the response (similar to a void response type).
     * NOTE: This mode only affects the visibility of stdout, it does NOT prevent visibility of errors.
    */
    "log" = "log",
    /** Fires off the command without waiting for a response. */
    "async" = "async"
}
export interface TerminalCommandRequest extends Partial<ShellSpec> {
    command: string;
    /** Declares whether to stream output to a log or to cpature and return it with the command result. */
    outputMode: CommandOutputModeEnum;
    cwd?: string | undefined;
}
export interface ShellSpec {
    /** Command to invoke a specific terminal from which to execute given commands.
     * Setting this argument will invoke a 3-step process to open a terminal, then fire the command from that terminal, and then finally close the terminal.
     *
     * If you want to run the command from a shell in a single step (aka: inline shell command),
     * ignore this property and construct the shell inline syntax into the main command string.
     * eg:
     * ```
     * const req = { command: "powershell -c 'wsl -l -v'" }
     * ```
    */
    shellExe: string | undefined;
    /** Arguments for the terminal command. */
    shellArgs?: string[] | undefined;
    env?: {
        [key: string]: string;
    } | undefined;
    /** Declares that the command is to be run inline with the shell command as a single execution.
     * Leave this parameter out if you want to run the command as a separate statement within the shell after the shell is instantiated.
     *
     * When set, the value of this property must be the name of the shell argument declaring the main command to run within the shell.
     *
     * There are typically two conventional arguments for this purpose:
     * `--` (double-dash) or `-c` (command arg) (sometimes `-e`).
     * When specified with a double-dash (`--`), the inline command is to be appended at the end of the whole shell command string, unescaped, as-is.
     * When specified with a command arg (`-c` or `-e`), the inline command needs to be enclosed in double quotes (aka: "enquoted") with its content escaped appropriately.
     *
     * Niether of these two syntaxes support piping within the command.
     * To utilize pipe operators within your command, ignore this property to avoid the inline syntax.
     *
     * For Example: the following shell spec and command...
     * ```
     * const shellSpec = { shellExe: "powershell", shellArgs: undefined, inlineOperator: "-c" };
     * const command = "wsl -l -v"
     * ```
     * ...will yield the following command string:
     * ```
     * powershell -c 'wsl -l -v'
     * ```
     */
    inlineOperator?: "--" | "-c" | string | undefined;
}
/** Return value of a cli command execution. */
export interface CommandResponse extends CommandResponseVoid {
    stdout: string | undefined;
}
/** Return value of a cli command execution. */
export interface CommandResponseVoid {
    code: number;
    stderr?: string | undefined;
    error?: Error | undefined;
}
