claude-flow/v3/@claude-flow/shared/dist/core/config/schema.d.ts

Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration

/**
 * V3 Configuration Schemas
 * Zod schemas for all configuration types
 */
import { z } from 'zod';
/**
 * Agent configuration schema
 */
export declare const AgentConfigSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    type: z.ZodString;
    capabilities: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    maxConcurrentTasks: z.ZodDefault<z.ZodNumber>;
    priority: z.ZodDefault<z.ZodNumber>;
    timeout: z.ZodOptional<z.ZodNumber>;
    retryPolicy: z.ZodOptional<z.ZodObject<{
        maxRetries: z.ZodDefault<z.ZodNumber>;
        backoffMs: z.ZodDefault<z.ZodNumber>;
        backoffMultiplier: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        maxRetries: number;
        backoffMs: number;
        backoffMultiplier: number;
    }, {
        maxRetries?: number | undefined;
        backoffMs?: number | undefined;
        backoffMultiplier?: number | undefined;
    }>>;
    resources: z.ZodOptional<z.ZodObject<{
        maxMemoryMb: z.ZodOptional<z.ZodNumber>;
        maxCpuPercent: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        maxMemoryMb?: number | undefined;
        maxCpuPercent?: number | undefined;
    }, {
        maxMemoryMb?: number | undefined;
        maxCpuPercent?: number | undefined;
    }>>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    capabilities: string[];
    priority: number;
    name: string;
    type: string;
    id: string;
    maxConcurrentTasks: number;
    metadata?: Record<string, unknown> | undefined;
    resources?: {
        maxMemoryMb?: number | undefined;
        maxCpuPercent?: number | undefined;
    } | undefined;
    timeout?: number | undefined;
    retryPolicy?: {
        maxRetries: number;
        backoffMs: number;
        backoffMultiplier: number;
    } | undefined;
}, {
    name: string;
    type: string;
    id: string;
    capabilities?: string[] | undefined;
    priority?: number | undefined;
    metadata?: Record<string, unknown> | undefined;
    resources?: {
        maxMemoryMb?: number | undefined;
        maxCpuPercent?: number | undefined;
    } | undefined;
    timeout?: number | undefined;
    maxConcurrentTasks?: number | undefined;
    retryPolicy?: {
        maxRetries?: number | undefined;
        backoffMs?: number | undefined;
        backoffMultiplier?: number | undefined;
    } | undefined;
}>;
/**
 * Task configuration schema
 */
export declare const TaskConfigSchema: z.ZodObject<{
    type: z.ZodString;
    description: z.ZodString;
    priority: z.ZodDefault<z.ZodNumber>;
    timeout: z.ZodOptional<z.ZodNumber>;
    assignedAgent: z.ZodOptional<z.ZodString>;
    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    metadata: z.ZodOptional<z.ZodObject<{
        requiredCapabilities: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        retryCount: z.ZodOptional<z.ZodNumber>;
        maxRetries: z.ZodOptional<z.ZodNumber>;
        critical: z.ZodOptional<z.ZodBoolean>;
        parentTaskId: z.ZodOptional<z.ZodString>;
        childTaskIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        critical?: boolean | undefined;
        retryCount?: number | undefined;
        requiredCapabilities?: string[] | undefined;
        maxRetries?: number | undefined;
        parentTaskId?: string | undefined;
        childTaskIds?: string[] | undefined;
        tags?: string[] | undefined;
    }, {
        critical?: boolean | undefined;
        retryCount?: number | undefined;
        requiredCapabilities?: string[] | undefined;
        maxRetries?: number | undefined;
        parentTaskId?: string | undefined;
        childTaskIds?: string[] | undefined;
        tags?: string[] | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    description: string;
    priority: number;
    type: string;
    metadata?: {
        critical?: boolean | undefined;
        retryCount?: number | undefined;
        requiredCapabilities?: string[] | undefined;
        maxRetries?: number | undefined;
        parentTaskId?: string | undefined;
        childTaskIds?: string[] | undefined;
        tags?: string[] | undefined;
    } | undefined;
    assignedAgent?: string | undefined;
    timeout?: number | undefined;
    input?: Record<string, unknown> | undefined;
}, {
    description: string;
    type: string;
    priority?: number | undefined;
    metadata?: {
        critical?: boolean | undefined;
        retryCount?: number | undefined;
        requiredCapabilities?: string[] | undefined;
        maxRetries?: number | undefined;
        parentTaskId?: string | undefined;
        childTaskIds?: string[] | undefined;
        tags?: string[] | undefined;
    } | undefined;
    assignedAgent?: string | undefined;
    timeout?: number | undefined;
    input?: Record<string, unknown> | undefined;
}>;
/**
 * Swarm configuration schema
 */
export declare const SwarmConfigSchema: z.ZodObject<{
    topology: z.ZodEnum<["hierarchical", "mesh", "ring", "star", "adaptive", "hierarchical-mesh"]>;
    maxAgents: z.ZodDefault<z.ZodNumber>;
    autoScale: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
        minAgents: z.ZodDefault<z.ZodNumber>;
        maxAgents: z.ZodDefault<z.ZodNumber>;
        scaleUpThreshold: z.ZodDefault<z.ZodNumber>;
        scaleDownThreshold: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        maxAgents: number;
        enabled: boolean;
        minAgents: number;
        scaleUpThreshold: number;
        scaleDownThreshold: number;
    }, {
        maxAgents?: number | undefined;
        enabled?: boolean | undefined;
        minAgents?: number | undefined;
        scaleUpThreshold?: number | undefined;
        scaleDownThreshold?: number | undefined;
    }>>;
    coordination: z.ZodOptional<z.ZodObject<{
        consensusRequired: z.ZodDefault<z.ZodBoolean>;
        timeoutMs: z.ZodDefault<z.ZodNumber>;
        retryPolicy: z.ZodObject<{
            maxRetries: z.ZodDefault<z.ZodNumber>;
            backoffMs: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            maxRetries: number;
            backoffMs: number;
        }, {
            maxRetries?: number | undefined;
            backoffMs?: number | undefined;
        }>;
    }, "strip", z.ZodTypeAny, {
        retryPolicy: {
            maxRetries: number;
            backoffMs: number;
        };
        consensusRequired: boolean;
        timeoutMs: number;
    }, {
        retryPolicy: {
            maxRetries?: number | undefined;
            backoffMs?: number | undefined;
        };
        consensusRequired?: boolean | undefined;
        timeoutMs?: number | undefined;
    }>>;
    communication: z.ZodOptional<z.ZodObject<{
        protocol: z.ZodDefault<z.ZodEnum<["events", "messages", "shared-memory"]>>;
        batchSize: z.ZodDefault<z.ZodNumber>;
        flushIntervalMs: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        protocol: "events" | "messages" | "shared-memory";
        batchSize: number;
        flushIntervalMs: number;
    }, {
        protocol?: "events" | "messages" | "shared-memory" | undefined;
        batchSize?: number | undefined;
        flushIntervalMs?: number | undefined;
    }>>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    topology: "hierarchical-mesh" | "mesh" | "hierarchical" | "ring" | "star" | "adaptive";
    maxAgents: number;
    metadata?: Record<string, unknown> | undefined;
    autoScale?: {
        maxAgents: number;
        enabled: boolean;
        minAgents: number;
        scaleUpThreshold: number;
        scaleDownThreshold: number;
    } | undefined;
    coordination?: {
        retryPolicy: {
            maxRetries: number;
            backoffMs: number;
        };
        consensusRequired: boolean;
        timeoutMs: number;
    } | undefined;
    communication?: {
        protocol: "events" | "messages" | "shared-memory";
        batchSize: number;
        flushIntervalMs: number;
    } | undefined;
}, {
    topology: "hierarchical-mesh" | "mesh" | "hierarchical" | "ring" | "star" | "adaptive";
    maxAgents?: number | undefined;
    metadata?: Record<string, unknown> | undefined;
    autoScale?: {
        maxAgents?: number | undefined;
        enabled?: boolean | undefined;
        minAgents?: number | undefined;
        scaleUpThreshold?: number | undefined;
        scaleDownThreshold?: number | undefined;
    } | undefined;
    coordination?: {
        retryPolicy: {
            maxRetries?: number | undefined;
            backoffMs?: number | undefined;
        };
        consensusRequired?: boolean | undefined;
        timeoutMs?: number | undefined;
    } | undefined;
    communication?: {
        protocol?: "events" | "messages" | "shared-memory" | undefined;
        batchSize?: number | undefined;
        flushIntervalMs?: number | undefined;
    } | undefined;
}>;
/**
 * Memory configuration schema
 */
