import { z } from 'zod';
export declare const AgentName: z.ZodEnum<["qwen", "gemini", "aider", "goose", "codex", "opencode", "claude"]>;
export type AgentName = z.infer<typeof AgentName>;
export declare const AuthStatus: z.ZodEnum<["ready", "needs_login", "needs_api_key", "needs_setup"]>;
export type AuthStatus = z.infer<typeof AuthStatus>;
export declare const InputMethod: z.ZodEnum<["flag", "stdin", "positional", "subcommand"]>;
export type InputMethod = z.infer<typeof InputMethod>;
export declare const TaskConfig: z.ZodObject<{
    model: z.ZodOptional<z.ZodString>;
    files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    timeout: z.ZodDefault<z.ZodNumber>;
    retries: z.ZodDefault<z.ZodNumber>;
    sandbox: z.ZodOptional<z.ZodBoolean>;
    workingDirectory: z.ZodOptional<z.ZodString>;
    allowFallback: z.ZodDefault<z.ZodBoolean>;
    fallbackAgents: z.ZodOptional<z.ZodArray<z.ZodEnum<["qwen", "gemini", "aider", "goose", "codex", "opencode", "claude"]>, "many">>;
    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    flags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    context: z.ZodOptional<z.ZodObject<{
        stdin: z.ZodOptional<z.ZodString>;
        environment: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, "strip", z.ZodTypeAny, {
        stdin?: string | undefined;
        environment?: Record<string, string> | undefined;
    }, {
        stdin?: string | undefined;
        environment?: Record<string, string> | undefined;
    }>>;
    smartSummary: z.ZodOptional<z.ZodBoolean>;
}, "strict", z.ZodTypeAny, {
    timeout: number;
    retries: number;
    allowFallback: boolean;
    model?: string | undefined;
    files?: string[] | undefined;
    sandbox?: boolean | undefined;
    workingDirectory?: string | undefined;
    fallbackAgents?: ("qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude")[] | undefined;
    env?: Record<string, string> | undefined;
    flags?: string[] | undefined;
    context?: {
        stdin?: string | undefined;
        environment?: Record<string, string> | undefined;
    } | undefined;
    smartSummary?: boolean | undefined;
}, {
    model?: string | undefined;
    files?: string[] | undefined;
    timeout?: number | undefined;
    retries?: number | undefined;
    sandbox?: boolean | undefined;
    workingDirectory?: string | undefined;
    allowFallback?: boolean | undefined;
    fallbackAgents?: ("qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude")[] | undefined;
    env?: Record<string, string> | undefined;
    flags?: string[] | undefined;
    context?: {
        stdin?: string | undefined;
        environment?: Record<string, string> | undefined;
    } | undefined;
    smartSummary?: boolean | undefined;
}>;
export type TaskConfig = z.infer<typeof TaskConfig>;
export declare const AgentDetectionResult: z.ZodObject<{
    name: z.ZodEnum<["qwen", "gemini", "aider", "goose", "codex", "opencode", "claude"]>;
    available: z.ZodBoolean;
    version: z.ZodOptional<z.ZodString>;
    authStatus: z.ZodEnum<["ready", "needs_login", "needs_api_key", "needs_setup"]>;
    authInstructions: z.ZodString;
    inputMethod: z.ZodEnum<["flag", "stdin", "positional", "subcommand"]>;
    autoAcceptFlag: z.ZodOptional<z.ZodString>;
    modelFlag: z.ZodOptional<z.ZodString>;
    requiresSubcommand: z.ZodOptional<z.ZodString>;
}, "strict", z.ZodTypeAny, {
    name: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
    available: boolean;
    authStatus: "ready" | "needs_login" | "needs_api_key" | "needs_setup";
    authInstructions: string;
    inputMethod: "flag" | "stdin" | "positional" | "subcommand";
    version?: string | undefined;
    autoAcceptFlag?: string | undefined;
    modelFlag?: string | undefined;
    requiresSubcommand?: string | undefined;
}, {
    name: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
    available: boolean;
    authStatus: "ready" | "needs_login" | "needs_api_key" | "needs_setup";
    authInstructions: string;
    inputMethod: "flag" | "stdin" | "positional" | "subcommand";
    version?: string | undefined;
    autoAcceptFlag?: string | undefined;
    modelFlag?: string | undefined;
    requiresSubcommand?: string | undefined;
}>;
export type AgentDetectionResult = z.infer<typeof AgentDetectionResult>;
export declare const ExecutionAttempt: z.ZodObject<{
    agent: z.ZodEnum<["qwen", "gemini", "aider", "goose", "codex", "opencode", "claude"]>;
    status: z.ZodEnum<["success", "failed", "busy", "unavailable"]>;
    error: z.ZodOptional<z.ZodString>;
    startTime: z.ZodOptional<z.ZodNumber>;
    endTime: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    status: "success" | "failed" | "busy" | "unavailable";
    agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
    error?: string | undefined;
    startTime?: number | undefined;
    endTime?: number | undefined;
}, {
    status: "success" | "failed" | "busy" | "unavailable";
    agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
    error?: string | undefined;
    startTime?: number | undefined;
    endTime?: number | undefined;
}>;
export type ExecutionAttempt = z.infer<typeof ExecutionAttempt>;
export declare const RunAgentResponse: z.ZodObject<{
    success: z.ZodBoolean;
    taskId: z.ZodString;
    agent: z.ZodEnum<["qwen", "gemini", "aider", "goose", "codex", "opencode", "claude"]>;
    executedBy: z.ZodOptional<z.ZodEnum<["qwen", "gemini", "aider", "goose", "codex", "opencode", "claude"]>>;
    fallbackUsed: z.ZodBoolean;
    attempts: z.ZodArray<z.ZodObject<{
        agent: z.ZodEnum<["qwen", "gemini", "aider", "goose", "codex", "opencode", "claude"]>;
        status: z.ZodEnum<["success", "failed", "busy", "unavailable"]>;
        error: z.ZodOptional<z.ZodString>;
        startTime: z.ZodOptional<z.ZodNumber>;
        endTime: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        status: "success" | "failed" | "busy" | "unavailable";
        agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
        error?: string | undefined;
        startTime?: number | undefined;
        endTime?: number | undefined;
    }, {
        status: "success" | "failed" | "busy" | "unavailable";
        agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
        error?: string | undefined;
        startTime?: number | undefined;
        endTime?: number | undefined;
    }>, "many">;
    output: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
    success: boolean;
    taskId: string;
    fallbackUsed: boolean;
    attempts: {
        status: "success" | "failed" | "busy" | "unavailable";
        agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
        error?: string | undefined;
        startTime?: number | undefined;
        endTime?: number | undefined;
    }[];
    executedBy?: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude" | undefined;
    output?: string[] | undefined;
}, {
    agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
    success: boolean;
    taskId: string;
    fallbackUsed: boolean;
    attempts: {
        status: "success" | "failed" | "busy" | "unavailable";
        agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
        error?: string | undefined;
        startTime?: number | undefined;
        endTime?: number | undefined;
    }[];
    executedBy?: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude" | undefined;
    output?: string[] | undefined;
}>;
export type RunAgentResponse = z.infer<typeof RunAgentResponse>;
export declare const AgentStatus: z.ZodObject<{
    name: z.ZodEnum<["qwen", "gemini", "aider", "goose", "codex", "opencode", "claude"]>;
    available: z.ZodBoolean;
    status: z.ZodEnum<["ready", "busy", "needs_auth", "not_installed"]>;
    version: z.ZodOptional<z.ZodString>;
    currentTasks: z.ZodNumber;
    maxConcurrent: z.ZodNumber;
    authInstructions: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    status: "ready" | "busy" | "needs_auth" | "not_installed";
    name: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
    available: boolean;
    currentTasks: number;
    maxConcurrent: number;
    version?: string | undefined;
    authInstructions?: string | undefined;
}, {
    status: "ready" | "busy" | "needs_auth" | "not_installed";
    name: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
    available: boolean;
    currentTasks: number;
    maxConcurrent: number;
    version?: string | undefined;
    authInstructions?: string | undefined;
}>;
export type AgentStatus = z.infer<typeof AgentStatus>;
export declare const ListAgentsResponse: z.ZodObject<{
    agents: z.ZodArray<z.ZodObject<{
        name: z.ZodEnum<["qwen", "gemini", "aider", "goose", "codex", "opencode", "claude"]>;
        available: z.ZodBoolean;
        status: z.ZodEnum<["ready", "busy", "needs_auth", "not_installed"]>;
        version: z.ZodOptional<z.ZodString>;
        currentTasks: z.ZodNumber;
        maxConcurrent: z.ZodNumber;
        authInstructions: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        status: "ready" | "busy" | "needs_auth" | "not_installed";
        name: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
        available: boolean;
        currentTasks: number;
        maxConcurrent: number;
        version?: string | undefined;
        authInstructions?: string | undefined;
    }, {
        status: "ready" | "busy" | "needs_auth" | "not_installed";
        name: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
        available: boolean;
        currentTasks: number;
        maxConcurrent: number;
        version?: string | undefined;
        authInstructions?: string | undefined;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    agents: {
        status: "ready" | "busy" | "needs_auth" | "not_installed";
        name: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
        available: boolean;
        currentTasks: number;
        maxConcurrent: number;
        version?: string | undefined;
        authInstructions?: string | undefined;
    }[];
}, {
    agents: {
        status: "ready" | "busy" | "needs_auth" | "not_installed";
        name: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
        available: boolean;
        currentTasks: number;
        maxConcurrent: number;
        version?: string | undefined;
        authInstructions?: string | undefined;
    }[];
}>;
export type ListAgentsResponse = z.infer<typeof ListAgentsResponse>;
export declare const TaskStatus: z.ZodObject<{
    taskId: z.ZodString;
    status: z.ZodEnum<["queued", "running", "completed", "failed", "cancelled"]>;
    agent: z.ZodEnum<["qwen", "gemini", "aider", "goose", "codex", "opencode", "claude"]>;
    startTime: z.ZodOptional<z.ZodNumber>;
    endTime: z.ZodOptional<z.ZodNumber>;
    duration: z.ZodOptional<z.ZodNumber>;
    output: z.ZodArray<z.ZodString, "many">;
    error: z.ZodOptional<z.ZodString>;
    progress: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    status: "failed" | "queued" | "running" | "completed" | "cancelled";
    agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
    taskId: string;
    output: string[];
    error?: string | undefined;
    startTime?: number | undefined;
    endTime?: number | undefined;
    duration?: number | undefined;
    progress?: number | undefined;
}, {
    status: "failed" | "queued" | "running" | "completed" | "cancelled";
    agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
    taskId: string;
    output: string[];
    error?: string | undefined;
    startTime?: number | undefined;
    endTime?: number | undefined;
    duration?: number | undefined;
    progress?: number | undefined;
}>;
export type TaskStatus = z.infer<typeof TaskStatus>;
export declare const StreamingTaskStatus: z.ZodObject<{
    taskId: z.ZodString;
    status: z.ZodEnum<["queued", "running", "completed", "failed", "cancelled"]>;
    agent: z.ZodEnum<["qwen", "gemini", "aider", "goose", "codex", "opencode", "claude"]>;
    startTime: z.ZodOptional<z.ZodNumber>;
    endTime: z.ZodOptional<z.ZodNumber>;
    duration: z.ZodOptional<z.ZodNumber>;
    lines: z.ZodArray<z.ZodObject<{
        lineNumber: z.ZodNumber;
        content: z.ZodString;
        timestamp: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        lineNumber: number;
        content: string;
        timestamp?: number | undefined;
    }, {
        lineNumber: number;
        content: string;
        timestamp?: number | undefined;
    }>, "many">;
    totalLines: z.ZodNumber;
    hasMore: z.ZodBoolean;
    lastSeenLine: z.ZodNumber;
    newLinesCount: z.ZodNumber;
    error: z.ZodOptional<z.ZodString>;
    progress: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    status: "failed" | "queued" | "running" | "completed" | "cancelled";
    agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
    taskId: string;
    lines: {
        lineNumber: number;
        content: string;
        timestamp?: number | undefined;
    }[];
    totalLines: number;
    hasMore: boolean;
    lastSeenLine: number;
    newLinesCount: number;
    error?: string | undefined;
    startTime?: number | undefined;
    endTime?: number | undefined;
    duration?: number | undefined;
    progress?: number | undefined;
}, {
    status: "failed" | "queued" | "running" | "completed" | "cancelled";
    agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
    taskId: string;
    lines: {
        lineNumber: number;
        content: string;
        timestamp?: number | undefined;
    }[];
    totalLines: number;
    hasMore: boolean;
    lastSeenLine: number;
    newLinesCount: number;
    error?: string | undefined;
    startTime?: number | undefined;
    endTime?: number | undefined;
    duration?: number | undefined;
    progress?: number | undefined;
}>;
export type StreamingTaskStatus = z.infer<typeof StreamingTaskStatus>;
export declare const GetTaskStatusRequest: z.ZodObject<{
    taskId: z.ZodString;
    outputOptions: z.ZodOptional<z.ZodObject<{
        offset: z.ZodOptional<z.ZodNumber>;
        limit: z.ZodOptional<z.ZodNumber>;
        fromEnd: z.ZodOptional<z.ZodBoolean>;
        maxChars: z.ZodOptional<z.ZodNumber>;
        search: z.ZodOptional<z.ZodString>;
        context: z.ZodOptional<z.ZodNumber>;
        outputMode: z.ZodOptional<z.ZodEnum<["content", "matches_only", "count"]>>;
        ignoreCase: z.ZodOptional<z.ZodBoolean>;
        matchNumbers: z.ZodOptional<z.ZodBoolean>;
        streaming: z.ZodOptional<z.ZodObject<{
            lastSeenLine: z.ZodOptional<z.ZodNumber>;
            waitForNew: z.ZodOptional<z.ZodBoolean>;
            maxWaitTime: z.ZodOptional<z.ZodNumber>;
            includeLineNumbers: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            lastSeenLine?: number | undefined;
            waitForNew?: boolean | undefined;
            maxWaitTime?: number | undefined;
            includeLineNumbers?: boolean | undefined;
        }, {
            lastSeenLine?: number | undefined;
            waitForNew?: boolean | undefined;
            maxWaitTime?: number | undefined;
            includeLineNumbers?: boolean | undefined;
        }>>;
    }, "strip", z.ZodTypeAny, {
        context?: number | undefined;
        offset?: number | undefined;
        limit?: number | undefined;
        fromEnd?: boolean | undefined;
        maxChars?: number | undefined;
        search?: string | undefined;
        outputMode?: "content" | "matches_only" | "count" | undefined;
        ignoreCase?: boolean | undefined;
        matchNumbers?: boolean | undefined;
        streaming?: {
            lastSeenLine?: number | undefined;
            waitForNew?: boolean | undefined;
            maxWaitTime?: number | undefined;
            includeLineNumbers?: boolean | undefined;
        } | undefined;
    }, {
        context?: number | undefined;
        offset?: number | undefined;
        limit?: number | undefined;
        fromEnd?: boolean | undefined;
        maxChars?: number | undefined;
        search?: string | undefined;
        outputMode?: "content" | "matches_only" | "count" | undefined;
        ignoreCase?: boolean | undefined;
        matchNumbers?: boolean | undefined;
        streaming?: {
            lastSeenLine?: number | undefined;
            waitForNew?: boolean | undefined;
            maxWaitTime?: number | undefined;
            includeLineNumbers?: boolean | undefined;
        } | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    taskId: string;
    outputOptions?: {
        context?: number | undefined;
        offset?: number | undefined;
        limit?: number | undefined;
        fromEnd?: boolean | undefined;
        maxChars?: number | undefined;
        search?: string | undefined;
        outputMode?: "content" | "matches_only" | "count" | undefined;
        ignoreCase?: boolean | undefined;
        matchNumbers?: boolean | undefined;
        streaming?: {
            lastSeenLine?: number | undefined;
            waitForNew?: boolean | undefined;
            maxWaitTime?: number | undefined;
            includeLineNumbers?: boolean | undefined;
        } | undefined;
    } | undefined;
}, {
    taskId: string;
    outputOptions?: {
        context?: number | undefined;
        offset?: number | undefined;
        limit?: number | undefined;
        fromEnd?: boolean | undefined;
        maxChars?: number | undefined;
        search?: string | undefined;
        outputMode?: "content" | "matches_only" | "count" | undefined;
        ignoreCase?: boolean | undefined;
        matchNumbers?: boolean | undefined;
        streaming?: {
            lastSeenLine?: number | undefined;
            waitForNew?: boolean | undefined;
            maxWaitTime?: number | undefined;
            includeLineNumbers?: boolean | undefined;
        } | undefined;
    } | undefined;
}>;
export type GetTaskStatusRequest = z.infer<typeof GetTaskStatusRequest>;
export declare const WorkflowTask: z.ZodObject<{
    id: z.ZodString;
    agent: z.ZodEnum<["qwen", "gemini", "aider", "goose", "codex", "opencode", "claude"]>;
    task: z.ZodString;
    dependsOn: z.ZodOptional<z.ZodString>;
    condition: z.ZodOptional<z.ZodEnum<["success", "completed", "always"]>>;
    config: z.ZodOptional<z.ZodAny>;
}, "strip", z.ZodTypeAny, {
    agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
    id: string;
    task: string;
    dependsOn?: string | undefined;
    condition?: "success" | "completed" | "always" | undefined;
    config?: any;
}, {
    agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
    id: string;
    task: string;
    dependsOn?: string | undefined;
    condition?: "success" | "completed" | "always" | undefined;
    config?: any;
}>;
export type WorkflowTask = z.infer<typeof WorkflowTask>;
export declare const RunAgentSequenceRequest: z.ZodObject<{
    tasks: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        agent: z.ZodEnum<["qwen", "gemini", "aider", "goose", "codex", "opencode", "claude"]>;
        task: z.ZodString;
        dependsOn: z.ZodOptional<z.ZodString>;
        condition: z.ZodOptional<z.ZodEnum<["success", "completed", "always"]>>;
        config: z.ZodOptional<z.ZodAny>;
    }, "strip", z.ZodTypeAny, {
        agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
        id: string;
        task: string;
        dependsOn?: string | undefined;
        condition?: "success" | "completed" | "always" | undefined;
        config?: any;
    }, {
        agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
        id: string;
        task: string;
        dependsOn?: string | undefined;
        condition?: "success" | "completed" | "always" | undefined;
        config?: any;
    }>, "many">;
    continueOnFailure: z.ZodOptional<z.ZodBoolean>;
    templateData: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
}, "strip", z.ZodTypeAny, {
    tasks: {
        agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
        id: string;
        task: string;
        dependsOn?: string | undefined;
        condition?: "success" | "completed" | "always" | undefined;
        config?: any;
    }[];
    continueOnFailure?: boolean | undefined;
    templateData?: Record<string, any> | undefined;
}, {
    tasks: {
        agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
        id: string;
        task: string;
        dependsOn?: string | undefined;
        condition?: "success" | "completed" | "always" | undefined;
        config?: any;
    }[];
    continueOnFailure?: boolean | undefined;
    templateData?: Record<string, any> | undefined;
}>;
export type RunAgentSequenceRequest = z.infer<typeof RunAgentSequenceRequest>;
export declare const WorkflowResult: z.ZodObject<{
    success: z.ZodBoolean;
    workflowId: z.ZodString;
    completedTasks: z.ZodNumber;
    totalTasks: z.ZodNumber;
    tasks: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        agent: z.ZodEnum<["qwen", "gemini", "aider", "goose", "codex", "opencode", "claude"]>;
        taskId: z.ZodOptional<z.ZodString>;
        status: z.ZodEnum<["pending", "running", "completed", "failed", "skipped"]>;
        startTime: z.ZodOptional<z.ZodNumber>;
        endTime: z.ZodOptional<z.ZodNumber>;
        error: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        status: "failed" | "running" | "completed" | "pending" | "skipped";
        agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
        id: string;
        error?: string | undefined;
        startTime?: number | undefined;
        endTime?: number | undefined;
        taskId?: string | undefined;
    }, {
        status: "failed" | "running" | "completed" | "pending" | "skipped";
        agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
        id: string;
        error?: string | undefined;
        startTime?: number | undefined;
        endTime?: number | undefined;
        taskId?: string | undefined;
    }>, "many">;
    output: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    success: boolean;
    output: string[];
    tasks: {
        status: "failed" | "running" | "completed" | "pending" | "skipped";
        agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
        id: string;
        error?: string | undefined;
        startTime?: number | undefined;
        endTime?: number | undefined;
        taskId?: string | undefined;
    }[];
    workflowId: string;
    completedTasks: number;
    totalTasks: number;
}, {
    success: boolean;
    output: string[];
    tasks: {
        status: "failed" | "running" | "completed" | "pending" | "skipped";
        agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
        id: string;
        error?: string | undefined;
        startTime?: number | undefined;
        endTime?: number | undefined;
        taskId?: string | undefined;
    }[];
    workflowId: string;
    completedTasks: number;
    totalTasks: number;
}>;
export type WorkflowResult = z.infer<typeof WorkflowResult>;
export declare const ParallelTask: z.ZodObject<{
    agent: z.ZodEnum<["qwen", "gemini", "aider", "goose", "codex", "opencode", "claude"]>;
    task: z.ZodString;
    config: z.ZodOptional<z.ZodAny>;
}, "strip", z.ZodTypeAny, {
    agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
    task: string;
    config?: any;
}, {
    agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
    task: string;
    config?: any;
}>;
export type ParallelTask = z.infer<typeof ParallelTask>;
export declare const RunAgentsParallelRequest: z.ZodObject<{
    tasks: z.ZodRecord<z.ZodString, z.ZodObject<{
        agent: z.ZodEnum<["qwen", "gemini", "aider", "goose", "codex", "opencode", "claude"]>;
        task: z.ZodString;
        config: z.ZodOptional<z.ZodAny>;
    }, "strip", z.ZodTypeAny, {
        agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
        task: string;
        config?: any;
    }, {
        agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
        task: string;
        config?: any;
    }>>;
    timeout: z.ZodOptional<z.ZodNumber>;
    failFast: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    tasks: Record<string, {
        agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
        task: string;
        config?: any;
    }>;
    timeout?: number | undefined;
    failFast?: boolean | undefined;
}, {
    tasks: Record<string, {
        agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
        task: string;
        config?: any;
    }>;
    timeout?: number | undefined;
    failFast?: boolean | undefined;
}>;
export type RunAgentsParallelRequest = z.infer<typeof RunAgentsParallelRequest>;
export declare const ParallelResult: z.ZodObject<{
    success: z.ZodBoolean;
    parallelId: z.ZodString;
    completedTasks: z.ZodNumber;
    totalTasks: z.ZodNumber;
    duration: z.ZodOptional<z.ZodNumber>;
    tasks: z.ZodRecord<z.ZodString, z.ZodObject<{
        agent: z.ZodEnum<["qwen", "gemini", "aider", "goose", "codex", "opencode", "claude"]>;
        taskId: z.ZodOptional<z.ZodString>;
        status: z.ZodEnum<["running", "completed", "failed", "cancelled"]>;
        startTime: z.ZodOptional<z.ZodNumber>;
        endTime: z.ZodOptional<z.ZodNumber>;
        error: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        status: "failed" | "running" | "completed" | "cancelled";
        agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
        error?: string | undefined;
        startTime?: number | undefined;
        endTime?: number | undefined;
        taskId?: string | undefined;
    }, {
        status: "failed" | "running" | "completed" | "cancelled";
        agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
        error?: string | undefined;
        startTime?: number | undefined;
        endTime?: number | undefined;
        taskId?: string | undefined;
    }>>;
    output: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    success: boolean;
    output: string[];
    tasks: Record<string, {
        status: "failed" | "running" | "completed" | "cancelled";
        agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
        error?: string | undefined;
        startTime?: number | undefined;
        endTime?: number | undefined;
        taskId?: string | undefined;
    }>;
    completedTasks: number;
    totalTasks: number;
    parallelId: string;
    duration?: number | undefined;
}, {
    success: boolean;
    output: string[];
    tasks: Record<string, {
        status: "failed" | "running" | "completed" | "cancelled";
        agent: "qwen" | "gemini" | "aider" | "goose" | "codex" | "opencode" | "claude";
        error?: string | undefined;
        startTime?: number | undefined;
        endTime?: number | undefined;
        taskId?: string | undefined;
    }>;
    completedTasks: number;
    totalTasks: number;
    parallelId: string;
    duration?: number | undefined;
}>;
export type ParallelResult = z.infer<typeof ParallelResult>;
//# sourceMappingURL=index.d.ts.map