import { ToolLoopAgent } from 'ai';
export declare function createCodingAgent(runId?: string): Promise<ToolLoopAgent<never, {
    createPptx: import("ai").Tool<{
        filename: string;
        slides: ({
            kind: "bullets";
            title: string;
            bullets: string[];
            notes?: string | undefined;
            transition?: "push" | "none" | "cover" | "fade" | "wipe" | "dissolve" | "uncover" | undefined;
            background?: string | undefined;
        } | {
            kind: "image";
            caption?: string | undefined;
            notes?: string | undefined;
            fitMode?: "contain" | "cover" | "stretch" | undefined;
            hyperlink?: string | undefined;
            altText?: string | undefined;
            transition?: "push" | "none" | "cover" | "fade" | "wipe" | "dissolve" | "uncover" | undefined;
            background?: string | undefined;
            path?: string | undefined;
            url?: string | undefined;
            generate?: string | undefined;
            provider?: "openai" | "gemini" | "chatgpt" | "google" | "default" | undefined;
            size?: string | undefined;
            title?: string | undefined;
        } | {
            kind: "table";
            headers: string[];
            rows: string[][];
            title?: string | undefined;
            notes?: string | undefined;
            headerColor?: string | undefined;
            transition?: "push" | "none" | "cover" | "fade" | "wipe" | "dissolve" | "uncover" | undefined;
            background?: string | undefined;
        } | {
            kind: "chart";
            chartType: "bar" | "line" | "pie";
            labels: string[];
            series: {
                name: string;
                values: number[];
            }[];
            title?: string | undefined;
            notes?: string | undefined;
            transition?: "push" | "none" | "cover" | "fade" | "wipe" | "dissolve" | "uncover" | undefined;
            background?: string | undefined;
        } | {
            kind: "chartImage";
            chartType: "bar" | "line" | "pie" | "doughnut";
            labels: string[];
            series: {
                name: string;
                values: number[];
            }[];
            width: number;
            height: number;
            title?: string | undefined;
            notes?: string | undefined;
            transition?: "push" | "none" | "cover" | "fade" | "wipe" | "dissolve" | "uncover" | undefined;
            background?: string | undefined;
        } | {
            kind: "textBox";
            text: string;
            x: number;
            y: number;
            w: number;
            h: number;
            fontSize: number;
            color?: string | undefined;
            bold?: boolean | undefined;
            italic?: boolean | undefined;
            alignment?: "left" | "right" | "center" | undefined;
            hyperlink?: string | undefined;
            transition?: "push" | "none" | "cover" | "fade" | "wipe" | "dissolve" | "uncover" | undefined;
            background?: string | undefined;
        } | {
            kind: "section";
            title: string;
            subtitle?: string | undefined;
            transition?: "push" | "none" | "cover" | "fade" | "wipe" | "dissolve" | "uncover" | undefined;
            background?: string | undefined;
        } | {
            kind: "shape";
            shapeType: "line" | "circle" | "rect" | "star" | "ellipse" | "arrow" | "chevron" | "pentagon" | "hexagon" | "heart";
            x: number;
            y: number;
            w: number;
            h: number;
            fillColor?: string | undefined;
            borderColor?: string | undefined;
            borderWidth?: number | undefined;
            shadow?: boolean | undefined;
            text?: string | undefined;
            hyperlink?: string | undefined;
        })[];
        deckTitle?: string | undefined;
        subtitle?: string | undefined;
        accentColor?: string | undefined;
    }, {
        success: false;
        error: string;
    } | ({
        success: true;
    } & {
        path: string;
        relativePath: string;
        slideCount: number;
    })>;
    createChartImage: import("ai").Tool<{
        filename: string;
        type: "bar" | "line" | "pie" | "doughnut";
        labels: string[];
        datasets: {
            label: string;
            data: number[];
            color?: string | undefined;
        }[];
        width: number;
        height: number;
        title?: string | undefined;
    }, {
        success: false;
        error: string;
    } | ({
        success: true;
    } & {
        path: string;
        relativePath: string;
        bytes: number;
    })>;
    createHtmlReport: import("ai").Tool<{
        filename: string;
        title: string;
        theme: "light" | "dark";
        blocks: ({
            type: "heading";
            text: string;
            level: number;
            anchor?: string | undefined;
        } | {
            type: "paragraph";
            text: string;
            lead?: boolean | undefined;
        } | {
            type: "bullets";
            items: string[];
        } | {
            type: "numbered";
            items: string[];
        } | {
            type: "table";
            headers: string[];
            rows: string[][];
        } | {
            type: "callout";
            text: string;
            tone: "success" | "info" | "warning" | "danger";
            title?: string | undefined;
        } | {
            type: "quote";
            text: string;
            attribution?: string | undefined;
        } | {
            type: "code";
            code: string;
            language?: string | undefined;
        } | {
            type: "divider";
        } | {
            alt: string;
            type: "image";
            caption?: string | undefined;
            maxWidth?: number | undefined;
            lazy?: boolean | undefined;
            lightbox?: boolean | undefined;
            borderRadius?: number | undefined;
            shadow?: boolean | undefined;
            path?: string | undefined;
            url?: string | undefined;
            generate?: string | undefined;
            provider?: "openai" | "gemini" | "chatgpt" | "google" | "default" | undefined;
            size?: string | undefined;
        } | {
            type: "chart";
            chartType: "bar" | "line" | "pie" | "doughnut";
            labels: string[];
            datasets: {
                label: string;
                data: number[];
                color?: string | undefined;
            }[];
            width: number;
            height: number;
            title?: string | undefined;
            interactive?: boolean | undefined;
            caption?: string | undefined;
        } | {
            type: "stats";
            items: {
                label: string;
                value: string;
                delta?: string | undefined;
                tone?: "success" | "info" | "warning" | "danger" | undefined;
            }[];
        } | {
            type: "columns";
            columns: {
                text: string;
                heading?: string | undefined;
            }[];
        } | {
            type: "tableOfContents";
        } | {
            type: "tabs";
            tabs: {
                title: string;
                blocks: any[];
            }[];
        } | {
            type: "accordion";
            items: {
                title: string;
                blocks: any[];
            }[];
        } | {
            type: "progressBar";
            value: number;
            max: number;
            label?: string | undefined;
            color?: string | undefined;
        } | {
            type: "badge";
            text: string;
            color?: string | undefined;
            size?: "sm" | "md" | "lg" | undefined;
        } | {
            type: "gallery";
            images: {
                caption?: string | undefined;
                path?: string | undefined;
                url?: string | undefined;
                generate?: string | undefined;
                provider?: "openai" | "gemini" | "chatgpt" | "google" | "default" | undefined;
                size?: string | undefined;
            }[];
            columns: number;
        } | {
            type: "timeline";
            items: {
                date: string;
                title: string;
                text?: string | undefined;
            }[];
        } | {
            type: "faq";
            items: {
                question: string;
                answer: string;
            }[];
        } | {
            type: "collapsible";
            title: string;
            blocks: any[];
            defaultOpen?: boolean | undefined;
        } | {
            type: "tooltip";
            text: string;
            tooltip: string;
        } | {
            type: "mermaid";
            diagram: string;
            caption?: string | undefined;
        } | {
            type: "smartArt";
            prompt: string;
            width: number;
            height: number;
            caption?: string | undefined;
        })[];
        subtitle?: string | undefined;
        accentColor?: string | undefined;
        footerNote?: string | undefined;
        fontFamily?: string | undefined;
        showReadingTime?: boolean | undefined;
    }, {
        path: string;
        relativePath: string;
        bytes: number;
    }>;
    parseCsv: import("ai").Tool<{
        path: string;
        hasHeader: boolean;
        maxRows?: number | undefined;
    }, {
        success: false;
        error: string;
    } | ({
        success: true;
    } & {
        headers: string[] | undefined;
        rowCount: number;
        totalRowsInFile: number;
        truncated: boolean;
        rows: (string[] | Record<string, string>)[];
        parseErrors: import("papaparse").ParseError[];
    })>;
    writeCsv: import("ai").Tool<{
        filename: string;
        headers: string[];
        rows: (string | number | boolean | null)[][];
    }, {
        success: false;
        error: string;
    } | ({
        success: true;
    } & {
        path: string;
        relativePath: string;
        rowCount: number;
    })>;
    createDocx: import("ai").Tool<{
        filename: string;
        blocks: ({
            type: "image";
            width: number;
            height: number;
            path?: string | undefined;
            url?: string | undefined;
            generate?: string | undefined;
            provider?: "openai" | "gemini" | "chatgpt" | "google" | "default" | undefined;
            size?: string | undefined;
            caption?: string | undefined;
            altText?: string | undefined;
            border?: {
                color?: string | undefined;
                width?: number | undefined;
                style?: "single" | "double" | "dotted" | "dashed" | undefined;
            } | undefined;
            shadow?: boolean | undefined;
            rotation?: number | undefined;
        } | {
            type: "chart";
            chartType: "bar" | "line" | "pie" | "doughnut";
            labels: string[];
            datasets: {
                label: string;
                data: number[];
                color?: string | undefined;
            }[];
            width: number;
            height: number;
            title?: string | undefined;
            caption?: string | undefined;
        } | {
            type: "heading";
            text: string;
            level: number;
        } | {
            type: "paragraph";
            runs?: {
                text: string;
                bold?: boolean | undefined;
                italics?: boolean | undefined;
                underline?: boolean | undefined;
                strikethrough?: boolean | undefined;
                smallCaps?: boolean | undefined;
                allCaps?: boolean | undefined;
                color?: string | undefined;
                size?: number | undefined;
                font?: string | undefined;
                highlight?: string | undefined;
                link?: string | undefined;
                subscript?: boolean | undefined;
                superscript?: boolean | undefined;
            }[] | undefined;
            text?: string | undefined;
            alignment?: "left" | "right" | "center" | "justify" | undefined;
            spacingAfter?: number | undefined;
            spacingBefore?: number | undefined;
            indentLeft?: number | undefined;
            indentRight?: number | undefined;
            indentFirstLine?: number | undefined;
            style?: string | undefined;
        } | {
            type: "bullets";
            items: (string | {
                text: string;
                level: number;
            })[];
        } | {
            type: "numbered";
            items: (string | {
                text: string;
                level: number;
            })[];
        } | {
            type: "table";
            headers: string[];
            rows: string[][];
            headerColor?: string | undefined;
            borderColor?: string | undefined;
            alternateRowColor?: string | undefined;
        } | {
            type: "quote";
            text: string;
            attribution?: string | undefined;
        } | {
            type: "pageBreak";
        } | {
            type: "tableOfContents";
        } | {
            type: "divider";
        } | {
            type: "columns";
            columns: {
                blocks: any[];
                width?: number | undefined;
            }[];
            spacing?: number | undefined;
        } | {
            type: "sectionBreak";
            orientation?: "portrait" | "landscape" | undefined;
            margins?: {
                top: number;
                bottom: number;
                left: number;
                right: number;
            } | undefined;
        } | {
            type: "bookmark";
            name: string;
        } | {
            type: "crossReference";
            bookmark: string;
            text?: string | undefined;
        } | {
            type: "footnote";
            text: string;
            noteId?: number | undefined;
        } | {
            type: "watermark";
            text: string;
            color?: string | undefined;
            opacity?: number | undefined;
        } | {
            type: "qrCode";
            data: string;
            size: number;
            caption?: string | undefined;
        } | {
            type: "smartArt";
            prompt: string;
            width: number;
            height: number;
            style?: "process" | "hierarchy" | "radial" | "matrix" | "pyramid" | undefined;
            caption?: string | undefined;
        })[];
        showPageNumbers: boolean;
        title?: string | undefined;
        subtitle?: string | undefined;
        author?: string | undefined;
        subject?: string | undefined;
        keywords?: string[] | undefined;
        category?: string | undefined;
        headerText?: string | undefined;
        footerText?: string | undefined;
        margins?: {
            top: number;
            bottom: number;
            left: number;
            right: number;
        } | undefined;
        styles?: {
            name: string;
            basedOn?: string | undefined;
            font?: string | undefined;
            size?: number | undefined;
            color?: string | undefined;
            bold?: boolean | undefined;
        }[] | undefined;
    }, {
        success: false;
        error: string;
    } | ({
        success: true;
    } & {
        path: string;
        relativePath: string;
        bytes: number;
    })>;
    queryCorporateWiki: import("ai").Tool<{
        query: string;
        limit: number;
    }, {
        query: string;
        count: number;
        results: import("../memory/corporate-wiki.js").WikiFact[];
    }>;
    publishToCorporateWiki: import("ai").Tool<{
        content: string;
        metadata: {
            category?: string | undefined;
            topic?: string | undefined;
        };
    }, {
        status: string;
        message: string;
        bytes: number;
    }>;
    readScratchpad: import("ai").Tool<Record<string, never>, string>;
    appendScratchpad: import("ai").Tool<{
        note: string;
    }, string>;
    getSharedValue: import("ai").Tool<{
        key: string;
    }, any>;
    setSharedValue: import("ai").Tool<{
        key: string;
        value: any;
    }, string>;
    listSharedKeys: import("ai").Tool<Record<string, never>, string[]>;
    readNotebook: import("ai").Tool<{
        limitChars?: number | undefined;
    }, {
        paths: {
            markdown: string;
            json: string;
        };
        content: string;
    }>;
    appendNotebook: import("ai").Tool<{
        title: string;
        body: string;
        tags?: string[] | undefined;
    }, import("../memory/notebook.js").NotebookEntry>;
    searchNotebook: import("ai").Tool<{
        query: string;
        limit?: number | undefined;
    }, import("../memory/notebook.js").NotebookEntry[]>;
    listNotebookEntries: import("ai").Tool<{
        limit?: number | undefined;
    }, import("../memory/notebook.js").NotebookEntry[]>;
    quickNotebookNote: import("ai").Tool<{
        section: string;
        content: string;
    }, {
        path: string;
        section: string;
        appendedAt: string;
    }>;
    listSkills: import("ai").Tool<Record<string, never>, {
        skills: import("../skills/loader.js").SkillSummary[];
        searchPaths: string[];
        registry: string;
    }>;
    searchSkills: import("ai").Tool<{
        query: string;
        limit?: number | undefined;
    }, {
        query: string;
        skills: import("../skills/loader.js").SkillSummary[];
        scope: string;
    }>;
    searchSkillsRegistry: import("ai").Tool<{
        query: string;
        limit?: number | undefined;
    }, {
        query: string;
        results: import("../skills/registry.js").RegistrySkill[];
        installHint: string;
        browse: string;
    }>;
    installRegistrySkill: import("ai").Tool<{
        packageRef: string;
        global?: boolean | undefined;
    }, {
        ok: boolean;
        packageRef: string;
        installPath: string;
        output: string;
        browse: string;
    }>;
    readSkill: import("ai").Tool<{
        skillId: string;
    }, import("../skills/loader.js").SkillContent>;
    executeCommand: import("ai").Tool<{
        command: string;
        cwd?: string | undefined;
        timeout?: number | undefined;
        env?: Record<string, string> | undefined;
    }, {
        success: boolean;
        exit: any;
        stdout: any;
        stderr: any;
        command: string;
    }>;
    executeAndSelfHeal: import("ai").Tool<{
        command: string;
        context?: string | undefined;
    }, {
        success: boolean;
        stdout: string;
        command: string;
        error?: never;
        diagnosisHint?: never;
        context?: never;
    } | {
        success: boolean;
        command: string;
        error: any;
        diagnosisHint: string;
        context: string;
        stdout?: never;
    }>;
    installDependencies: import("ai").Tool<{
        command: string;
        manager?: "npm" | "pnpm" | "yarn" | undefined;
        cwd?: string | undefined;
        timeout?: number | undefined;
    }, {
        success: boolean;
        exit: any;
        manager: string;
        stdout: any;
        stderr: any;
    }>;
    runPipeline: import("ai").Tool<{
        commands: string[];
        cwd?: string | undefined;
        timeout?: number | undefined;
    }, {
        success: boolean;
        exit: any;
        stdout: any;
        stderr: any;
        pipeline: string;
    }>;
    pythonScript: import("ai").Tool<{
        code: string;
        cwd?: string | undefined;
        timeout?: number | undefined;
    }, {
        success: boolean;
        exit: any;
        stdout: any;
        stderr: any;
    }>;
    getSystemInfo: import("ai").Tool<Record<string, never>, {
        platform: NodeJS.Platform;
        arch: NodeJS.Architecture;
        release: string;
        cpuCores: number;
        totalMemoryGB: string;
        freeMemoryGB: string;
        nodeVersion: string;
        currentUser: string;
        uptime: string;
        homeDir: string;
    } | {
        platform: NodeJS.Platform;
        arch: NodeJS.Architecture;
        error: any;
    }>;
    listProcesses: import("ai").Tool<{
        filter?: string | undefined;
        limit?: number | undefined;
    }, {
        processes: string[];
        count: number;
        filtered: boolean;
        error?: never;
    } | {
        error: any;
        processes: never[];
        count: number;
        filtered?: never;
    }>;
    findInPath: import("ai").Tool<{
        command: string;
    }, {
        found: boolean;
        command: string;
        path: string;
        suggestion?: never;
    } | {
        found: boolean;
        command: string;
        suggestion: string;
        path?: never;
    }>;
    executeCommandAsync: import("ai").Tool<{
        command: string;
        cwd?: string | undefined;
        env?: Record<string, string> | undefined;
    }, {
        success: boolean;
        id: string;
        status: string;
        message: string;
        command: string;
        error?: never;
    } | {
        success: boolean;
        error: any;
        command: string;
        id?: never;
        status?: never;
        message?: never;
    }>;
    checkCommandStatus: import("ai").Tool<{
        id: string;
    }, {
        success: boolean;
        error: string;
        id?: never;
        command?: never;
        cwd?: never;
        status?: never;
        exitCode?: never;
        startTime?: never;
        endTime?: never;
        stdout?: never;
        stderr?: never;
    } | {
        success: boolean;
        id: string;
        command: string;
        cwd: string;
        status: "completed" | "running" | "failed" | "killed";
        exitCode: number | null;
        startTime: string;
        endTime: string | undefined;
        error: string | undefined;
        stdout: string;
        stderr: string;
    }>;
    sendInputToProcess: import("ai").Tool<{
        id: string;
        input: string;
    }, {
        success: boolean;
        error: string;
        message?: never;
    } | {
        success: boolean;
        message: string;
        error?: never;
    }>;
    killCommand: import("ai").Tool<{
        id: string;
    }, {
        success: boolean;
        error: string;
        message?: never;
    } | {
        success: boolean;
        message: string;
        error?: never;
    }>;
    listBackgroundCommands: import("ai").Tool<Record<string, never>, {
        success: boolean;
        processes: {
            id: string;
            command: string;
            cwd: string;
            status: "completed" | "running" | "failed" | "killed";
            exitCode: number | null;
            startTime: string;
            endTime: string | undefined;
        }[];
        count: number;
    }>;
    searchFiles: import("ai").Tool<{
        query: string;
        root?: string | undefined;
        includeContent?: boolean | undefined;
        maxDepth?: number | undefined;
        maxResults?: number | undefined;
    }, {
        match: string;
        excerpt: string;
        path: string;
        absolutePath: string;
        type: "file" | "directory";
        size: number;
        modifiedAt: string;
    }[]>;
    listDirectory: import("ai").Tool<{
        path: string;
        filter?: string | undefined;
        includeHidden?: boolean | undefined;
        maxDepth?: number | undefined;
        limit?: number | undefined;
        sortBy?: "name" | "size" | "modified" | undefined;
    }, {
        directory: string;
        absolutePath: string;
        entries: {
            path: string;
            absolutePath: string;
            type: "file" | "directory";
            size: number;
            modifiedAt: string;
        }[];
        count: number;
        filtered: boolean;
    }>;
    treeView: import("ai").Tool<{
        path?: string | undefined;
        maxDepth?: number | undefined;
        includeHidden?: boolean | undefined;
        foldersOnly?: boolean | undefined;
    }, {
        tree: string;
        directories: number;
        files: number;
        root: string;
    }>;
    readFile: import("ai").Tool<{
        path: string;
        maxBytes?: number | undefined;
        startLine?: number | undefined;
        endLine?: number | undefined;
    }, {
        path: string;
        size: number;
        modifiedAt: string;
        truncated: boolean;
        content: string;
        lineCount: number;
    }>;
    writeFile: import("ai").Tool<{
        path: string;
        content: string;
        mode?: "append" | "overwrite" | undefined;
        createDirs?: boolean | undefined;
    }, {
        path: string;
        bytes: number;
        mode: "append" | "overwrite";
    }>;
    patchFile: import("ai").Tool<{
        path: string;
        find?: string | undefined;
        replace?: string | undefined;
        startLine?: number | undefined;
        endLine?: number | undefined;
        newContent?: string | undefined;
        replaceAll?: boolean | undefined;
    }, {
        path: string;
        changed: boolean;
        bytesBefore: number;
        bytesAfter: number;
    }>;
    grepFiles: import("ai").Tool<{
        pattern: string;
        root?: string | undefined;
        filePattern?: string | undefined;
        isRegex?: boolean | undefined;
        caseSensitive?: boolean | undefined;
        maxResults?: number | undefined;
        contextLines?: number | undefined;
        maxDepth?: number | undefined;
    }, {
        pattern: string;
        matches: {
            file: string;
            lineNumber: number;
            line: string;
            context: string[];
        }[];
        total: number;
    }>;
    createFolder: import("ai").Tool<{
        path: string;
    }, {
        path: string;
        created: boolean;
    }>;
    moveCopyRename: import("ai").Tool<{
        operation: "rename" | "move" | "copy";
        from: string;
        to: string;
        overwrite?: boolean | undefined;
    }, {
        operation: "rename" | "move" | "copy";
        from: string;
        to: string;
    }>;
    bulkMove: import("ai").Tool<{
        paths: string[];
        to: string;
        operation: "move" | "copy";
        overwrite?: boolean | undefined;
    }, {
        operation: "move" | "copy";
        destination: string;
        results: {
            from: string;
            to: string;
            status: "ok" | "error";
            error?: string;
        }[];
    }>;
    deleteFile: import("ai").Tool<{
        path: string;
    }, {
        deleted: boolean;
        path: string;
        size: number;
    }>;
    deleteFolder: import("ai").Tool<{
        path: string;
    }, {
        deleted: boolean;
        path: string;
    }>;
    getFileInfo: import("ai").Tool<{
        path: string;
    }, {
        path: string;
        absolutePath: string;
        type: string;
        extension: string | undefined;
        size: number;
        sizeKB: string;
        sizeMB: string;
        created: string;
        modified: string;
        accessed: string;
        isFile: boolean;
        isDirectory: boolean;
        isSymlink: boolean;
        mode: string;
        lineCount: number | undefined;
    }>;
    summarizeDocument: import("ai").Tool<{
        path: string;
        maxBytes?: number | undefined;
    }, {
        characters: number;
        words: number;
        summary: string;
        path: string;
        truncated: boolean;
    }>;
    diffFiles: import("ai").Tool<{
        fileA: string;
        fileB: string;
        contextLines?: number | undefined;
    }, {
        fileA: string;
        fileB: string;
        added: number;
        removed: number;
        unchanged: number;
        diff: string;
        identical: boolean;
    }>;
    diskUsage: import("ai").Tool<{
        path?: string | undefined;
        maxDepth?: number | undefined;
        topN?: number | undefined;
    }, {
        root: string;
        totalBytes: number;
        totalKB: string;
        totalMB: string;
        fileCount: number;
        dirCount: number;
        topFiles: {
            path: string;
            size: number;
            sizeKB: string;
        }[];
        topDirs: {
            dir: string;
            size: number;
            sizeKB: string;
            sizeMB: string;
        }[];
    }>;
    findDuplicateLargeFiles: import("ai").Tool<{
        root?: string | undefined;
        minSizeBytes?: number | undefined;
        maxDepth?: number | undefined;
        maxResults?: number | undefined;
    }, {
        large: {
            path: string;
            absolutePath: string;
            type: "file" | "directory";
            size: number;
            modifiedAt: string;
        }[];
        duplicateSizeGroups: {
            size: number;
            files: string[];
        }[];
    }>;
    watchFolderChanges: import("ai").Tool<{
        path?: string | undefined;
        watchName?: string | undefined;
        reset?: boolean | undefined;
        maxDepth?: number | undefined;
    }, {
        watchName: string;
        baselineSaved: boolean;
        added: string[];
        changed: string[];
        removed: string[];
    }>;
    touchFile: import("ai").Tool<{
        path: string;
    }, {
        path: string;
        created: boolean;
    }>;
    createSymlink: import("ai").Tool<{
        target: string;
        link: string;
    }, {
        link: string;
        target: string;
    }>;
    readSymlink: import("ai").Tool<{
        path: string;
    }, {
        link: string;
        target: string;
    }>;
    checkFileExists: import("ai").Tool<{
        path: string;
    }, {
        exists: boolean;
        path: string;
        type?: never;
        size?: never;
        modified?: never;
    } | {
        exists: boolean;
        path: string;
        type: string;
        size: number;
        modified: string;
    }>;
    chmodFile: import("ai").Tool<{
        path: string;
        mode: string;
    }, {
        path: string;
        mode: string;
    }>;
    grepCodebase: import("ai").Tool<{
        pattern: string;
        cwd?: string | undefined;
        glob?: string | undefined;
        limit?: number | undefined;
    }, {
        root: string;
        pattern: string;
        output: string;
        error?: never;
    } | {
        root: string;
        pattern: string;
        error: string;
        output?: never;
    }>;
    reviewWorkingTree: import("ai").Tool<{
        cwd?: string | undefined;
        focus?: string | undefined;
    }, {
        root: string;
        review: string;
    }>;
    explainSymbol: import("ai").Tool<{
        symbol: string;
        cwd?: string | undefined;
    }, {
        symbol: string;
        root: string;
        explanation: string;
        hits: string;
    }>;
    scaffoldFiles: import("ai").Tool<{
        files: {
            path: string;
            content: string;
            overwrite?: boolean | undefined;
        }[];
        cwd?: string | undefined;
    }, {
        created: string[];
        count: number;
    }>;
    runProjectChecks: import("ai").Tool<{
        cwd?: string | undefined;
        scripts?: string[] | undefined;
    }, {
        root: string;
        ran: never[];
        note: string;
        available: Record<string, string>;
        results?: never;
        allPassed?: never;
    } | {
        root: string;
        results: {
            script: string;
            output: string;
            ok: boolean;
        }[];
        allPassed: boolean;
        ran?: never;
        note?: never;
        available?: never;
    }>;
    gitStatus: import("ai").Tool<{
        short: boolean;
        cwd?: string | undefined;
    }, {
        cwd: string;
        output: string;
    }>;
    gitDiff: import("ai").Tool<{
        staged: boolean;
        cwd?: string | undefined;
        path?: string | undefined;
        commit?: string | undefined;
    }, {
        cwd: string;
        output: string;
    }>;
    gitLog: import("ai").Tool<{
        limit: number;
        cwd?: string | undefined;
        path?: string | undefined;
    }, {
        cwd: string;
        output: string;
    }>;
    gitBranch: import("ai").Tool<{
        action: "list" | "create" | "checkout";
        cwd?: string | undefined;
        name?: string | undefined;
    }, {
        cwd: string;
        branches: string;
        action?: never;
        name?: never;
        output?: never;
    } | {
        cwd: string;
        action: "create" | "checkout";
        name: string;
        output: string;
        branches?: never;
    }>;
    gitStage: import("ai").Tool<{
        paths: string[];
        cwd?: string | undefined;
    }, {
        cwd: string;
        staged: string[];
        output: string;
    }>;
    gitCommit: import("ai").Tool<{
        message: string;
        cwd?: string | undefined;
    }, {
        cwd: string;
        message: string;
        output: string;
    }>;
    applyUnifiedPatch: import("ai").Tool<{
        patch: string;
        dryRun: boolean;
        cwd?: string | undefined;
    }, {
        dryRun: boolean;
        cwd: string;
        check: string;
        applied?: never;
        output?: never;
    } | {
        cwd: string;
        applied: boolean;
        output: string;
        dryRun?: never;
        check?: never;
    }>;
    listCloudBucket: import("ai").Tool<{
        provider: "s3" | "gcs" | "vercel-blob";
        limit: number;
        bucketName?: string | undefined;
        prefix?: string | undefined;
    }, {
        error: string;
        provider?: never;
        bucket?: never;
        files?: never;
        method?: never;
    } | {
        provider: "s3";
        bucket: string | undefined;
        files: {
            key: string;
            size: number;
            lastModified: string;
            url: string;
        }[];
        error?: never;
        method?: never;
    } | {
        provider: "gcs";
        bucket: string | undefined;
        files: {
            key: any;
            size: number;
            lastModified: any;
            url: string;
        }[];
        error?: never;
        method?: never;
    } | {
        provider: "vercel-blob";
        files: {
            key: string;
            size: number;
            lastModified: string;
            url: string;
        }[];
        error?: never;
        bucket?: never;
        method?: never;
    } | {
        provider: "s3";
        bucket: string | undefined;
        method: string;
        files: ({
            key: string;
            size: number;
            isFolder: boolean;
            lastModified?: never;
            url?: never;
        } | {
            key: string;
            size: number;
            lastModified: string;
            url: string;
            isFolder?: never;
        })[];
        error?: never;
    } | {
        provider: "gcs";
        bucket: string | undefined;
        method: string;
        files: {
            key: string;
            size: number;
            lastModified: string;
            url: string;
        }[];
        error?: never;
    } | {
        provider: "vercel-blob";
        method: string;
        files: any;
        error?: never;
        bucket?: never;
    }>;
    uploadFileToCloud: import("ai").Tool<{
        provider: "s3" | "gcs" | "vercel-blob";
        localFilePath: string;
        destinationKey: string;
        bucketName?: string | undefined;
    }, {
        error: string;
        success?: never;
        provider?: never;
        bucket?: never;
        key?: never;
        url?: never;
        contentType?: never;
        method?: never;
    } | {
        success: boolean;
        provider: "s3";
        bucket: string | undefined;
        key: string;
        url: string;
        contentType: string;
        error?: never;
        method?: never;
    } | {
        success: boolean;
        provider: "gcs";
        bucket: string | undefined;
        key: string;
        url: string;
        contentType: string;
        error?: never;
        method?: never;
    } | {
        success: boolean;
        provider: "vercel-blob";
        key: string;
        url: string;
        contentType: string;
        error?: never;
        bucket?: never;
        method?: never;
    } | {
        success: boolean;
        provider: "s3";
        bucket: string | undefined;
        key: string;
        url: string;
        contentType: string;
        method: string;
        error?: never;
    } | {
        success: boolean;
        provider: "gcs";
        bucket: string | undefined;
        key: string;
        url: string;
        contentType: string;
        method: string;
        error?: never;
    } | {
        success: boolean;
        provider: "vercel-blob";
        key: string;
        url: string;
        method: string;
        error?: never;
        bucket?: never;
        contentType?: never;
    }>;
    downloadFileFromCloud: import("ai").Tool<{
        provider: "s3" | "gcs" | "vercel-blob";
        destinationKey: string;
        localFilePath: string;
        bucketName?: string | undefined;
    }, {
        error: string;
        success?: never;
        provider?: never;
        bucket?: never;
        key?: never;
        localPath?: never;
        url?: never;
        method?: never;
    } | {
        success: boolean;
        provider: "s3";
        bucket: string | undefined;
        key: string;
        localPath: string;
        error?: never;
        url?: never;
        method?: never;
    } | {
        success: boolean;
        provider: "gcs";
        bucket: string | undefined;
        key: string;
        localPath: string;
        error?: never;
        url?: never;
        method?: never;
    } | {
        success: boolean;
        provider: "vercel-blob";
        url: string;
        localPath: string;
        error?: never;
        bucket?: never;
        key?: never;
        method?: never;
    } | {
        success: boolean;
        provider: "s3";
        bucket: string | undefined;
        key: string;
        localPath: string;
        method: string;
        error?: never;
        url?: never;
    } | {
        success: boolean;
        provider: "gcs";
        bucket: string | undefined;
        key: string;
        localPath: string;
        method: string;
        error?: never;
        url?: never;
    } | {
        success: boolean;
        provider: "vercel-blob";
        url: string;
        localPath: string;
        method: string;
        error?: never;
        bucket?: never;
        key?: never;
    }>;
    deleteCloudFile: import("ai").Tool<{
        provider: "s3" | "gcs" | "vercel-blob";
        destinationKey: string;
        bucketName?: string | undefined;
        recursive?: boolean | undefined;
    }, {
        error: string;
        success?: never;
        provider?: never;
        bucket?: never;
        deletedCount?: never;
        key?: never;
        prefix?: never;
        recursive?: never;
        url?: never;
        method?: never;
    } | {
        success: boolean;
        provider: "s3";
        bucket: string | undefined;
        deletedCount: number;
        error?: never;
        key?: never;
        prefix?: never;
        recursive?: never;
        url?: never;
        method?: never;
    } | {
        success: boolean;
        provider: "s3";
        bucket: string | undefined;
        key: string;
        error?: never;
        deletedCount?: never;
        prefix?: never;
        recursive?: never;
        url?: never;
        method?: never;
    } | {
        success: boolean;
        provider: "gcs";
        bucket: string | undefined;
        prefix: string;
        recursive: boolean;
        error?: never;
        deletedCount?: never;
        key?: never;
        url?: never;
        method?: never;
    } | {
        success: boolean;
        provider: "gcs";
        bucket: string | undefined;
        key: string;
        error?: never;
        deletedCount?: never;
        prefix?: never;
        recursive?: never;
        url?: never;
        method?: never;
    } | {
        success: boolean;
        provider: "vercel-blob";
        deletedCount: number;
        error?: never;
        bucket?: never;
        key?: never;
        prefix?: never;
        recursive?: never;
        url?: never;
        method?: never;
    } | {
        success: boolean;
        provider: "vercel-blob";
        url: string;
        error?: never;
        bucket?: never;
        deletedCount?: never;
        key?: never;
        prefix?: never;
        recursive?: never;
        method?: never;
    } | {
        success: boolean;
        provider: "s3";
        bucket: string | undefined;
        key: string;
        recursive: boolean | undefined;
        method: string;
        error?: never;
        deletedCount?: never;
        prefix?: never;
        url?: never;
    } | {
        success: boolean;
        provider: "gcs";
        bucket: string | undefined;
        key: string;
        recursive: boolean | undefined;
        method: string;
        error?: never;
        deletedCount?: never;
        prefix?: never;
        url?: never;
    } | {
        success: boolean;
        provider: "vercel-blob";
        url: string;
        method: string;
        error?: never;
        bucket?: never;
        deletedCount?: never;
        key?: never;
        prefix?: never;
        recursive?: never;
    }>;
    generateCloudSignedUrl: import("ai").Tool<{
        provider: "s3" | "gcs" | "vercel-blob";
        destinationKey: string;
        expiresIn: number;
        operation: "read" | "write";
        bucketName?: string | undefined;
    }, {
        error: string;
        success?: never;
        provider?: never;
        bucket?: never;
        key?: never;
        url?: never;
        operation?: never;
        expires?: never;
        note?: never;
    } | {
        success: boolean;
        provider: "s3";
        bucket: string | undefined;
        key: string;
        url: string;
        operation: "read" | "write";
        expires: number;
        error?: never;
        note?: never;
    } | {
        success: boolean;
        provider: "gcs";
        bucket: string | undefined;
        key: string;
        url: string;
        operation: "read" | "write";
        expires: number;
        error?: never;
        note?: never;
    } | {
        success: boolean;
        provider: "vercel-blob";
        key: string;
        url: string;
        note: string;
        error?: never;
        bucket?: never;
        operation?: never;
        expires?: never;
    } | {
        success: boolean;
        error: string;
        url: string;
        provider?: never;
        bucket?: never;
        key?: never;
        operation?: never;
        expires?: never;
        note?: never;
    }>;
    listDockerContainers: import("ai").Tool<{
        all: boolean;
    }, {
        error: string;
        containers?: never;
        rawError?: never;
    } | {
        containers: any[];
        error?: never;
        rawError?: never;
    } | {
        error: string;
        rawError: any;
        containers?: never;
    }>;
    getDockerContainerLogs: import("ai").Tool<{
        container: string;
        tail: number;
    }, {
        error: string;
        container?: never;
        logs?: never;
        rawError?: never;
    } | {
        container: string;
        logs: string;
        error?: never;
        rawError?: never;
    } | {
        error: string;
        rawError: any;
        container?: never;
        logs?: never;
    }>;
    controlDockerContainer: import("ai").Tool<{
        container: string;
        action: "stop" | "start" | "restart" | "kill";
    }, {
        error: string;
        success?: never;
        container?: never;
        action?: never;
        rawError?: never;
    } | {
        success: boolean;
        container: string;
        action: "stop" | "start" | "restart" | "kill";
        error?: never;
        rawError?: never;
    } | {
        success: boolean;
        error: string;
        rawError: any;
        container?: never;
        action?: never;
    }>;
    validateEnv: import("ai").Tool<Record<string, never>, {
        error: string;
        envExists?: never;
        exampleExists?: never;
        missingInEnv?: never;
        missingInExample?: never;
        presentInBoth?: never;
    } | {
        envExists: boolean;
        exampleExists: boolean;
        missingInEnv: string[];
        missingInExample: string[];
        presentInBoth: string[];
        error?: never;
    }>;
    manageDockerCompose: import("ai").Tool<{
        action: "logs" | "down" | "ps" | "restart" | "up" | "build";
        composeFile?: string | undefined;
        services?: string[] | undefined;
    }, {
        error: string;
        success?: never;
        action?: never;
        command?: never;
        stdout?: never;
        stderr?: never;
        rawError?: never;
    } | {
        success: boolean;
        action: "logs" | "down" | "ps" | "restart" | "up" | "build";
        command: string;
        stdout: string;
        stderr: string;
        error?: never;
        rawError?: never;
    } | {
        success: boolean;
        error: string;
        rawError: any;
        action?: never;
        command?: never;
        stdout?: never;
        stderr?: never;
    }>;
    runDockerContainer: import("ai").Tool<{
        image: string;
        autoRemove: boolean;
        name?: string | undefined;
        ports?: string[] | undefined;
        env?: string[] | undefined;
        volumes?: string[] | undefined;
        restartPolicy?: "no" | "always" | "unless-stopped" | "on-failure" | undefined;
        network?: string | undefined;
        memoryLimit?: string | undefined;
    }, {
        error: string;
        success?: never;
        image?: never;
        containerId?: never;
        name?: never;
        rawError?: never;
    } | {
        success: boolean;
        image: string;
        containerId: string;
        name: string | null;
        error?: never;
        rawError?: never;
    } | {
        success: boolean;
        error: string;
        rawError: any;
        image?: never;
        containerId?: never;
        name?: never;
    }>;
    execDockerCommand: import("ai").Tool<{
        container: string;
        command: string[];
        user?: string | undefined;
        workdir?: string | undefined;
    }, {
        error: string;
        success?: never;
        container?: never;
        stdout?: never;
        stderr?: never;
        rawError?: never;
    } | {
        success: boolean;
        container: string;
        stdout: string;
        stderr: string;
        error?: never;
        rawError?: never;
    } | {
        success: boolean;
        error: string;
        rawError: any;
        container?: never;
        stdout?: never;
        stderr?: never;
    }>;
    getCurrentTime: import("ai").Tool<{
        timeZone?: string | undefined;
    }, {
        iso: string;
        unixMs: number;
        timeZone: string;
        formatted: string;
    }>;
    appBuilder: import("ai").Tool<{
        task: string;
        context?: string | undefined;
    }, string>;
    qaIntegration: import("ai").Tool<{
        task: string;
        context?: string | undefined;
    }, string>;
}, never>>;
//# sourceMappingURL=coding.agent.d.ts.map