export declare const MemoryConfigSchema: z.ZodObject<{
    type: z.ZodDefault<z.ZodEnum<["sqlite", "agentdb", "hybrid", "redis", "memory"]>>;
    path: z.ZodOptional<z.ZodString>;
    maxSize: z.ZodOptional<z.ZodNumber>;
    ttlMs: z.ZodOptional<z.ZodNumber>;
    sqlite: z.ZodOptional<z.ZodObject<{
        filename: z.ZodOptional<z.ZodString>;
        inMemory: z.ZodDefault<z.ZodBoolean>;
        wal: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        inMemory: boolean;
        wal: boolean;
        filename?: string | undefined;
    }, {
        filename?: string | undefined;
        inMemory?: boolean | undefined;
        wal?: boolean | undefined;
    }>>;
    agentdb: z.ZodOptional<z.ZodObject<{
        dimensions: z.ZodDefault<z.ZodNumber>;
        indexType: z.ZodDefault<z.ZodEnum<["hnsw", "flat", "ivf"]>>;
        efConstruction: z.ZodDefault<z.ZodNumber>;
        m: z.ZodDefault<z.ZodNumber>;
        quantization: z.ZodDefault<z.ZodEnum<["none", "scalar", "product"]>>;
    }, "strip", z.ZodTypeAny, {
        dimensions: number;
        indexType: "flat" | "hnsw" | "ivf";
        efConstruction: number;
        m: number;
        quantization: "none" | "scalar" | "product";
    }, {
        dimensions?: number | undefined;
        indexType?: "flat" | "hnsw" | "ivf" | undefined;
        efConstruction?: number | undefined;
        m?: number | undefined;
        quantization?: "none" | "scalar" | "product" | undefined;
    }>>;
    redis: z.ZodOptional<z.ZodObject<{
        host: z.ZodDefault<z.ZodString>;
        port: z.ZodDefault<z.ZodNumber>;
        password: z.ZodOptional<z.ZodString>;
        db: z.ZodDefault<z.ZodNumber>;
        keyPrefix: z.ZodDefault<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        host: string;
        port: number;
        db: number;
        keyPrefix: string;
        password?: string | undefined;
    }, {
        host?: string | undefined;
        port?: number | undefined;
        password?: string | undefined;
        db?: number | undefined;
        keyPrefix?: string | undefined;
    }>>;
    hybrid: z.ZodOptional<z.ZodObject<{
        vectorThreshold: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        vectorThreshold: number;
    }, {
        vectorThreshold?: number | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    type: "memory" | "sqlite" | "agentdb" | "hybrid" | "redis";
    path?: string | undefined;
    sqlite?: {
        inMemory: boolean;
        wal: boolean;
        filename?: string | undefined;
    } | undefined;
    agentdb?: {
        dimensions: number;
        indexType: "flat" | "hnsw" | "ivf";
        efConstruction: number;
        m: number;
        quantization: "none" | "scalar" | "product";
    } | undefined;
    hybrid?: {
        vectorThreshold: number;
    } | undefined;
    redis?: {
        host: string;
        port: number;
        db: number;
        keyPrefix: string;
        password?: string | undefined;
    } | undefined;
    maxSize?: number | undefined;
    ttlMs?: number | undefined;
}, {
    type?: "memory" | "sqlite" | "agentdb" | "hybrid" | "redis" | undefined;
    path?: string | undefined;
    sqlite?: {
        filename?: string | undefined;
        inMemory?: boolean | undefined;
        wal?: boolean | undefined;
    } | undefined;
    agentdb?: {
        dimensions?: number | undefined;
        indexType?: "flat" | "hnsw" | "ivf" | undefined;
        efConstruction?: number | undefined;
        m?: number | undefined;
        quantization?: "none" | "scalar" | "product" | undefined;
    } | undefined;
    hybrid?: {
        vectorThreshold?: number | undefined;
    } | undefined;
    redis?: {
        host?: string | undefined;
        port?: number | undefined;
        password?: string | undefined;
        db?: number | undefined;
        keyPrefix?: string | undefined;
    } | undefined;
    maxSize?: number | undefined;
    ttlMs?: number | undefined;
}>;
/**
 * MCP server configuration schema
 */
export declare const MCPServerConfigSchema: z.ZodObject<{
    name: z.ZodDefault<z.ZodString>;
    version: z.ZodDefault<z.ZodString>;
    transport: z.ZodObject<{
        type: z.ZodDefault<z.ZodEnum<["stdio", "http", "websocket"]>>;
        port: z.ZodOptional<z.ZodNumber>;
        host: z.ZodOptional<z.ZodString>;
        path: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        type: "stdio" | "http" | "websocket";
        path?: string | undefined;
        host?: string | undefined;
        port?: number | undefined;
    }, {
        type?: "stdio" | "http" | "websocket" | undefined;
        path?: string | undefined;
        host?: string | undefined;
        port?: number | undefined;
    }>;
    capabilities: z.ZodOptional<z.ZodObject<{
        tools: z.ZodDefault<z.ZodBoolean>;
        resources: z.ZodDefault<z.ZodBoolean>;
        prompts: z.ZodDefault<z.ZodBoolean>;
        logging: z.ZodDefault<z.ZodBoolean>;
        experimental: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
    }, "strip", z.ZodTypeAny, {
        resources: boolean;
        tools: boolean;
        prompts: boolean;
        logging: boolean;
        experimental?: Record<string, boolean> | undefined;
    }, {
        resources?: boolean | undefined;
        tools?: boolean | undefined;
        prompts?: boolean | undefined;
        logging?: boolean | undefined;
        experimental?: Record<string, boolean> | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    name: string;
    version: string;
    transport: {
        type: "stdio" | "http" | "websocket";
        path?: string | undefined;
        host?: string | undefined;
        port?: number | undefined;
    };
    capabilities?: {
        resources: boolean;
        tools: boolean;
        prompts: boolean;
        logging: boolean;
        experimental?: Record<string, boolean> | undefined;
    } | undefined;
}, {
    transport: {
        type?: "stdio" | "http" | "websocket" | undefined;
        path?: string | undefined;
        host?: string | undefined;
        port?: number | undefined;
    };
    capabilities?: {
        resources?: boolean | undefined;
        tools?: boolean | undefined;
        prompts?: boolean | undefined;
        logging?: boolean | undefined;
        experimental?: Record<string, boolean> | undefined;
    } | undefined;
    name?: string | undefined;
    version?: string | undefined;
}>;
/**
 * Orchestrator configuration schema
 */
export declare const OrchestratorConfigSchema: z.ZodObject<{
    session: z.ZodObject<{
        persistSessions: z.ZodDefault<z.ZodBoolean>;
        dataDir: z.ZodDefault<z.ZodString>;
        sessionRetentionMs: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        persistSessions: boolean;
        dataDir: string;
        sessionRetentionMs: number;
    }, {
        persistSessions?: boolean | undefined;
        dataDir?: string | undefined;
        sessionRetentionMs?: number | undefined;
    }>;
    health: z.ZodObject<{
        checkInterval: z.ZodDefault<z.ZodNumber>;
        historyLimit: z.ZodDefault<z.ZodNumber>;
        degradedThreshold: z.ZodDefault<z.ZodNumber>;
        unhealthyThreshold: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        checkInterval: number;
        historyLimit: number;
        degradedThreshold: number;
        unhealthyThreshold: number;
    }, {
        checkInterval?: number | undefined;
        historyLimit?: number | undefined;
        degradedThreshold?: number | undefined;
        unhealthyThreshold?: number | undefined;
    }>;
    lifecycle: z.ZodObject<{
        maxConcurrentAgents: z.ZodDefault<z.ZodNumber>;
        spawnTimeout: z.ZodDefault<z.ZodNumber>;
        terminateTimeout: z.ZodDefault<z.ZodNumber>;
        maxSpawnRetries: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        maxConcurrentAgents: number;
        spawnTimeout: number;
        terminateTimeout: number;
        maxSpawnRetries: number;
    }, {
        maxConcurrentAgents?: number | undefined;
        spawnTimeout?: number | undefined;
        terminateTimeout?: number | undefined;
        maxSpawnRetries?: number | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    health: {
        checkInterval: number;
        historyLimit: number;
        degradedThreshold: number;
        unhealthyThreshold: number;
    };
    session: {
        persistSessions: boolean;
        dataDir: string;
        sessionRetentionMs: number;
    };
    lifecycle: {
        maxConcurrentAgents: number;
        spawnTimeout: number;
        terminateTimeout: number;
        maxSpawnRetries: number;
    };
}, {
    health: {
        checkInterval?: number | undefined;
        historyLimit?: number | undefined;
        degradedThreshold?: number | undefined;
        unhealthyThreshold?: number | undefined;
    };
    session: {
        persistSessions?: boolean | undefined;
        dataDir?: string | undefined;
        sessionRetentionMs?: number | undefined;
    };
    lifecycle: {
        maxConcurrentAgents?: number | undefined;
        spawnTimeout?: number | undefined;
        terminateTimeout?: number | undefined;
        maxSpawnRetries?: number | undefined;
    };
}>;
/**
 * Full system configuration schema
 * Uses passthrough() to accept unknown extra keys from user configs
 * without failing validation (e.g., simple key-value pairs, custom fields).
 */
export declare const SystemConfigSchema: z.ZodObject<{
    orchestrator: z.ZodObject<{
        session: z.ZodObject<{
            persistSessions: z.ZodDefault<z.ZodBoolean>;
            dataDir: z.ZodDefault<z.ZodString>;
            sessionRetentionMs: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            persistSessions: boolean;
            dataDir: string;
            sessionRetentionMs: number;
        }, {
            persistSessions?: boolean | undefined;
            dataDir?: string | undefined;
            sessionRetentionMs?: number | undefined;
        }>;
        health: z.ZodObject<{
            checkInterval: z.ZodDefault<z.ZodNumber>;
            historyLimit: z.ZodDefault<z.ZodNumber>;
            degradedThreshold: z.ZodDefault<z.ZodNumber>;
            unhealthyThreshold: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            checkInterval: number;
            historyLimit: number;
            degradedThreshold: number;
            unhealthyThreshold: number;
        }, {
            checkInterval?: number | undefined;
            historyLimit?: number | undefined;
            degradedThreshold?: number | undefined;
            unhealthyThreshold?: number | undefined;
        }>;
        lifecycle: z.ZodObject<{
            maxConcurrentAgents: z.ZodDefault<z.ZodNumber>;
            spawnTimeout: z.ZodDefault<z.ZodNumber>;
            terminateTimeout: z.ZodDefault<z.ZodNumber>;
            maxSpawnRetries: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            maxConcurrentAgents: number;
            spawnTimeout: number;
            terminateTimeout: number;
            maxSpawnRetries: number;
        }, {
            maxConcurrentAgents?: number | undefined;
            spawnTimeout?: number | undefined;
            terminateTimeout?: number | undefined;
            maxSpawnRetries?: number | undefined;
        }>;
    }, "strip", z.ZodTypeAny, {
        health: {
            checkInterval: number;
            historyLimit: number;
            degradedThreshold: number;
            unhealthyThreshold: number;
        };
        session: {
            persistSessions: boolean;
            dataDir: string;
            sessionRetentionMs: number;
        };
        lifecycle: {
            maxConcurrentAgents: number;
            spawnTimeout: number;
            terminateTimeout: number;
            maxSpawnRetries: number;
        };
    }, {
        health: {
            checkInterval?: number | undefined;
            historyLimit?: number | undefined;
            degradedThreshold?: number | undefined;
            unhealthyThreshold?: number | undefined;
        };
        session: {
            persistSessions?: boolean | undefined;
            dataDir?: string | undefined;
            sessionRetentionMs?: number | undefined;
        };
        lifecycle: {
            maxConcurrentAgents?: number | undefined;
            spawnTimeout?: number | undefined;
            terminateTimeout?: number | undefined;
            maxSpawnRetries?: number | undefined;
        };
    }>;
    memory: z.ZodOptional<z.ZodObject<{
        type: z.ZodDefault<z.ZodEnum<["sqlite", "agentdb", "hybrid", "redis", "memory"]>>;
        path: z.ZodOptional<z.ZodString>;
        maxSize: z.ZodOptional<z.ZodNumber>;
        ttlMs: z.ZodOptional<z.ZodNumber>;
        sqlite: z.ZodOptional<z.ZodObject<{
            filename: z.ZodOptional<z.ZodString>;
            inMemory: z.ZodDefault<z.ZodBoolean>;
            wal: z.ZodDefault<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            inMemory: boolean;
            wal: boolean;
            filename?: string | undefined;
        }, {
            filename?: string | undefined;
            inMemory?: boolean | undefined;
            wal?: boolean | undefined;
        }>>;
        agentdb: z.ZodOptional<z.ZodObject<{
            dimensions: z.ZodDefault<z.ZodNumber>;
            indexType: z.ZodDefault<z.ZodEnum<["hnsw", "flat", "ivf"]>>;
            efConstruction: z.ZodDefault<z.ZodNumber>;
            m: z.ZodDefault<z.ZodNumber>;
            quantization: z.ZodDefault<z.ZodEnum<["none", "scalar", "product"]>>;
        }, "strip", z.ZodTypeAny, {
            dimensions: number;
            indexType: "flat" | "hnsw" | "ivf";
            efConstruction: number;
            m: number;
            quantization: "none" | "scalar" | "product";
        }, {
            dimensions?: number | undefined;
            indexType?: "flat" | "hnsw" | "ivf" | undefined;
            efConstruction?: number | undefined;
            m?: number | undefined;
            quantization?: "none" | "scalar" | "product" | undefined;
        }>>;
        redis: z.ZodOptional<z.ZodObject<{
            host: z.ZodDefault<z.ZodString>;
            port: z.ZodDefault<z.ZodNumber>;
            password: z.ZodOptional<z.ZodString>;
            db: z.ZodDefault<z.ZodNumber>;
            keyPrefix: z.ZodDefault<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            host: string;
            port: number;
            db: number;
            keyPrefix: string;
            password?: string | undefined;
        }, {
            host?: string | undefined;
            port?: number | undefined;
            password?: string | undefined;
            db?: number | undefined;
            keyPrefix?: string | undefined;
        }>>;
        hybrid: z.ZodOptional<z.ZodObject<{
            vectorThreshold: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            vectorThreshold: number;
        }, {
            vectorThreshold?: number | undefined;
        }>>;
    }, "strip", z.ZodTypeAny, {
        type: "memory" | "sqlite" | "agentdb" | "hybrid" | "redis";
        path?: string | undefined;
        sqlite?: {
            inMemory: boolean;
            wal: boolean;
            filename?: string | undefined;
        } | undefined;
        agentdb?: {
            dimensions: number;
            indexType: "flat" | "hnsw" | "ivf";
            efConstruction: number;
            m: number;
            quantization: "none" | "scalar" | "product";
        } | undefined;
        hybrid?: {
            vectorThreshold: number;
        } | undefined;
        redis?: {
            host: string;
            port: number;
            db: number;
            keyPrefix: string;
            password?: string | undefined;
        } | undefined;
        maxSize?: number | undefined;
        ttlMs?: number | undefined;
    }, {
        type?: "memory" | "sqlite" | "agentdb" | "hybrid" | "redis" | undefined;
        path?: string | undefined;
        sqlite?: {
            filename?: string | undefined;
            inMemory?: boolean | undefined;
            wal?: boolean | undefined;
        } | undefined;
        agentdb?: {
            dimensions?: number | undefined;
            indexType?: "flat" | "hnsw" | "ivf" | undefined;
            efConstruction?: number | undefined;
            m?: number | undefined;
            quantization?: "none" | "scalar" | "product" | undefined;
        } | undefined;
        hybrid?: {
            vectorThreshold?: number | undefined;
        } | undefined;
        redis?: {
            host?: string | undefined;
            port?: number | undefined;
            password?: string | undefined;
            db?: number | undefined;
            keyPrefix?: string | undefined;
        } | undefined;
        maxSize?: number | undefined;
        ttlMs?: number | undefined;
    }>>;
    mcp: z.ZodOptional<z.ZodObject<{
        name: z.ZodDefault<z.ZodString>;
        version: z.ZodDefault<z.ZodString>;
        transport: z.ZodObject<{
            type: z.ZodDefault<z.ZodEnum<["stdio", "http", "websocket"]>>;
            port: z.ZodOptional<z.ZodNumber>;
            host: z.ZodOptional<z.ZodString>;
            path: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            type: "stdio" | "http" | "websocket";
            path?: string | undefined;
            host?: string | undefined;
            port?: number | undefined;
        }, {
            type?: "stdio" | "http" | "websocket" | undefined;
            path?: string | undefined;
            host?: string | undefined;
            port?: number | undefined;
        }>;
        capabilities: z.ZodOptional<z.ZodObject<{
            tools: z.ZodDefault<z.ZodBoolean>;
            resources: z.ZodDefault<z.ZodBoolean>;
            prompts: z.ZodDefault<z.ZodBoolean>;
            logging: z.ZodDefault<z.ZodBoolean>;
            experimental: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
        }, "strip", z.ZodTypeAny, {
            resources: boolean;
            tools: boolean;
            prompts: boolean;
            logging: boolean;
            experimental?: Record<string, boolean> | undefined;
        }, {
            resources?: boolean | undefined;
            tools?: boolean | undefined;
            prompts?: boolean | undefined;
            logging?: boolean | undefined;
            experimental?: Record<string, boolean> | undefined;
        }>>;
    }, "strip", z.ZodTypeAny, {
        name: string;
        version: string;
        transport: {
            type: "stdio" | "http" | "websocket";
            path?: string | undefined;
            host?: string | undefined;
            port?: number | undefined;
        };
        capabilities?: {
            resources: boolean;
            tools: boolean;
            prompts: boolean;
            logging: boolean;
            experimental?: Record<string, boolean> | undefined;
        } | undefined;
    }, {
        transport: {
            type?: "stdio" | "http" | "websocket" | undefined;
            path?: string | undefined;
            host?: string | undefined;
            port?: number | undefined;
        };
        capabilities?: {
            resources?: boolean | undefined;
            tools?: boolean | undefined;
            prompts?: boolean | undefined;
            logging?: boolean | undefined;
            experimental?: Record<string, boolean> | undefined;
        } | undefined;
        name?: string | undefined;
        version?: string | undefined;
    }>>;
    swarm: z.ZodOptional<z.ZodObject<{
        topology: z.ZodEnum<["hierarchical", "mesh", "ring", "star", "adaptive", "hierarchical-mesh"]>;
        maxAgents: z.ZodDefault<z.ZodNumber>;
        autoScale: z.ZodOptional<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
            minAgents: z.ZodDefault<z.ZodNumber>;
            maxAgents: z.ZodDefault<z.ZodNumber>;
            scaleUpThreshold: z.ZodDefault<z.ZodNumber>;
            scaleDownThreshold: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            maxAgents: number;
            enabled: boolean;
            minAgents: number;
            scaleUpThreshold: number;
            scaleDownThreshold: number;
        }, {
            maxAgents?: number | undefined;
            enabled?: boolean | undefined;
            minAgents?: number | undefined;
            scaleUpThreshold?: number | undefined;
            scaleDownThreshold?: number | undefined;
        }>>;
        coordination: z.ZodOptional<z.ZodObject<{
            consensusRequired: z.ZodDefault<z.ZodBoolean>;
            timeoutMs: z.ZodDefault<z.ZodNumber>;
            retryPolicy: z.ZodObject<{
                maxRetries: z.ZodDefault<z.ZodNumber>;
                backoffMs: z.ZodDefault<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                maxRetries: number;
                backoffMs: number;
            }, {
                maxRetries?: number | undefined;
                backoffMs?: number | undefined;
            }>;
        }, "strip", z.ZodTypeAny, {
            retryPolicy: {
                maxRetries: number;
                backoffMs: number;
            };
            consensusRequired: boolean;
            timeoutMs: number;
        }, {
            retryPolicy: {
                maxRetries?: number | undefined;
                backoffMs?: number | undefined;
            };
            consensusRequired?: boolean | undefined;
            timeoutMs?: number | undefined;
        }>>;
        communication: z.ZodOptional<z.ZodObject<{
            protocol: z.ZodDefault<z.ZodEnum<["events", "messages", "shared-memory"]>>;
            batchSize: z.ZodDefault<z.ZodNumber>;
            flushIntervalMs: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            protocol: "events" | "messages" | "shared-memory";
            batchSize: number;
            flushIntervalMs: number;
        }, {
            protocol?: "events" | "messages" | "shared-memory" | undefined;
            batchSize?: number | undefined;
            flushIntervalMs?: number | undefined;
        }>>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, "strip", z.ZodTypeAny, {
        topology: "hierarchical-mesh" | "mesh" | "hierarchical" | "ring" | "star" | "adaptive";
        maxAgents: number;
        metadata?: Record<string, unknown> | undefined;
        autoScale?: {
            maxAgents: number;
            enabled: boolean;
            minAgents: number;
            scaleUpThreshold: number;
            scaleDownThreshold: number;
        } | undefined;
        coordination?: {
            retryPolicy: {
                maxRetries: number;
                backoffMs: number;
            };
            consensusRequired: boolean;
            timeoutMs: number;
        } | undefined;
        communication?: {
            protocol: "events" | "messages" | "shared-memory";
            batchSize: number;
            flushIntervalMs: number;
        } | undefined;
    }, {
        topology: "hierarchical-mesh" | "mesh" | "hierarchical" | "ring" | "star" | "adaptive";
        maxAgents?: number | undefined;
        metadata?: Record<string, unknown> | undefined;
        autoScale?: {
            maxAgents?: number | undefined;
            enabled?: boolean | undefined;
            minAgents?: number | undefined;
            scaleUpThreshold?: number | undefined;
            scaleDownThreshold?: number | undefined;
        } | undefined;
        coordination?: {
            retryPolicy: {
                maxRetries?: number | undefined;
                backoffMs?: number | undefined;
            };
            consensusRequired?: boolean | undefined;
            timeoutMs?: number | undefined;
        } | undefined;
        communication?: {
            protocol?: "events" | "messages" | "shared-memory" | undefined;
            batchSize?: number | undefined;
            flushIntervalMs?: number | undefined;
        } | undefined;
    }>>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    orchestrator: z.ZodObject<{
        session: z.ZodObject<{
            persistSessions: z.ZodDefault<z.ZodBoolean>;
            dataDir: z.ZodDefault<z.ZodString>;
            sessionRetentionMs: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            persistSessions: boolean;
            dataDir: string;
            sessionRetentionMs: number;
        }, {
            persistSessions?: boolean | undefined;
            dataDir?: string | undefined;
            sessionRetentionMs?: number | undefined;
        }>;
        health: z.ZodObject<{
            checkInterval: z.ZodDefault<z.ZodNumber>;
            historyLimit: z.ZodDefault<z.ZodNumber>;
            degradedThreshold: z.ZodDefault<z.ZodNumber>;
            unhealthyThreshold: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            checkInterval: number;
            historyLimit: number;
            degradedThreshold: number;
            unhealthyThreshold: number;
        }, {
            checkInterval?: number | undefined;
            historyLimit?: number | undefined;
            degradedThreshold?: number | undefined;
            unhealthyThreshold?: number | undefined;
        }>;
        lifecycle: z.ZodObject<{
            maxConcurrentAgents: z.ZodDefault<z.ZodNumber>;
            spawnTimeout: z.ZodDefault<z.ZodNumber>;
            terminateTimeout: z.ZodDefault<z.ZodNumber>;
            maxSpawnRetries: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            maxConcurrentAgents: number;
            spawnTimeout: number;
            terminateTimeout: number;
            maxSpawnRetries: number;
        }, {
            maxConcurrentAgents?: number | undefined;
            spawnTimeout?: number | undefined;
            terminateTimeout?: number | undefined;
            maxSpawnRetries?: number | undefined;
        }>;
    }, "strip", z.ZodTypeAny, {
        health: {
            checkInterval: number;
            historyLimit: number;
            degradedThreshold: number;
            unhealthyThreshold: number;
        };
        session: {
            persistSessions: boolean;
            dataDir: string;
            sessionRetentionMs: number;
        };
        lifecycle: {
            maxConcurrentAgents: number;
            spawnTimeout: number;
            terminateTimeout: number;
            maxSpawnRetries: number;
        };
    }, {
        health: {
            checkInterval?: number | undefined;
            historyLimit?: number | undefined;
            degradedThreshold?: number | undefined;
            unhealthyThreshold?: number | undefined;
        };
        session: {
            persistSessions?: boolean | undefined;
            dataDir?: string | undefined;
            sessionRetentionMs?: number | undefined;
        };
        lifecycle: {
            maxConcurrentAgents?: number | undefined;
            spawnTimeout?: number | undefined;
            terminateTimeout?: number | undefined;
            maxSpawnRetries?: number | undefined;
        };
    }>;
    memory: z.ZodOptional<z.ZodObject<{
        type: z.ZodDefault<z.ZodEnum<["sqlite", "agentdb", "hybrid", "redis", "memory"]>>;
        path: z.ZodOptional<z.ZodString>;
        maxSize: z.ZodOptional<z.ZodNumber>;
        ttlMs: z.ZodOptional<z.ZodNumber>;
        sqlite: z.ZodOptional<z.ZodObject<{
            filename: z.ZodOptional<z.ZodString>;
            inMemory: z.ZodDefault<z.ZodBoolean>;
            wal: z.ZodDefault<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            inMemory: boolean;
            wal: boolean;
            filename?: string | undefined;
        }, {
            filename?: string | undefined;
            inMemory?: boolean | undefined;
            wal?: boolean | undefined;
        }>>;
        agentdb: z.ZodOptional<z.ZodObject<{
            dimensions: z.ZodDefault<z.ZodNumber>;
            indexType: z.ZodDefault<z.ZodEnum<["hnsw", "flat", "ivf"]>>;
            efConstruction: z.ZodDefault<z.ZodNumber>;
            m: z.ZodDefault<z.ZodNumber>;
            quantization: z.ZodDefault<z.ZodEnum<["none", "scalar", "product"]>>;
        }, "strip", z.ZodTypeAny, {
            dimensions: number;
            indexType: "flat" | "hnsw" | "ivf";
            efConstruction: number;
            m: number;
            quantization: "none" | "scalar" | "product";
        }, {
            dimensions?: number | undefined;
            indexType?: "flat" | "hnsw" | "ivf" | undefined;
            efConstruction?: number | undefined;
            m?: number | undefined;
            quantization?: "none" | "scalar" | "product" | undefined;
        }>>;
        redis: z.ZodOptional<z.ZodObject<{
            host: z.ZodDefault<z.ZodString>;
            port: z.ZodDefault<z.ZodNumber>;
            password: z.ZodOptional<z.ZodString>;
            db: z.ZodDefault<z.ZodNumber>;
            keyPrefix: z.ZodDefault<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            host: string;
            port: number;
            db: number;
            keyPrefix: string;
            password?: string | undefined;
        }, {
            host?: string | undefined;
            port?: number | undefined;
            password?: string | undefined;
            db?: number | undefined;
            keyPrefix?: string | undefined;
        }>>;
        hybrid: z.ZodOptional<z.ZodObject<{
            vectorThreshold: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            vectorThreshold: number;
        }, {
            vectorThreshold?: number | undefined;
        }>>;
    }, "strip", z.ZodTypeAny, {
        type: "memory" | "sqlite" | "agentdb" | "hybrid" | "redis";
        path?: string | undefined;
        sqlite?: {
            inMemory: boolean;
            wal: boolean;
            filename?: string | undefined;
        } | undefined;
        agentdb?: {
            dimensions: number;
            indexType: "flat" | "hnsw" | "ivf";
            efConstruction: number;
            m: number;
            quantization: "none" | "scalar" | "product";
        } | undefined;
        hybrid?: {
            vectorThreshold: number;
        } | undefined;
        redis?: {
            host: string;
            port: number;
            db: number;
            keyPrefix: string;
            password?: string | undefined;
        } | undefined;
        maxSize?: number | undefined;
        ttlMs?: number | undefined;
    }, {
        type?: "memory" | "sqlite" | "agentdb" | "hybrid" | "redis" | undefined;
        path?: string | undefined;
        sqlite?: {
            filename?: string | undefined;
            inMemory?: boolean | undefined;
            wal?: boolean | undefined;
        } | undefined;
        agentdb?: {
            dimensions?: number | undefined;
            indexType?: "flat" | "hnsw" | "ivf" | undefined;
            efConstruction?: number | undefined;
            m?: number | undefined;
            quantization?: "none" | "scalar" | "product" | undefined;
        } | undefined;
        hybrid?: {
            vectorThreshold?: number | undefined;
        } | undefined;
        redis?: {
            host?: string | undefined;
            port?: number | undefined;
            password?: string | undefined;
            db?: number | undefined;
            keyPrefix?: string | undefined;
        } | undefined;
        maxSize?: number | undefined;
        ttlMs?: number | undefined;
    }>>;
    mcp: z.ZodOptional<z.ZodObject<{
        name: z.ZodDefault<z.ZodString>;
        version: z.ZodDefault<z.ZodString>;
        transport: z.ZodObject<{
            type: z.ZodDefault<z.ZodEnum<["stdio", "http", "websocket"]>>;
            port: z.ZodOptional<z.ZodNumber>;
            host: z.ZodOptional<z.ZodString>;
            path: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            type: "stdio" | "http" | "websocket";
            path?: string | undefined;
            host?: string | undefined;
            port?: number | undefined;
        }, {
            type?: "stdio" | "http" | "websocket" | undefined;
            path?: string | undefined;
            host?: string | undefined;
            port?: number | undefined;
        }>;
        capabilities: z.ZodOptional<z.ZodObject<{
            tools: z.ZodDefault<z.ZodBoolean>;
            resources: z.ZodDefault<z.ZodBoolean>;
            prompts: z.ZodDefault<z.ZodBoolean>;
            logging: z.ZodDefault<z.ZodBoolean>;
            experimental: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
        }, "strip", z.ZodTypeAny, {
            resources: boolean;
            tools: boolean;
            prompts: boolean;
            logging: boolean;
            experimental?: Record<string, boolean> | undefined;
        }, {
            resources?: boolean | undefined;
            tools?: boolean | undefined;
            prompts?: boolean | undefined;
            logging?: boolean | undefined;
            experimental?: Record<string, boolean> | undefined;
        }>>;
    }, "strip", z.ZodTypeAny, {
        name: string;
        version: string;
        transport: {
            type: "stdio" | "http" | "websocket";
            path?: string | undefined;
            host?: string | undefined;
            port?: number | undefined;
        };
        capabilities?: {
            resources: boolean;
            tools: boolean;
            prompts: boolean;
            logging: boolean;
            experimental?: Record<string, boolean> | undefined;
        } | undefined;
    }, {
        transport: {
            type?: "stdio" | "http" | "websocket" | undefined;
            path?: string | undefined;
            host?: string | undefined;
            port?: number | undefined;
        };
        capabilities?: {
            resources?: boolean | undefined;
            tools?: boolean | undefined;
            prompts?: boolean | undefined;
            logging?: boolean | undefined;
            experimental?: Record<string, boolean> | undefined;
        } | undefined;
        name?: string | undefined;
        version?: string | undefined;
    }>>;
    swarm: z.ZodOptional<z.ZodObject<{
        topology: z.ZodEnum<["hierarchical", "mesh", "ring", "star", "adaptive", "hierarchical-mesh"]>;
        maxAgents: z.ZodDefault<z.ZodNumber>;
        autoScale: z.ZodOptional<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
            minAgents: z.ZodDefault<z.ZodNumber>;
            maxAgents: z.ZodDefault<z.ZodNumber>;
            scaleUpThreshold: z.ZodDefault<z.ZodNumber>;
            scaleDownThreshold: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            maxAgents: number;
            enabled: boolean;
            minAgents: number;
            scaleUpThreshold: number;
            scaleDownThreshold: number;
        }, {
            maxAgents?: number | undefined;
            enabled?: boolean | undefined;
            minAgents?: number | undefined;
            scaleUpThreshold?: number | undefined;
            scaleDownThreshold?: number | undefined;
        }>>;
        coordination: z.ZodOptional<z.ZodObject<{
            consensusRequired: z.ZodDefault<z.ZodBoolean>;
            timeoutMs: z.ZodDefault<z.ZodNumber>;
            retryPolicy: z.ZodObject<{
                maxRetries: z.ZodDefault<z.ZodNumber>;
                backoffMs: z.ZodDefault<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                maxRetries: number;
                backoffMs: number;
            }, {
                maxRetries?: number | undefined;
                backoffMs?: number | undefined;
            }>;
        }, "strip", z.ZodTypeAny, {
            retryPolicy: {
                maxRetries: number;
                backoffMs: number;
            };
            consensusRequired: boolean;
            timeoutMs: number;
        }, {
            retryPolicy: {
                maxRetries?: number | undefined;
                backoffMs?: number | undefined;
            };
            consensusRequired?: boolean | undefined;
            timeoutMs?: number | undefined;
        }>>;
        communication: z.ZodOptional<z.ZodObject<{
            protocol: z.ZodDefault<z.ZodEnum<["events", "messages", "shared-memory"]>>;
            batchSize: z.ZodDefault<z.ZodNumber>;
            flushIntervalMs: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            protocol: "events" | "messages" | "shared-memory";
            batchSize: number;
            flushIntervalMs: number;
        }, {
            protocol?: "events" | "messages" | "shared-memory" | undefined;
            batchSize?: number | undefined;
            flushIntervalMs?: number | undefined;
        }>>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, "strip", z.ZodTypeAny, {
        topology: "hierarchical-mesh" | "mesh" | "hierarchical" | "ring" | "star" | "adaptive";
        maxAgents: number;
        metadata?: Record<string, unknown> | undefined;
        autoScale?: {
            maxAgents: number;
            enabled: boolean;
            minAgents: number;
            scaleUpThreshold: number;
            scaleDownThreshold: number;
        } | undefined;
        coordination?: {
            retryPolicy: {
                maxRetries: number;
                backoffMs: number;
            };
            consensusRequired: boolean;
            timeoutMs: number;
        } | undefined;
        communication?: {
            protocol: "events" | "messages" | "shared-memory";
            batchSize: number;
            flushIntervalMs: number;
        } | undefined;
    }, {
        topology: "hierarchical-mesh" | "mesh" | "hierarchical" | "ring" | "star" | "adaptive";
        maxAgents?: number | undefined;
        metadata?: Record<string, unknown> | undefined;
        autoScale?: {
            maxAgents?: number | undefined;
            enabled?: boolean | undefined;
            minAgents?: number | undefined;
            scaleUpThreshold?: number | undefined;
            scaleDownThreshold?: number | undefined;
        } | undefined;
        coordination?: {
            retryPolicy: {
                maxRetries?: number | undefined;
                backoffMs?: number | undefined;
            };
            consensusRequired?: boolean | undefined;
            timeoutMs?: number | undefined;
        } | undefined;
        communication?: {
            protocol?: "events" | "messages" | "shared-memory" | undefined;
            batchSize?: number | undefined;
            flushIntervalMs?: number | undefined;
        } | undefined;
    }>>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    orchestrator: z.ZodObject<{
        session: z.ZodObject<{
            persistSessions: z.ZodDefault<z.ZodBoolean>;
            dataDir: z.ZodDefault<z.ZodString>;
            sessionRetentionMs: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            persistSessions: boolean;
            dataDir: string;
            sessionRetentionMs: number;
        }, {
            persistSessions?: boolean | undefined;
            dataDir?: string | undefined;
            sessionRetentionMs?: number | undefined;
        }>;
        health: z.ZodObject<{
            checkInterval: z.ZodDefault<z.ZodNumber>;
            historyLimit: z.ZodDefault<z.ZodNumber>;
            degradedThreshold: z.ZodDefault<z.ZodNumber>;
            unhealthyThreshold: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            checkInterval: number;
            historyLimit: number;
            degradedThreshold: number;
            unhealthyThreshold: number;
        }, {
            checkInterval?: number | undefined;
            historyLimit?: number | undefined;
            degradedThreshold?: number | undefined;
            unhealthyThreshold?: number | undefined;
        }>;
        lifecycle: z.ZodObject<{
            maxConcurrentAgents: z.ZodDefault<z.ZodNumber>;
            spawnTimeout: z.ZodDefault<z.ZodNumber>;
            terminateTimeout: z.ZodDefault<z.ZodNumber>;
            maxSpawnRetries: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            maxConcurrentAgents: number;
            spawnTimeout: number;
            terminateTimeout: number;
            maxSpawnRetries: number;
        }, {
            maxConcurrentAgents?: number | undefined;
            spawnTimeout?: number | undefined;
            terminateTimeout?: number | undefined;
            maxSpawnRetries?: number | undefined;
        }>;
    }, "strip", z.ZodTypeAny, {
        health: {
            checkInterval: number;