/**
 * JSON Schema definition for the `exec` tool.
 *
 * The exec tool runs shell commands, optionally in parallel or background,
 * with retry, timeout, expectation-checking, and pre-command file operations.
 */
export declare const EXEC_TOOL_SCHEMA: {
    readonly type: "object";
    readonly properties: {
        readonly commands: {
            readonly type: "array";
            readonly description: "Commands to execute. Run sequentially by default, parallel if parallel=true.";
            readonly items: {
                readonly type: "object";
                readonly properties: {
                    readonly cmd: {
                        readonly type: "string";
                        readonly description: "Shell command to execute via sh -c.";
                    };
                    readonly cmd_base64: {
                        readonly type: "string";
                        readonly description: "Base64-encoded command. Use when cmd contains special characters.";
                    };
                    readonly cwd: {
                        readonly type: "string";
                        readonly description: "Working directory for this command. Overrides working_dir.";
                    };
                    readonly timeout_ms: {
                        readonly type: "integer";
                        readonly minimum: 1;
                        readonly description: "Per-command timeout in milliseconds. Default: 120000 (2 min).";
                    };
                    readonly env: {
                        readonly type: "object";
                        readonly description: "Additional environment variables merged with the current process env.";
                        readonly additionalProperties: {
                            readonly type: "string";
                        };
                    };
                    readonly expect: {
                        readonly type: "object";
                        readonly description: "Expectations to validate after the command completes.";
                        readonly properties: {
                            readonly exit_code: {
                                readonly type: "integer";
                                readonly description: "Expected exit code.";
                            };
                            readonly stdout_contains: {
                                readonly type: "string";
                                readonly description: "Substring that stdout must contain.";
                            };
                            readonly stderr_contains: {
                                readonly type: "string";
                                readonly description: "Substring that stderr must contain.";
                            };
                        };
                    };
                    readonly background: {
                        readonly type: "boolean";
                        readonly description: string;
                    };
                    readonly retry: {
                        readonly type: "object";
                        readonly description: "Retry configuration for transient failures.";
                        readonly properties: {
                            readonly max: {
                                readonly type: "integer";
                                readonly minimum: 1;
                                readonly maximum: 10;
                                readonly description: "Maximum retry attempts. Default: 3.";
                            };
                            readonly delay_ms: {
                                readonly type: "integer";
                                readonly minimum: 0;
                                readonly description: "Base delay between retries in ms. Default: 1000.";
                            };
                            readonly max_delay_ms: {
                                readonly type: "integer";
                                readonly minimum: 0;
                                readonly description: "Max jitter cap for exponential backoff in ms. Default: 30000.";
                            };
                            readonly backoff: {
                                readonly type: "string";
                                readonly enum: readonly ["fixed", "exponential"];
                                readonly description: "Backoff strategy. Default: exponential.";
                            };
                            readonly on: {
                                readonly type: "array";
                                readonly items: {
                                    readonly type: "string";
                                    readonly enum: readonly ["network", "lock", "busy", "oom"];
                                };
                                readonly description: "Error categories to retry on. Default: [\"network\", \"lock\", \"busy\"].";
                            };
                        };
                    };
                    readonly until: {
                        readonly type: "object";
                        readonly description: "Pattern-based early termination. Watch stdout/stderr for a regex match.";
                        readonly properties: {
                            readonly pattern: {
                                readonly type: "string";
                                readonly description: "Regex to watch for in combined stdout/stderr.";
                            };
                            readonly timeout_ms: {
                                readonly type: "integer";
                                readonly minimum: 1;
                                readonly description: "Max wait time in ms. Defaults to command timeout.";
                            };
                            readonly kill_after: {
                                readonly type: "boolean";
                                readonly description: "Kill the process when pattern matches. Default false (promotes to background).";
                            };
                        };
                        readonly required: readonly ["pattern"];
                    };
                    readonly progress: {
                        readonly type: "boolean";
                        readonly description: string;
                    };
                };
            };
            readonly minItems: 1;
            readonly maxItems: 10;
        };
        readonly parallel: {
            readonly type: "boolean";
            readonly description: "Run all commands in parallel. Default: false (sequential).";
        };
        readonly working_dir: {
            readonly type: "string";
            readonly description: "Global working directory applied to all commands unless overridden per-command.";
        };
        readonly timeout_ms: {
            readonly type: "integer";
            readonly minimum: 1;
            readonly description: "Global timeout in ms applied to all commands. Default: 120000.";
        };
        readonly verbosity: {
            readonly type: "string";
            readonly enum: readonly ["count_only", "minimal", "standard", "verbose"];
            readonly description: string;
        };
        readonly stop_on_error: {
            readonly type: "boolean";
            readonly description: string;
        };
        readonly fail_fast: {
            readonly type: "boolean";
            readonly description: string;
        };
        readonly file_ops: {
            readonly type: "array";
            readonly description: "File operations to execute BEFORE commands run.";
            readonly items: {
                readonly type: "object";
                readonly properties: {
                    readonly op: {
                        readonly type: "string";
                        readonly enum: readonly ["copy", "move", "delete"];
                        readonly description: "Operation type.";
                    };
                    readonly source: {
                        readonly type: "string";
                        readonly description: "Source path (relative or absolute, within project root).";
                    };
                    readonly destination: {
                        readonly type: "string";
                        readonly description: "Destination path. Required for copy and move.";
                    };
                    readonly recursive: {
                        readonly type: "boolean";
                        readonly description: "Copy/delete directories recursively.";
                    };
                    readonly overwrite: {
                        readonly type: "boolean";
                        readonly description: string;
                        readonly default: false;
                    };
                    readonly dry_run: {
                        readonly type: "boolean";
                        readonly description: string;
                        readonly default: false;
                    };
                    readonly update_imports: {
                        readonly type: "boolean";
                        readonly description: string;
                        readonly default: false;
                    };
                };
                readonly required: readonly ["op", "source"];
            };
        };
    };
    readonly required: readonly ["commands"];
};
export type ExecVerbosity = 'count_only' | 'minimal' | 'standard' | 'verbose';
export interface ExecExpect {
    exit_code?: number | undefined;
    stdout_contains?: string | undefined;
    stderr_contains?: string | undefined;
}
export interface ExecRetry {
    max?: number | undefined;
    delay_ms?: number | undefined;
    /** Max jitter cap for exponential backoff. Default: 30000. */
    max_delay_ms?: number | undefined;
    backoff?: 'fixed' | 'exponential' | undefined;
    /** Error categories to retry on. Default: ['network', 'lock', 'busy']. */
    on?: ReadonlyArray<'network' | 'lock' | 'busy' | 'oom'> | undefined;
}
export interface ExecUntil {
    pattern: string;
    timeout_ms?: number | undefined;
    kill_after?: boolean | undefined;
}
export interface ExecFileOp {
    op: 'copy' | 'move' | 'delete';
    source: string;
    destination?: string | undefined;
    recursive?: boolean | undefined;
    /** Overwrite destination if it exists (copy/move only). Default: false. */
    overwrite?: boolean | undefined;
    /** Preview what would be deleted without deleting (delete only). Default: false. */
    dry_run?: boolean | undefined;
    /** Rewrite TS/JS import paths after move (move only). Default: false. */
    update_imports?: boolean | undefined;
}
export interface ExecCommandInput {
    cmd?: string | undefined;
    cmd_base64?: string | undefined;
    cwd?: string | undefined;
    timeout_ms?: number | undefined;
    env?: Record<string, string> | undefined;
    expect?: ExecExpect | undefined;
    background?: boolean | undefined;
    retry?: ExecRetry | undefined;
    until?: ExecUntil | undefined;
    /** Stream stdout to a pollable progress file. Auto-enabled when timeout_ms > 30000. */
    progress?: boolean | undefined;
}
export interface ExecInput {
    commands: ExecCommandInput[];
    parallel?: boolean | undefined;
    working_dir?: string | undefined;
    timeout_ms?: number | undefined;
    verbosity?: ExecVerbosity | undefined;
    file_ops?: ExecFileOp[] | undefined;
    /**
     * Stop sequential execution on first failed command.
     * Unexecuted commands appear as {skipped: true} entries. Default: false.
     */
    fail_fast?: boolean | undefined;
    /** Alias for fail_fast. */
    stop_on_error?: boolean | undefined;
}
export interface ExecCommandResult {
    cmd: string;
    exit_code: number | null;
    stdout: string;
    stderr: string;
    success: boolean;
    /** Set when expectations are violated. */
    expectation_error?: string | undefined;
    /** Set when command exceeded timeout. */
    timed_out?: boolean | undefined;
    /** Set when command ran in background. */
    process_id?: string | undefined;
    pid?: number | undefined;
    /** Timing info (verbose only). */
    duration_ms?: number | undefined;
    cwd?: string | undefined;
    env?: Record<string, string> | undefined;
    /** Truncation note. */
    stdout_truncated?: boolean | undefined;
    stderr_truncated?: boolean | undefined;
    /** Number of retry attempts used. */
    retries?: number | undefined;
    /** Set when this command was not executed due to fail_fast/stop_on_error. */
    skipped?: boolean | undefined;
    /** Path to the pollable progress file when progress tracking is enabled. */
    progress_file?: string | undefined;
    /** Tool-level warnings for degraded command collection or side effects. */
    warnings?: string[] | undefined;
}
export type { BackgroundProcess } from '../shared/process-manager.js';
//# sourceMappingURL=schema.d.ts.map