import { ToolLoopAgent } from 'ai';
import { type ProgressEvent } from '../runtime/progress.js';
import { type ConfirmationHandler } from '../runtime/confirm.js';
import { type AskHandler } from '../runtime/ask.js';
export declare function createManagerAgent(runId?: string, options?: {
    sessionId?: 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;
    })>;
    autonomousMarketResearch: import("ai").Tool<{
        url: string;
        focus?: string | undefined;
    }, {
        url: string;
        focus: string;
        recommendedSteps: string[];
        message: string;
    }>;
    removeBackground: import("ai").Tool<{
        imagePath: string;
        outputFileName?: string | undefined;
    }, {
        inputPath: string;
        outputPath: string;
        format: string;
        status: string;
    }>;
    browserNavigate: import("ai").Tool<{
        url: string;
        waitUntil: "commit" | "load" | "domcontentloaded" | "networkidle";
    }, {
        url: string;
        title: string;
        status: string;
    }>;
    browserClick: import("ai").Tool<{
        selector: string;
        timeout: number;
    }, {
        selector: string;
        result: string;
    }>;
    browserType: import("ai").Tool<{
        selector: string;
        text: string;
        delay: number;
        pressEnter: boolean;
    }, {
        selector: string;
        result: string;
    }>;
    browserExtractContent: import("ai").Tool<{
        mode: "text" | "markdown" | "html" | "links";
        selector?: string | undefined;
    }, {
        mode: "text" | "markdown" | "html" | "links";
        result: any;
    }>;
    browserTakeScreenshot: import("ai").Tool<{
        fullPage: boolean;
    }, {
        filePath: string;
    }>;
    browserExecuteScript: import("ai").Tool<{
        script: string;
    }, {
        result: unknown;
    }>;
    browserClose: import("ai").Tool<Record<string, never>, {
        status: string;
    }>;
    visualBrowserAudit: import("ai").Tool<{
        focus?: string | undefined;
    }, {
        screenshotPath: string;
        auditPrompt: string;
        message: string;
    }>;
    getSessionHandoff: import("ai").Tool<{
        sessionId?: string | undefined;
    }, {
        sessionId: string;
        summary: string;
        nextActions: string[];
        openThreads: string[];
        updatedAt: string;
    } | null>;
    saveSessionHandoff: import("ai").Tool<{
        summary: string;
        nextActions: string[];
        sessionId?: string | undefined;
        openThreads?: string[] | undefined;
    }, {
        sessionId: string;
        summary: string;
        nextActions: string[];
        openThreads: string[];
        updatedAt: string;
    }>;
    generateSessionHandoff: import("ai").Tool<{
        sessionId?: string | undefined;
    }, {
        sessionId: string;
        summary: string;
        nextActions: string[];
        openThreads: string[];
        updatedAt: string;
    }>;
    getSituationBrief: import("ai").Tool<{
        sessionId?: string | undefined;
    }, {
        sessionId: string;
        cwd: string;
        package: string;
        platform: string;
        workspace: string;
        models: {
            manager: string;
            coding: string;
            image: string;
            overrides: Partial<Record<import("../config/model-store.js").ModelRole, string>>;
        };
        capabilities: {
            gateway: boolean;
            composio: boolean;
            redis: boolean;
            qstash: boolean;
            jobs: boolean;
            voice: boolean;
        };
        git: string;
        recentJobs: {
            id: string;
            status: import("../server.js").JobStatus;
            task: string;
        }[];
        memoryCount: number;
        owner: string;
        activeProjects: string[];
        knowledgeNodes: number;
    }>;
    recallRelevantMemories: import("ai").Tool<{
        query: string;
        limit?: number | undefined;
    }, import("../server.js").LongTermMemory[]>;
    askUserQuestion: import("ai").Tool<{
        question: string;
        options: {
            id: string;
            label: string;
            description?: string | undefined;
        }[];
        allowMultiple?: boolean | undefined;
        required?: boolean | undefined;
    }, {
        answered: boolean;
        selectedIds: never[];
        message: string;
        labels?: never;
    } | {
        answered: boolean;
        selectedIds: string[];
        labels: string[];
        message?: never;
    }>;
    generatePdf: import("ai").Tool<{
        title: string;
        content: string;
        expandWithAi?: boolean | undefined;
        audience?: string | undefined;
        filename?: string | undefined;
    }, {
        title: string;
        bytesEstimate: number;
        path: string;
        format: "pdf";
        pageEstimate: number;
    }>;
    generateSlideDeck: import("ai").Tool<{
        title: string;
        content: string;
        expandWithAi?: boolean | undefined;
        theme?: "light" | "dark" | "zilmate" | undefined;
        audience?: string | undefined;
        filename?: string | undefined;
    }, {
        title: string;
        hint: string;
        path: string;
        markdownPath: string;
        slideCount: number;
        format: "pptx";
    }>;
    sendNotification: import("ai").Tool<{
        title: string;
        message: string;
        urgency?: "critical" | "normal" | "low" | undefined;
        webhook?: string | undefined;
        slack?: string | undefined;
    }, {
        ok: boolean;
    }>;
    checkForUpdate: import("ai").Tool<Record<string, never>, {
        current: string;
        latest: string;
        updateAvailable: boolean;
        command: string;
        error?: never;
    } | {
        current: string;
        latest: null;
        updateAvailable: boolean;
        error: string;
        command: string;
    }>;
    selfUpdate: import("ai").Tool<{
        confirmed: boolean;
        tag?: string | undefined;
        dryRun?: boolean | undefined;
    }, {
        ok: boolean;
        dryRun: boolean;
        tag: string;
    }>;
    logTrustAction: import("ai").Tool<{
        action: string;
        category?: "other" | "destructive" | "outbound" | "os-control" | undefined;
        reversible?: boolean | undefined;
        undoHint?: string | undefined;
    }, import("../safety/trust-log.js").TrustAction>;
    listActiveTrustActions: import("ai").Tool<Record<string, never>, {
        undoWindowMs: number;
        actions: import("../safety/trust-log.js").TrustAction[];
    }>;
    markTrustActionUndone: import("ai").Tool<{
        id: string;
    }, null>;
    runHealPass: import("ai").Tool<{
        sessionSummary: string;
        sessionId?: string | undefined;
        recentSuccesses?: string[] | undefined;
        recentFailures?: string[] | undefined;
        deep?: boolean | undefined;
    }, import("../memory/heal.js").HealResult>;
    readHealHistory: import("ai").Tool<{
        limit?: number | undefined;
    }, Record<string, unknown>[]>;
    getKnowledgeGraph: import("ai").Tool<Record<string, never>, import("../memory/knowledge-graph.js").KnowledgeGraph>;
    setKnowledgeOwner: import("ai").Tool<{
        name: string;
    }, import("../memory/knowledge-graph.js").KnowledgeGraph>;
    upsertKnowledgeNode: import("ai").Tool<{
        label: string;
        type: "other" | "topic" | "project" | "tool" | "goal" | "person" | "org";
        parentLabel?: string | undefined;
        notes?: string | undefined;
        tags?: string[] | undefined;
    }, import("../memory/knowledge-graph.js").KnowledgeNode | {
        parent: import("../memory/knowledge-graph.js").KnowledgeNode;
        child: import("../memory/knowledge-graph.js").KnowledgeNode;
    }>;
    searchKnowledgeGraph: import("ai").Tool<{
        query: string;
        limit?: number | undefined;
    }, import("../memory/knowledge-graph.js").KnowledgeNode[]>;
    getKnowledgeTree: import("ai").Tool<{
        rootLabel?: string | undefined;
    }, Record<string, unknown>>;
    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;
    }>;
    getWorkspaceInfo: import("ai").Tool<Record<string, never>, {
        root: string;
        paths: import("../workspace/paths.js").WorkspaceLayout;
        skillCount: number;
        exists: boolean;
    }>;
    initWorkspace: import("ai").Tool<Record<string, never>, {
        ok: boolean;
        root: string;
    }>;
    installSkill: import("ai").Tool<{
        name: string;
        description: string;
        body: string;
        sourcePath?: string | undefined;
    }, {
        path: string;
        skillDir: string;
        hint: string;
    }>;
    checkSetupStatus: import("ai").Tool<{
        live?: boolean | undefined;
    }, {
        workspace: {
            root: string;
            exists: boolean;
        };
        configured: {
            gateway: boolean;
            composio: boolean;
            redis: boolean;
            jobs: boolean;
            qstash: boolean;
            triggers: boolean;
            voice: boolean;
        };
        doctor: import("../cli/doctor.js").DoctorCheck[];
        tunnel: {
            name: string;
            ok: boolean;
            detail: string;
        };
        secureSetupHint: string;
    }>;
    launchSecureSetup: import("ai").Tool<{
        section?: "all" | "workspace" | "gateway" | "voice" | "redis" | "jobs" | "composio" | "tavily" | "qstash" | undefined;
    }, {
        instruction: string;
        command: string;
        note: string;
    }>;
    configureSafeSetting: import("ai").Tool<{
        key: string;
        value: string;
        envPath?: string | undefined;
    }, {
        ok: boolean;
        key: string;
        value: string;
        envPath: string;
        reloadHint: string;
    }>;
    initWorkspaceFromAgent: import("ai").Tool<Record<string, never>, {
        root: string;
        paths: import("../workspace/paths.js").WorkspaceLayout;
    }>;
    getPersonalContext: import("ai").Tool<Record<string, never>, {
        context: import("../memory/personal-context.js").PersonalContext;
        summary: string;
    }>;
    updatePersonalContext: import("ai").Tool<{
        ownerName?: string | undefined;
        businessName?: string | undefined;
        urgencyRule?: string | undefined;
        workflow?: string | undefined;
        contact?: {
            name: string;
            vip: boolean;
            id?: string | undefined;
            email?: string | undefined;
            handle?: string | undefined;
            role?: string | undefined;
            notes?: string | undefined;
        } | undefined;
        project?: {
            name: string;
            status: "done" | "active" | "paused";
            tags: string[];
            id?: string | undefined;
            description?: string | undefined;
        } | undefined;
    }, {
        updated: boolean;
        summary: 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;
    }>;
    dragAndDrop: import("ai").Tool<{
        fromX: number;
        fromY: number;
        toX: number;
        toY: number;
        duration: number;
        button: "left" | "right" | "middle";
    }, {
        fromX: number;
        fromY: number;
        toX: number;
        toY: number;
        result: string;
    }>;
    findOnScreen: import("ai").Tool<{
        referenceImagePath: string;
        confidence: number;
        region?: {
            x: number;
            y: number;
            width: number;
            height: number;
        } | undefined;
    }, any>;
    manageWindow: import("ai").Tool<{
        action: "list" | "close" | "focus" | "resize" | "minimize" | "maximize";
        title?: string | undefined;
        x?: number | undefined;
        y?: number | undefined;
        width?: number | undefined;
        height?: number | undefined;
    }, any>;
    readScreen: import("ai").Tool<{
        region?: {
            x: number;
            y: number;
            width: number;
            height: number;
        } | undefined;
    }, {
        filePath: string;
        width: number | undefined;
        height: number | undefined;
    }>;
    keyboardAction: import("ai").Tool<{
        action: "type" | "press" | "hotkey";
        interval: number;
        text?: string | undefined;
        key?: string | undefined;
        hotkey?: string[] | undefined;
    }, {
        action: "type" | "press" | "hotkey";
        result: string;
    }>;
    mouseAction: import("ai").Tool<{
        action: "move" | "click" | "scroll" | "doubleClick" | "rightClick";
        x: number;
        y: number;
        scrollAmount: number;
        duration: number;
        scrollDirection?: "left" | "right" | "down" | "up" | undefined;
    }, {
        action: "move" | "click" | "scroll" | "doubleClick" | "rightClick";
        x: number;
        y: number;
        result: string;
    }>;
    installComputerUseDeps: import("ai").Tool<Record<string, never>, {
        platform: NodeJS.Platform;
        results: Record<string, string>;
    }>;
    addMCPServer: import("ai").Tool<{
        name: string;
        type: "stdio" | "http" | "sse";
        command?: string | undefined;
        args?: string[] | undefined;
        env?: Record<string, string> | undefined;
        url?: string | undefined;
        headers?: Record<string, string> | undefined;
    }, {
        error: string;
        status?: never;
    } | {
        status: string;
        error?: never;
    }>;
    listMCPServers: import("ai").Tool<Record<string, never>, {
        servers: {
            name: string;
            type: "stdio" | "http" | "sse";
            enabled: boolean;
            active: boolean;
        }[];
    }>;
    removeMCPServer: import("ai").Tool<{
        name: string;
    }, {
        error: string;
        status?: never;
    } | {
        status: string;
        error?: never;
    }>;
    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[]>;
    listTriggerTypes: import("ai").Tool<{
        toolkit?: string | undefined;
        limit?: number | undefined;
    }, {
        items: {
            slug: string;
            name: string;
            description: string;
            toolkit: {
                slug: string;
                name: string;
                logo: string;
            };
            config: Record<string, unknown>;
            payload: Record<string, unknown>;
            version?: string | undefined;
            instructions?: string | undefined;
        }[];
        totalPages: number;
        nextCursor?: string | null | undefined;
    }>;
    showTriggerType: import("ai").Tool<{
        triggerSlug: string;
    }, {
        slug: string;
        name: string;
        description: string;
        toolkit: {
            slug: string;
            name: string;
            logo: string;
        };
        config: Record<string, unknown>;
        payload: Record<string, unknown>;
        version?: string | undefined;
        instructions?: string | undefined;
    }>;
    listTriggers: import("ai").Tool<{
        limit?: number | undefined;
        showDisabled?: boolean | undefined;
    }, {
        items: {
            connectedAccountId: string;
            id: string;
            updatedAt: string;
            disabledAt: string | null;
            state: Record<string, unknown>;
            triggerConfig: Record<string, unknown>;
            triggerName: string;
            uuid?: string | undefined;
            triggerData?: string | undefined;
        }[];
        nextCursor: string | null;
        totalPages: number;
    }>;
    createTrigger: import("ai").Tool<{
        triggerSlug: string;
        triggerConfig?: Record<string, unknown> | undefined;
        connectedAccountId?: string | undefined;
        dryRun?: boolean | undefined;
    }, {
        triggerId: string;
    } | {
        triggerConfig?: Record<string, unknown>;
        connectedAccountId?: string;
        userId: string;
        triggerSlug: string;
        dryRun: boolean;
    }>;
    createJob: import("ai").Tool<{
        task: string;
        schedule?: string | undefined;
        runAt?: string | undefined;
        priority?: "critical" | "high" | "normal" | "low" | undefined;
        dependsOn?: string[] | undefined;
        tags?: string[] | undefined;
        notify?: {
            on: ("success" | "start" | "failure")[];
            slack?: string | undefined;
            email?: string | undefined;
            desktop?: boolean | undefined;
            webhook?: string | undefined;
        } | undefined;
        timeoutMs?: number | undefined;
        requiresApproval?: boolean | undefined;
        concurrencyGroup?: string | undefined;
        metadata?: Record<string, unknown> | undefined;
    }, import("../server.js").ZilMateJob>;
    listJobs: import("ai").Tool<{
        status?: "running" | "failed" | "queued" | "succeeded" | "cancelled" | "waiting" | undefined;
        priority?: "critical" | "high" | "normal" | "low" | undefined;
        tags?: string[] | undefined;
        concurrencyGroup?: string | undefined;
        limit?: number | undefined;
    }, import("../server.js").ZilMateJob[]>;
    showJob: import("ai").Tool<{
        id: string;
    }, import("../server.js").ZilMateJob | null>;
    listJobLogs: import("ai").Tool<{
        id: string;
    }, import("../server.js").JobLog[]>;
    cancelJob: import("ai").Tool<{
        id: string;
    }, import("../server.js").ZilMateJob | null>;
    approveJob: import("ai").Tool<{
        id: string;
    }, import("../server.js").ZilMateJob | null>;
    getJobStats: import("ai").Tool<Record<string, never>, import("../jobs/types.js").JobStats>;
    resolveJobDependencies: import("ai").Tool<Record<string, never>, {
        resolved: number;
        jobs: import("../server.js").ZilMateJob[];
    }>;
    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;
    }>;
    transcodeVideo: import("ai").Tool<{
        inputPath: string;
        outputPath: string;
        resolution?: string | undefined;
        fps?: number | undefined;
        durationSeconds?: number | undefined;
        codec?: string | undefined;
    }, {
        error: string;
        success?: never;
        inputPath?: never;
        outputPath?: never;
        rawError?: never;
    } | {
        success: boolean;
        inputPath: string;
        outputPath: string;
        error?: never;
        rawError?: never;
    } | {
        success: boolean;
        error: string;
        rawError: any;
        inputPath?: never;
        outputPath?: never;
    }>;
    extractAudio: import("ai").Tool<{
        videoPath: string;
        audioOutputPath: string;
    }, {
        error: string;
        success?: never;
        videoPath?: never;
        audioOutputPath?: never;
        rawError?: never;
    } | {
        success: boolean;
        videoPath: string;
        audioOutputPath: string;
        error?: never;
        rawError?: never;
    } | {
        success: boolean;
        error: string;
        rawError: any;
        videoPath?: never;
        audioOutputPath?: never;
    }>;
    speechToText: import("ai").Tool<{
        audioPath: string;
        language?: string | undefined;
    }, {
        error: string;
        audioPath?: never;
        provider?: never;
        model?: never;
        confidence?: never;
        transcript?: never;
    } | {
        audioPath: string;
        provider: string;
        model: string;
        confidence: any;
        transcript: any;
        error?: never;
    } | {
        audioPath: string;
        provider: string;
        model: string;
        transcript: any;
        error?: never;
        confidence?: never;
    }>;
    optimizeImage: import("ai").Tool<{
        imagePath: string;
        outputPath: string;
        quality: number;
        maxWidth?: number | undefined;
        maxHeight?: number | undefined;
        format?: "png" | "jpeg" | "webp" | undefined;
        watermarkText?: string | undefined;
    }, {
        error: string;
        success?: never;
        imagePath?: never;
        outputPath?: never;
        quality?: never;
        watermarked?: never;
        rawError?: never;
    } | {
        success: boolean;
        imagePath: string;
        outputPath: string;
        quality: number;
        watermarked: boolean;
        error?: never;
        rawError?: never;
    } | {
        success: boolean;
        error: string;
        rawError: any;
        imagePath?: never;
        outputPath?: never;
        quality?: never;
        watermarked?: never;
    }>;
    textToSpeech: import("ai").Tool<{
        text: string;
        outputPath: string;
        voice?: string | undefined;
    }, {
        success: boolean;
        provider: string;
        model: string;
        outputPath: string;
        error?: never;
    } | {
        error: string;
        success?: never;
        provider?: never;
        model?: never;
        outputPath?: never;
    }>;
    listOpenPorts: import("ai").Tool<Record<string, never>, {
        ports: any;
        error?: never;
        rawError?: never;
    } | {
        error: string;
        rawError: any;
        ports?: never;
    }>;
    pingHost: import("ai").Tool<{
        host: string;
    }, {
        host: string;
        success: boolean;
        output: string;
        error?: never;
        rawError?: never;
    } | {
        host: string;
        success: boolean;
        error: string;
        rawError: any;
        output?: never;
    }>;
    traceRoute: import("ai").Tool<{
        host: string;
    }, {
        host: string;
        output: string;
        error?: never;
        rawError?: never;
    } | {
        host: string;
        error: string;
        rawError: any;
        output?: never;
    }>;
    getDatabaseSchema: import("ai").Tool<{
        databasePath: string;
    }, {
        error: string;
        databasePath?: never;
        method?: never;
        schema?: never;
        tables?: never;
    } | {
        databasePath: string;
        method: string;
        schema: string;
        error?: never;
        tables?: never;
    } | {
        databasePath: string;
        method: string;
        schema: any;
        tables: any;
        error?: never;
    }>;
    runDatabaseQuery: import("ai").Tool<{
        databasePath: string;
        sql: string;
    }, any>;
    listSystemProcesses: import("ai").Tool<{
        sortBy: "memory" | "cpu" | "pid";
        limit: number;
        filterName?: string | undefined;
    }, {
        processes: {
            pid: number;
            name: string;
            cpu: number;
            memory: number;
        }[];
        error?: never;
        rawError?: never;
    } | {
        error: string;
        rawError: any;
        processes?: never;
    }>;
    killSystemProcess: import("ai").Tool<{
        force: boolean;
        pid?: number | undefined;
        name?: string | undefined;
        port?: number | undefined;
    }, {
        error: string;
        success?: never;
        killedPids?: never;
        name?: never;
        rawError?: never;
    } | {
        success: boolean;
        error: string;
        killedPids?: never;
        name?: never;
        rawError?: never;
    } | {
        success: boolean;
        killedPids: number[];
        error?: never;
        name?: never;
        rawError?: never;
    } | {
        success: boolean;
        name: string;
        error?: never;
        killedPids?: never;
        rawError?: never;
    } | {
        success: boolean;
        error: string;
        rawError: any;
        killedPids?: never;
        name?: never;
    }>;
    getSystemMetrics: import("ai").Tool<Record<string, never>, {
        success: boolean;
        metrics: {
            os: {
                name: string;
                platform: NodeJS.Platform;
                release: string;
                architecture: NodeJS.Architecture;
                uptimeSeconds: number;
                uptimeHours: number;
            };
            cpu: {
                activeUtilizationPercent: number;
                cores: number;
                model: string;
            };
            memory: {
                totalGb: number;
                freeGb: number;
                usedGb: number;
                utilizationPercent: number;
            };
            disk: {
                workspacePath: string;
                totalGb: number;
                freeGb: number;
                usedGb: number;
                utilizationPercent: number;
            };
        };
        error?: never;
        rawError?: never;
    } | {
        success: boolean;
        error: string;
        rawError: any;
        metrics?: 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;
    }>;
    readClipboard: import("ai").Tool<{
        maxCharacters?: number | undefined;
    }, {
        characters: number;
        truncated: boolean;
        text: string;
    }>;
    writeClipboard: import("ai").Tool<{
        text: string;
    }, {
        copied: boolean;
        characters: number;
    }>;
    takeScreenshot: import("ai").Tool<Record<string, never>, {
        file: string;
    }>;
    analyzeScreenshot: import("ai").Tool<{
        path?: string | undefined;
        prompt?: string | undefined;
        searchWeb?: boolean | undefined;
        maxSearchResults?: number | undefined;
    }, {
        webResults?: import("../tools/web-search.tool.js").WebSearchResult[];
        file: string;
        model: string;
        analysis: string;
    }>;
    takeCameraPhoto: import("ai").Tool<{
        device?: string | undefined;
    }, {
        file: string;
    }>;
    analyzeCameraPhoto: import("ai").Tool<{
        device?: string | undefined;
        prompt?: string | undefined;
        searchWeb?: boolean | undefined;
        maxSearchResults?: number | undefined;
    }, {
        webResults?: import("../tools/web-search.tool.js").WebSearchResult[];
        file: string;
        model: string;
        analysis: string;
    }>;
    openFile: import("ai").Tool<{
        path: string;
    }, {
        opened: boolean;
        path: string;
        error?: never;
    } | {
        opened: boolean;
        error: any;
        path?: never;
    }>;
    openApplication: import("ai").Tool<{
        application: string;
        args?: string[] | undefined;
    }, {
        opened: boolean;
        application: string;
        error?: never;
    } | {
        opened: boolean;
        error: any;
        application?: never;
    }>;
    listRunningApplications: import("ai").Tool<{
        filter?: string | undefined;
        limit?: number | undefined;
    }, {
        applications: string[];
        count: number;
        filtered: boolean;
        platform: NodeJS.Platform;
        error?: never;
    } | {
        error: any;
        applications: never[];
        count: number;
        filtered?: never;
        platform?: never;
    }>;
    simulateKeyboard: import("ai").Tool<{
        input: string;
    }, {
        sent: boolean;
        input: string;
        error?: never;
    } | {
        sent: boolean;
        error: any;
        input?: never;
    }>;
    simulateMouse: import("ai").Tool<{
        action: "move" | "click" | "double-click" | "right-click" | "drag" | "scroll";
        x?: number | undefined;
        y?: number | undefined;
        endX?: number | undefined;
        endY?: number | undefined;
        scrollAmount?: number | undefined;
    }, {
        success: boolean;
        action: "move" | "click" | "double-click" | "right-click" | "drag" | "scroll";
        error?: never;
    } | {
        success: boolean;
        error: any;
        action?: never;
    }>;
    displaySystemNotification: import("ai").Tool<{
        title: string;
        message: string;
    }, {
        success: boolean;
        error?: never;
    } | {
        success: boolean;
        error: any;
    }>;
    recordAudioSnippet: import("ai").Tool<{
        durationSeconds: number;
    }, {
        success: boolean;
        file: string;
        durationSeconds: number;
        error?: never;
    } | {
        success: boolean;
        error: any;
        file?: never;
        durationSeconds?: never;
    }>;
    getActiveWindowContext: import("ai").Tool<Record<string, never>, {
        title?: string;
        process?: string;
        pid?: number;
        success: boolean;
        error?: never;
    } | {
        success: boolean;
        error: any;
    }>;
    controlSystemVolume: import("ai").Tool<{
        action: "set" | "get" | "mute" | "unmute" | "media-play-pause" | "media-next" | "media-prev";
        level?: number | undefined;
    }, {
        success: boolean;
        action: "media-play-pause";
        level?: never;
        error?: never;
    } | {
        success: boolean;
        action: "media-next";
        level?: never;
        error?: never;
    } | {
        success: boolean;
        action: "media-prev";
        level?: never;
        error?: never;
    } | {
        success: boolean;
        action: "mute";
        level?: never;
        error?: never;
    } | {
        success: boolean;
        action: "unmute";
        level?: never;
        error?: never;
    } | {
        success: boolean;
        action: "set";
        level: number;
        error?: never;
    } | {
        success: boolean;
        error: string;
        action?: never;
        level?: never;
    } | {
        success: boolean;
        level: number;
        action?: never;
        error?: never;
    } | {
        success: boolean;
        error: any;
    }>;
    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;
    }>;
    getWeather: import("ai").Tool<{
        location: string;
    }, {
        location: string;
        coordinates: {
            lat: number;
            lon: number;
        };
        current: {
            temperature: {
                value: number;
                unit: string;
            };
            feelsLike: {
                value: number;
                unit: string;
            };
            humidity: {
                value: number;
                unit: string;
            };
            windSpeed: {
                value: number;
                unit: string;
            };
            condition: string;
            emoji: string;
        };
        today: {
            high: {
                value: number;
                unit: string;
            };
            low: {
                value: number;
                unit: string;
            };
            precipitationChance: {
                value: number;
                unit: string;
            };
        } | null;
    }>;
    getForecast: import("ai").Tool<{
        location: string;
        days: number;
    }, {
        location: string;
        coordinates: {
            lat: number;
            lon: number;
        };
        forecast: {
            date: string;
            condition: string;
            emoji: string;
            high: {
                value: number;
                unit: string;
            };
            low: {
                value: number;
                unit: string;
            };
            precipitationChance: {
                value: number;
                unit: string;
            };
            windMax: {
                value: number;
                unit: string;
            };
        }[];
    }>;
    getCurrentLocation: import("ai").Tool<Record<string, never>, {
        ip: string;
        city: string;
        region: string;
        country: string;
        coordinates: {
            lat: number;
            lon: number;
        };
        displayName: string;
    }>;
    getCurrentTime: import("ai").Tool<{
        timeZone?: string | undefined;
    }, {
        iso: string;
        unixMs: number;
        timeZone: string;
        formatted: string;
    }>;
    rememberMemory: import("ai").Tool<{
        text: string;
        tags?: string[] | undefined;
    }, import("../server.js").LongTermMemory>;
    recallMemory: import("ai").Tool<{
        query?: string | undefined;
        limit?: number | undefined;
    }, import("../server.js").LongTermMemory[]>;
    listMemory: import("ai").Tool<Record<string, never>, import("../server.js").LongTermMemory[]>;
    forgetMemory: import("ai").Tool<{
        id: string;
    }, {
        id: string;
        deleted: boolean;
    }>;
    listZiloDocs: import("ai").Tool<Record<string, never>, {
        key: string;
        title: string;
        description: string;
    }[]>;
    readZiloDoc: import("ai").Tool<{
        key: string;
        maxChars?: number | undefined;
    }, {
        key: string;
        title: string;
        description: string;
        content: string;
    }>;
    searchZiloDocs: import("ai").Tool<{
        query: string;
        maxResults?: number | undefined;
    }, {
        key: string;
        title: string;
        description: string;
        snippet: string;
    }[]>;
    quickHelp: import("ai").Tool<{
        prompt: string;
    }, string>;
    chat: import("ai").Tool<{
        prompt: string;
    }, string>;
    post: import("ai").Tool<{
        prompt: string;
    }, string>;
    image: import("ai").Tool<{
        prompt: string;
    }, string>;
    research: import("ai").Tool<{
        prompt: string;
    }, string>;
    automationPlanner: import("ai").Tool<{
        prompt: string;
    }, string>;
    personalAssistant: import("ai").Tool<{
        prompt: string;
    }, string>;
    developerHelper: import("ai").Tool<{
        prompt: string;
    }, string>;
    security: import("ai").Tool<{
        prompt: string;
    }, string>;
    coding: import("ai").Tool<{
        prompt: string;
    }, string>;
    goalManager: import("ai").Tool<{
        prompt: string;
    }, string>;
    finance: import("ai").Tool<{
        prompt: string;
    }, string>;
    digitalCorporation: import("ai").Tool<{
        prompt: string;
    }, string>;
}, never>>;
export declare function runManager(prompt: string, options?: {
    progress?: (event: ProgressEvent) => void;
    runId?: string;
    sessionId?: string;
    confirm?: ConfirmationHandler;
    ask?: AskHandler;
    abortSignal?: AbortSignal;
}): Promise<string>;
//# sourceMappingURL=manager.d.ts.map