import { z } from 'zod';
export declare const ArtifactMetadataSchema: z.ZodObject<{
    session: z.ZodString;
    step: z.ZodString;
    timestamp: z.ZodString;
    generator: z.ZodString;
    specialist: z.ZodOptional<z.ZodString>;
    project: z.ZodOptional<z.ZodString>;
    status: z.ZodDefault<z.ZodEnum<["pending", "in_progress", "completed", "failed", "blocked"]>>;
    dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
    estimatedDuration: z.ZodOptional<z.ZodNumber>;
    actualDuration: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    status?: "pending" | "completed" | "failed" | "in_progress" | "blocked";
    tags?: string[];
    dependencies?: string[];
    step?: string;
    timestamp?: string;
    priority?: "low" | "medium" | "high" | "critical";
    estimatedDuration?: number;
    project?: string;
    session?: string;
    generator?: string;
    specialist?: string;
    actualDuration?: number;
}, {
    status?: "pending" | "completed" | "failed" | "in_progress" | "blocked";
    tags?: string[];
    dependencies?: string[];
    step?: string;
    timestamp?: string;
    priority?: "low" | "medium" | "high" | "critical";
    estimatedDuration?: number;
    project?: string;
    session?: string;
    generator?: string;
    specialist?: string;
    actualDuration?: number;
}>;
export type ArtifactMetadata = z.infer<typeof ArtifactMetadataSchema>;
export declare const ArtifactContentSchema: z.ZodObject<{
    metadata: z.ZodObject<{
        session: z.ZodString;
        step: z.ZodString;
        timestamp: z.ZodString;
        generator: z.ZodString;
        specialist: z.ZodOptional<z.ZodString>;
        project: z.ZodOptional<z.ZodString>;
        status: z.ZodDefault<z.ZodEnum<["pending", "in_progress", "completed", "failed", "blocked"]>>;
        dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
        estimatedDuration: z.ZodOptional<z.ZodNumber>;
        actualDuration: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        status?: "pending" | "completed" | "failed" | "in_progress" | "blocked";
        tags?: string[];
        dependencies?: string[];
        step?: string;
        timestamp?: string;
        priority?: "low" | "medium" | "high" | "critical";
        estimatedDuration?: number;
        project?: string;
        session?: string;
        generator?: string;
        specialist?: string;
        actualDuration?: number;
    }, {
        status?: "pending" | "completed" | "failed" | "in_progress" | "blocked";
        tags?: string[];
        dependencies?: string[];
        step?: string;
        timestamp?: string;
        priority?: "low" | "medium" | "high" | "critical";
        estimatedDuration?: number;
        project?: string;
        session?: string;
        generator?: string;
        specialist?: string;
        actualDuration?: number;
    }>;
    content: z.ZodString;
    filePath: z.ZodString;
    size: z.ZodNumber;
    lastModified: z.ZodDate;
    checksum: z.ZodString;
}, "strip", z.ZodTypeAny, {
    metadata?: {
        status?: "pending" | "completed" | "failed" | "in_progress" | "blocked";
        tags?: string[];
        dependencies?: string[];
        step?: string;
        timestamp?: string;
        priority?: "low" | "medium" | "high" | "critical";
        estimatedDuration?: number;
        project?: string;
        session?: string;
        generator?: string;
        specialist?: string;
        actualDuration?: number;
    };
    size?: number;
    lastModified?: Date;
    checksum?: string;
    filePath?: string;
    content?: string;
}, {
    metadata?: {
        status?: "pending" | "completed" | "failed" | "in_progress" | "blocked";
        tags?: string[];
        dependencies?: string[];
        step?: string;
        timestamp?: string;
        priority?: "low" | "medium" | "high" | "critical";
        estimatedDuration?: number;
        project?: string;
        session?: string;
        generator?: string;
        specialist?: string;
        actualDuration?: number;
    };
    size?: number;
    lastModified?: Date;
    checksum?: string;
    filePath?: string;
    content?: string;
}>;
export type ArtifactContent = z.infer<typeof ArtifactContentSchema>;
export declare const ProjectStateSchema: z.ZodObject<{
    projectName: z.ZodString;
    totalArtifacts: z.ZodNumber;
    completedArtifacts: z.ZodNumber;
    failedArtifacts: z.ZodNumber;
    blockedArtifacts: z.ZodNumber;
    completionPercentage: z.ZodNumber;
    lastActivity: z.ZodDate;
    criticalPath: z.ZodArray<z.ZodString, "many">;
    blockers: z.ZodArray<z.ZodString, "many">;
    nextActions: z.ZodArray<z.ZodString, "many">;
    estimatedTimeRemaining: z.ZodOptional<z.ZodNumber>;
    artifactsByStatus: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
    dependencyGraph: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    projectName?: string;
    totalArtifacts?: number;
    completedArtifacts?: number;
    failedArtifacts?: number;
    blockedArtifacts?: number;
    completionPercentage?: number;
    lastActivity?: Date;
    criticalPath?: string[];
    blockers?: string[];
    nextActions?: string[];
    estimatedTimeRemaining?: number;
    artifactsByStatus?: Record<string, string[]>;
    dependencyGraph?: Record<string, string[]>;
}, {
    projectName?: string;
    totalArtifacts?: number;
    completedArtifacts?: number;
    failedArtifacts?: number;
    blockedArtifacts?: number;
    completionPercentage?: number;
    lastActivity?: Date;
    criticalPath?: string[];
    blockers?: string[];
    nextActions?: string[];
    estimatedTimeRemaining?: number;
    artifactsByStatus?: Record<string, string[]>;
    dependencyGraph?: Record<string, string[]>;
}>;
export type ProjectState = z.infer<typeof ProjectStateSchema>;
export declare const DependencyNodeSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    status: z.ZodEnum<["pending", "in_progress", "completed", "failed", "blocked"]>;
    dependencies: z.ZodArray<z.ZodString, "many">;
    dependents: z.ZodArray<z.ZodString, "many">;
    metadata: z.ZodObject<{
        session: z.ZodString;
        step: z.ZodString;
        timestamp: z.ZodString;
        generator: z.ZodString;
        specialist: z.ZodOptional<z.ZodString>;
        project: z.ZodOptional<z.ZodString>;
        status: z.ZodDefault<z.ZodEnum<["pending", "in_progress", "completed", "failed", "blocked"]>>;
        dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
        estimatedDuration: z.ZodOptional<z.ZodNumber>;
        actualDuration: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        status?: "pending" | "completed" | "failed" | "in_progress" | "blocked";
        tags?: string[];
        dependencies?: string[];
        step?: string;
        timestamp?: string;
        priority?: "low" | "medium" | "high" | "critical";
        estimatedDuration?: number;
        project?: string;
        session?: string;
        generator?: string;
        specialist?: string;
        actualDuration?: number;
    }, {
        status?: "pending" | "completed" | "failed" | "in_progress" | "blocked";
        tags?: string[];
        dependencies?: string[];
        step?: string;
        timestamp?: string;
        priority?: "low" | "medium" | "high" | "critical";
        estimatedDuration?: number;
        project?: string;
        session?: string;
        generator?: string;
        specialist?: string;
        actualDuration?: number;
    }>;
    criticalPath: z.ZodDefault<z.ZodBoolean>;
    estimatedDuration: z.ZodOptional<z.ZodNumber>;
    actualDuration: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    status?: "pending" | "completed" | "failed" | "in_progress" | "blocked";
    name?: string;
    metadata?: {
        status?: "pending" | "completed" | "failed" | "in_progress" | "blocked";
        tags?: string[];
        dependencies?: string[];
        step?: string;
        timestamp?: string;
        priority?: "low" | "medium" | "high" | "critical";
        estimatedDuration?: number;
        project?: string;
        session?: string;
        generator?: string;
        specialist?: string;
        actualDuration?: number;
    };
    dependencies?: string[];
    id?: string;
    estimatedDuration?: number;
    actualDuration?: number;
    criticalPath?: boolean;
    dependents?: string[];
}, {
    status?: "pending" | "completed" | "failed" | "in_progress" | "blocked";
    name?: string;
    metadata?: {
        status?: "pending" | "completed" | "failed" | "in_progress" | "blocked";
        tags?: string[];
        dependencies?: string[];
        step?: string;
        timestamp?: string;
        priority?: "low" | "medium" | "high" | "critical";
        estimatedDuration?: number;
        project?: string;
        session?: string;
        generator?: string;
        specialist?: string;
        actualDuration?: number;
    };
    dependencies?: string[];
    id?: string;
    estimatedDuration?: number;
    actualDuration?: number;
    criticalPath?: boolean;
    dependents?: string[];
}>;
export type DependencyNode = z.infer<typeof DependencyNodeSchema>;
export declare const DependencyGraphSchema: z.ZodObject<{
    nodes: z.ZodRecord<z.ZodString, z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
        status: z.ZodEnum<["pending", "in_progress", "completed", "failed", "blocked"]>;
        dependencies: z.ZodArray<z.ZodString, "many">;
        dependents: z.ZodArray<z.ZodString, "many">;
        metadata: z.ZodObject<{
            session: z.ZodString;
            step: z.ZodString;
            timestamp: z.ZodString;
            generator: z.ZodString;
            specialist: z.ZodOptional<z.ZodString>;
            project: z.ZodOptional<z.ZodString>;
            status: z.ZodDefault<z.ZodEnum<["pending", "in_progress", "completed", "failed", "blocked"]>>;
            dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
            tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
            priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
            estimatedDuration: z.ZodOptional<z.ZodNumber>;
            actualDuration: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            status?: "pending" | "completed" | "failed" | "in_progress" | "blocked";
            tags?: string[];
            dependencies?: string[];
            step?: string;
            timestamp?: string;
            priority?: "low" | "medium" | "high" | "critical";
            estimatedDuration?: number;
            project?: string;
            session?: string;
            generator?: string;
            specialist?: string;
            actualDuration?: number;
        }, {
            status?: "pending" | "completed" | "failed" | "in_progress" | "blocked";
            tags?: string[];
            dependencies?: string[];
            step?: string;
            timestamp?: string;
            priority?: "low" | "medium" | "high" | "critical";
            estimatedDuration?: number;
            project?: string;
            session?: string;
            generator?: string;
            specialist?: string;
            actualDuration?: number;
        }>;
        criticalPath: z.ZodDefault<z.ZodBoolean>;
        estimatedDuration: z.ZodOptional<z.ZodNumber>;
        actualDuration: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        status?: "pending" | "completed" | "failed" | "in_progress" | "blocked";
        name?: string;
        metadata?: {
            status?: "pending" | "completed" | "failed" | "in_progress" | "blocked";
            tags?: string[];
            dependencies?: string[];
            step?: string;
            timestamp?: string;
            priority?: "low" | "medium" | "high" | "critical";
            estimatedDuration?: number;
            project?: string;
            session?: string;
            generator?: string;
            specialist?: string;
            actualDuration?: number;
        };
        dependencies?: string[];
        id?: string;
        estimatedDuration?: number;
        actualDuration?: number;
        criticalPath?: boolean;
        dependents?: string[];
    }, {
        status?: "pending" | "completed" | "failed" | "in_progress" | "blocked";
        name?: string;
        metadata?: {
            status?: "pending" | "completed" | "failed" | "in_progress" | "blocked";
            tags?: string[];
            dependencies?: string[];
            step?: string;
            timestamp?: string;
            priority?: "low" | "medium" | "high" | "critical";
            estimatedDuration?: number;
            project?: string;
            session?: string;
            generator?: string;
            specialist?: string;
            actualDuration?: number;
        };
        dependencies?: string[];
        id?: string;
        estimatedDuration?: number;
        actualDuration?: number;
        criticalPath?: boolean;
        dependents?: string[];
    }>>;
    edges: z.ZodArray<z.ZodObject<{
        from: z.ZodString;
        to: z.ZodString;
        type: z.ZodDefault<z.ZodEnum<["hard", "soft", "conditional"]>>;
        weight: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        type?: "hard" | "soft" | "conditional";
        weight?: number;
        from?: string;
        to?: string;
    }, {
        type?: "hard" | "soft" | "conditional";
        weight?: number;
        from?: string;
        to?: string;
    }>, "many">;
    criticalPath: z.ZodArray<z.ZodString, "many">;
    parallelizable: z.ZodArray<z.ZodArray<z.ZodString, "many">, "many">;
    blockers: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    criticalPath?: string[];
    blockers?: string[];
    nodes?: Record<string, {
        status?: "pending" | "completed" | "failed" | "in_progress" | "blocked";
        name?: string;
        metadata?: {
            status?: "pending" | "completed" | "failed" | "in_progress" | "blocked";
            tags?: string[];
            dependencies?: string[];
            step?: string;
            timestamp?: string;
            priority?: "low" | "medium" | "high" | "critical";
            estimatedDuration?: number;
            project?: string;
            session?: string;
            generator?: string;
            specialist?: string;
            actualDuration?: number;
        };
        dependencies?: string[];
        id?: string;
        estimatedDuration?: number;
        actualDuration?: number;
        criticalPath?: boolean;
        dependents?: string[];
    }>;
    edges?: {
        type?: "hard" | "soft" | "conditional";
        weight?: number;
        from?: string;
        to?: string;
    }[];
    parallelizable?: string[][];
}, {
    criticalPath?: string[];
    blockers?: string[];
    nodes?: Record<string, {
        status?: "pending" | "completed" | "failed" | "in_progress" | "blocked";
        name?: string;
        metadata?: {
            status?: "pending" | "completed" | "failed" | "in_progress" | "blocked";
            tags?: string[];
            dependencies?: string[];
            step?: string;
            timestamp?: string;
            priority?: "low" | "medium" | "high" | "critical";
            estimatedDuration?: number;
            project?: string;
            session?: string;
            generator?: string;
            specialist?: string;
            actualDuration?: number;
        };
        dependencies?: string[];
        id?: string;
        estimatedDuration?: number;
        actualDuration?: number;
        criticalPath?: boolean;
        dependents?: string[];
    }>;
    edges?: {
        type?: "hard" | "soft" | "conditional";
        weight?: number;
        from?: string;
        to?: string;
    }[];
    parallelizable?: string[][];
}>;
export type DependencyGraph = z.infer<typeof DependencyGraphSchema>;
export declare const RecoveryContextSchema: z.ZodObject<{
    projectState: z.ZodObject<{
        projectName: z.ZodString;
        totalArtifacts: z.ZodNumber;
        completedArtifacts: z.ZodNumber;
        failedArtifacts: z.ZodNumber;
        blockedArtifacts: z.ZodNumber;
        completionPercentage: z.ZodNumber;
        lastActivity: z.ZodDate;
        criticalPath: z.ZodArray<z.ZodString, "many">;
        blockers: z.ZodArray<z.ZodString, "many">;
        nextActions: z.ZodArray<z.ZodString, "many">;
        estimatedTimeRemaining: z.ZodOptional<z.ZodNumber>;
        artifactsByStatus: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
        dependencyGraph: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        projectName?: string;
        totalArtifacts?: number;
        completedArtifacts?: number;
        failedArtifacts?: number;
        blockedArtifacts?: number;
        completionPercentage?: number;
        lastActivity?: Date;
        criticalPath?: string[];
        blockers?: string[];
        nextActions?: string[];
        estimatedTimeRemaining?: number;
        artifactsByStatus?: Record<string, string[]>;
        dependencyGraph?: Record<string, string[]>;
    }, {
        projectName?: string;
        totalArtifacts?: number;
        completedArtifacts?: number;
        failedArtifacts?: number;
        blockedArtifacts?: number;
        completionPercentage?: number;
        lastActivity?: Date;
        criticalPath?: string[];
        blockers?: string[];
        nextActions?: string[];
        estimatedTimeRemaining?: number;
        artifactsByStatus?: Record<string, string[]>;
        dependencyGraph?: Record<string, string[]>;
    }>;
    incompleteWork: z.ZodArray<z.ZodObject<{
        artifactId: z.ZodString;
        lastAttempt: z.ZodDate;
        failureReason: z.ZodOptional<z.ZodString>;
        retryCount: z.ZodDefault<z.ZodNumber>;
        priority: z.ZodEnum<["low", "medium", "high", "critical"]>;
    }, "strip", z.ZodTypeAny, {
        retryCount?: number;
        priority?: "low" | "medium" | "high" | "critical";
        artifactId?: string;
        lastAttempt?: Date;
        failureReason?: string;
    }, {
        retryCount?: number;
        priority?: "low" | "medium" | "high" | "critical";
        artifactId?: string;
        lastAttempt?: Date;
        failureReason?: string;
    }>, "many">;
    missingDependencies: z.ZodArray<z.ZodString, "many">;
    suggestedNextSteps: z.ZodArray<z.ZodString, "many">;
    recoveryStrategy: z.ZodEnum<["resume", "restart", "skip", "manual"]>;
    estimatedEffort: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    missingDependencies?: string[];
    recoveryStrategy?: "skip" | "resume" | "restart" | "manual";
    projectState?: {
        projectName?: string;
        totalArtifacts?: number;
        completedArtifacts?: number;
        failedArtifacts?: number;
        blockedArtifacts?: number;
        completionPercentage?: number;
        lastActivity?: Date;
        criticalPath?: string[];
        blockers?: string[];
        nextActions?: string[];
        estimatedTimeRemaining?: number;
        artifactsByStatus?: Record<string, string[]>;
        dependencyGraph?: Record<string, string[]>;
    };
    incompleteWork?: {
        retryCount?: number;
        priority?: "low" | "medium" | "high" | "critical";
        artifactId?: string;
        lastAttempt?: Date;
        failureReason?: string;
    }[];
    suggestedNextSteps?: string[];
    estimatedEffort?: number;
}, {
    missingDependencies?: string[];
    recoveryStrategy?: "skip" | "resume" | "restart" | "manual";
    projectState?: {
        projectName?: string;
        totalArtifacts?: number;
        completedArtifacts?: number;
        failedArtifacts?: number;
        blockedArtifacts?: number;
        completionPercentage?: number;
        lastActivity?: Date;
        criticalPath?: string[];
        blockers?: string[];
        nextActions?: string[];
        estimatedTimeRemaining?: number;
        artifactsByStatus?: Record<string, string[]>;
        dependencyGraph?: Record<string, string[]>;
    };
    incompleteWork?: {
        retryCount?: number;
        priority?: "low" | "medium" | "high" | "critical";
        artifactId?: string;
        lastAttempt?: Date;
        failureReason?: string;
    }[];
    suggestedNextSteps?: string[];
    estimatedEffort?: number;
}>;
export type RecoveryContext = z.infer<typeof RecoveryContextSchema>;
export declare const RecoveryPromptSchema: z.ZodObject<{
    title: z.ZodString;
    context: z.ZodObject<{
        projectState: z.ZodObject<{
            projectName: z.ZodString;
            totalArtifacts: z.ZodNumber;
            completedArtifacts: z.ZodNumber;
            failedArtifacts: z.ZodNumber;
            blockedArtifacts: z.ZodNumber;
            completionPercentage: z.ZodNumber;
            lastActivity: z.ZodDate;
            criticalPath: z.ZodArray<z.ZodString, "many">;
            blockers: z.ZodArray<z.ZodString, "many">;
            nextActions: z.ZodArray<z.ZodString, "many">;
            estimatedTimeRemaining: z.ZodOptional<z.ZodNumber>;
            artifactsByStatus: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
            dependencyGraph: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
        }, "strip", z.ZodTypeAny, {
            projectName?: string;
            totalArtifacts?: number;
            completedArtifacts?: number;
            failedArtifacts?: number;
            blockedArtifacts?: number;
            completionPercentage?: number;
            lastActivity?: Date;
            criticalPath?: string[];
            blockers?: string[];
            nextActions?: string[];
            estimatedTimeRemaining?: number;
            artifactsByStatus?: Record<string, string[]>;
            dependencyGraph?: Record<string, string[]>;
        }, {
            projectName?: string;
            totalArtifacts?: number;
            completedArtifacts?: number;
            failedArtifacts?: number;
            blockedArtifacts?: number;
            completionPercentage?: number;
            lastActivity?: Date;
            criticalPath?: string[];
            blockers?: string[];
            nextActions?: string[];
            estimatedTimeRemaining?: number;
            artifactsByStatus?: Record<string, string[]>;
            dependencyGraph?: Record<string, string[]>;
        }>;
        incompleteWork: z.ZodArray<z.ZodObject<{
            artifactId: z.ZodString;
            lastAttempt: z.ZodDate;
            failureReason: z.ZodOptional<z.ZodString>;
            retryCount: z.ZodDefault<z.ZodNumber>;
            priority: z.ZodEnum<["low", "medium", "high", "critical"]>;
        }, "strip", z.ZodTypeAny, {
            retryCount?: number;
            priority?: "low" | "medium" | "high" | "critical";
            artifactId?: string;
            lastAttempt?: Date;
            failureReason?: string;
        }, {
            retryCount?: number;
            priority?: "low" | "medium" | "high" | "critical";
            artifactId?: string;
            lastAttempt?: Date;
            failureReason?: string;
        }>, "many">;
        missingDependencies: z.ZodArray<z.ZodString, "many">;
        suggestedNextSteps: z.ZodArray<z.ZodString, "many">;
        recoveryStrategy: z.ZodEnum<["resume", "restart", "skip", "manual"]>;
        estimatedEffort: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        missingDependencies?: string[];
        recoveryStrategy?: "skip" | "resume" | "restart" | "manual";
        projectState?: {
            projectName?: string;
            totalArtifacts?: number;
            completedArtifacts?: number;
            failedArtifacts?: number;
            blockedArtifacts?: number;
            completionPercentage?: number;
            lastActivity?: Date;
            criticalPath?: string[];
            blockers?: string[];
            nextActions?: string[];
            estimatedTimeRemaining?: number;
            artifactsByStatus?: Record<string, string[]>;
            dependencyGraph?: Record<string, string[]>;
        };
        incompleteWork?: {
            retryCount?: number;
            priority?: "low" | "medium" | "high" | "critical";
            artifactId?: string;
            lastAttempt?: Date;
            failureReason?: string;
        }[];
        suggestedNextSteps?: string[];
        estimatedEffort?: number;
    }, {
        missingDependencies?: string[];
        recoveryStrategy?: "skip" | "resume" | "restart" | "manual";
        projectState?: {
            projectName?: string;
            totalArtifacts?: number;
            completedArtifacts?: number;
            failedArtifacts?: number;
            blockedArtifacts?: number;
            completionPercentage?: number;
            lastActivity?: Date;
            criticalPath?: string[];
            blockers?: string[];
            nextActions?: string[];
            estimatedTimeRemaining?: number;
            artifactsByStatus?: Record<string, string[]>;
            dependencyGraph?: Record<string, string[]>;
        };
        incompleteWork?: {
            retryCount?: number;
            priority?: "low" | "medium" | "high" | "critical";
            artifactId?: string;
            lastAttempt?: Date;
            failureReason?: string;
        }[];
        suggestedNextSteps?: string[];
        estimatedEffort?: number;
    }>;
    prompt: z.ZodString;
    instructions: z.ZodArray<z.ZodString, "many">;
    prerequisites: z.ZodArray<z.ZodString, "many">;
    expectedOutcome: z.ZodString;
    riskAssessment: z.ZodEnum<["low", "medium", "high"]>;
    timeEstimate: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    prompt?: string;
    context?: {
        missingDependencies?: string[];
        recoveryStrategy?: "skip" | "resume" | "restart" | "manual";
        projectState?: {
            projectName?: string;
            totalArtifacts?: number;
            completedArtifacts?: number;
            failedArtifacts?: number;
            blockedArtifacts?: number;
            completionPercentage?: number;
            lastActivity?: Date;
            criticalPath?: string[];
            blockers?: string[];
            nextActions?: string[];
            estimatedTimeRemaining?: number;
            artifactsByStatus?: Record<string, string[]>;
            dependencyGraph?: Record<string, string[]>;
        };
        incompleteWork?: {
            retryCount?: number;
            priority?: "low" | "medium" | "high" | "critical";
            artifactId?: string;
            lastAttempt?: Date;
            failureReason?: string;
        }[];
        suggestedNextSteps?: string[];
        estimatedEffort?: number;
    };
    title?: string;
    instructions?: string[];
    prerequisites?: string[];
    expectedOutcome?: string;
    riskAssessment?: "low" | "medium" | "high";
    timeEstimate?: number;
}, {
    prompt?: string;
    context?: {
        missingDependencies?: string[];
        recoveryStrategy?: "skip" | "resume" | "restart" | "manual";
        projectState?: {
            projectName?: string;
            totalArtifacts?: number;
            completedArtifacts?: number;
            failedArtifacts?: number;
            blockedArtifacts?: number;
            completionPercentage?: number;
            lastActivity?: Date;
            criticalPath?: string[];
            blockers?: string[];
            nextActions?: string[];
            estimatedTimeRemaining?: number;
            artifactsByStatus?: Record<string, string[]>;
            dependencyGraph?: Record<string, string[]>;
        };
        incompleteWork?: {
            retryCount?: number;
            priority?: "low" | "medium" | "high" | "critical";
            artifactId?: string;
            lastAttempt?: Date;
            failureReason?: string;
        }[];
        suggestedNextSteps?: string[];
        estimatedEffort?: number;
    };
    title?: string;
    instructions?: string[];
    prerequisites?: string[];
    expectedOutcome?: string;
    riskAssessment?: "low" | "medium" | "high";
    timeEstimate?: number;
}>;
export type RecoveryPrompt = z.infer<typeof RecoveryPromptSchema>;
export declare const AgentCapabilitySchema: z.ZodObject<{
    name: z.ZodString;
    description: z.ZodString;
    inputs: z.ZodArray<z.ZodString, "many">;
    outputs: z.ZodArray<z.ZodString, "many">;
    tools: z.ZodArray<z.ZodString, "many">;
    domains: z.ZodArray<z.ZodString, "many">;
    complexity: z.ZodEnum<["low", "medium", "high"]>;
    reliability: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    name?: string;
    description?: string;
    complexity?: "low" | "medium" | "high";
    tools?: string[];
    domains?: string[];
    inputs?: string[];
    outputs?: string[];
    reliability?: number;
}, {
    name?: string;
    description?: string;
    complexity?: "low" | "medium" | "high";
    tools?: string[];
    domains?: string[];
    inputs?: string[];
    outputs?: string[];
    reliability?: number;
}>;
export type AgentCapability = z.infer<typeof AgentCapabilitySchema>;
export declare const EnhancedAgentSpecSchema: z.ZodObject<{
    name: z.ZodString;
    version: z.ZodString;
    description: z.ZodString;
    capabilities: z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        description: z.ZodString;
        inputs: z.ZodArray<z.ZodString, "many">;
        outputs: z.ZodArray<z.ZodString, "many">;
        tools: z.ZodArray<z.ZodString, "many">;
        domains: z.ZodArray<z.ZodString, "many">;
        complexity: z.ZodEnum<["low", "medium", "high"]>;
        reliability: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        name?: string;
        description?: string;
        complexity?: "low" | "medium" | "high";
        tools?: string[];
        domains?: string[];
        inputs?: string[];
        outputs?: string[];
        reliability?: number;
    }, {
        name?: string;
        description?: string;
        complexity?: "low" | "medium" | "high";
        tools?: string[];
        domains?: string[];
        inputs?: string[];
        outputs?: string[];
        reliability?: number;
    }>, "many">;
    triggers: z.ZodArray<z.ZodString, "many">;
    dependencies: z.ZodArray<z.ZodString, "many">;
    health: z.ZodEnum<["healthy", "degraded", "unavailable"]>;
    lastChecked: z.ZodDate;
    performance: z.ZodObject<{
        avgResponseTime: z.ZodNumber;
        successRate: z.ZodNumber;
        errorRate: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        successRate?: number;
        avgResponseTime?: number;
        errorRate?: number;
    }, {
        successRate?: number;
        avgResponseTime?: number;
        errorRate?: number;
    }>;
    filePath: z.ZodString;
    checksum: z.ZodString;
}, "strip", z.ZodTypeAny, {
    name?: string;
    version?: string;
    description?: string;
    dependencies?: string[];
    capabilities?: {
        name?: string;
        description?: string;
        complexity?: "low" | "medium" | "high";
        tools?: string[];
        domains?: string[];
        inputs?: string[];
        outputs?: string[];
        reliability?: number;
    }[];
    checksum?: string;
    performance?: {
        successRate?: number;
        avgResponseTime?: number;
        errorRate?: number;
    };
    filePath?: string;
    triggers?: string[];
    health?: "healthy" | "degraded" | "unavailable";
    lastChecked?: Date;
}, {
    name?: string;
    version?: string;
    description?: string;
    dependencies?: string[];
    capabilities?: {
        name?: string;
        description?: string;
        complexity?: "low" | "medium" | "high";
        tools?: string[];
        domains?: string[];
        inputs?: string[];
        outputs?: string[];
        reliability?: number;
    }[];
    checksum?: string;
    performance?: {
        successRate?: number;
        avgResponseTime?: number;
        errorRate?: number;
    };
    filePath?: string;
    triggers?: string[];
    health?: "healthy" | "degraded" | "unavailable";
    lastChecked?: Date;
}>;
export type EnhancedAgentSpec = z.infer<typeof EnhancedAgentSpecSchema>;
export declare const FileOperationSchema: z.ZodObject<{
    type: z.ZodEnum<["read", "write", "delete", "move", "copy", "mkdir", "rmdir"]>;
    source: z.ZodString;
    destination: z.ZodOptional<z.ZodString>;
    content: z.ZodOptional<z.ZodString>;
    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
    atomic: z.ZodDefault<z.ZodBoolean>;
    backup: z.ZodDefault<z.ZodBoolean>;
    verify: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    options?: Record<string, any>;
    type?: "delete" | "read" | "write" | "move" | "copy" | "mkdir" | "rmdir";
    source?: string;
    content?: string;
    destination?: string;
    atomic?: boolean;
    backup?: boolean;
    verify?: boolean;
}, {
    options?: Record<string, any>;
    type?: "delete" | "read" | "write" | "move" | "copy" | "mkdir" | "rmdir";
    source?: string;
    content?: string;
    destination?: string;
    atomic?: boolean;
    backup?: boolean;
    verify?: boolean;
}>;
export type FileOperation = z.infer<typeof FileOperationSchema>;
export declare const FileOperationResultSchema: z.ZodObject<{
    operation: z.ZodObject<{
        type: z.ZodEnum<["read", "write", "delete", "move", "copy", "mkdir", "rmdir"]>;
        source: z.ZodString;
        destination: z.ZodOptional<z.ZodString>;
        content: z.ZodOptional<z.ZodString>;
        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
        atomic: z.ZodDefault<z.ZodBoolean>;
        backup: z.ZodDefault<z.ZodBoolean>;
        verify: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        options?: Record<string, any>;
        type?: "delete" | "read" | "write" | "move" | "copy" | "mkdir" | "rmdir";
        source?: string;
        content?: string;
        destination?: string;
        atomic?: boolean;
        backup?: boolean;
        verify?: boolean;
    }, {
        options?: Record<string, any>;
        type?: "delete" | "read" | "write" | "move" | "copy" | "mkdir" | "rmdir";
        source?: string;
        content?: string;
        destination?: string;
        atomic?: boolean;
        backup?: boolean;
        verify?: boolean;
    }>;
    success: z.ZodBoolean;
    timestamp: z.ZodDate;
    duration: z.ZodNumber;
    error: z.ZodOptional<z.ZodString>;
    rollbackInfo: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
}, "strip", z.ZodTypeAny, {
    timestamp?: Date;
    duration?: number;
    success?: boolean;
    error?: string;
    operation?: {
        options?: Record<string, any>;
        type?: "delete" | "read" | "write" | "move" | "copy" | "mkdir" | "rmdir";
        source?: string;
        content?: string;
        destination?: string;
        atomic?: boolean;
        backup?: boolean;
        verify?: boolean;
    };
    rollbackInfo?: Record<string, any>;
}, {
    timestamp?: Date;
    duration?: number;
    success?: boolean;
    error?: string;
    operation?: {
        options?: Record<string, any>;
        type?: "delete" | "read" | "write" | "move" | "copy" | "mkdir" | "rmdir";
        source?: string;
        content?: string;
        destination?: string;
        atomic?: boolean;
        backup?: boolean;
        verify?: boolean;
    };
    rollbackInfo?: Record<string, any>;
}>;
export type FileOperationResult = z.infer<typeof FileOperationResultSchema>;
export declare const FileWatchEventSchema: z.ZodObject<{
    type: z.ZodEnum<["created", "modified", "deleted", "moved"]>;
    path: z.ZodString;
    timestamp: z.ZodDate;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
}, "strip", z.ZodTypeAny, {
    path?: string;
    type?: "created" | "modified" | "deleted" | "moved";
    metadata?: Record<string, any>;
    timestamp?: Date;
}, {
    path?: string;
    type?: "created" | "modified" | "deleted" | "moved";
    metadata?: Record<string, any>;
    timestamp?: Date;
}>;
export type FileWatchEvent = z.infer<typeof FileWatchEventSchema>;
export declare const MonitoringConfigSchema: z.ZodObject<{
    paths: z.ZodArray<z.ZodString, "many">;
    recursive: z.ZodDefault<z.ZodBoolean>;
    debounceMs: z.ZodDefault<z.ZodNumber>;
    batchSize: z.ZodDefault<z.ZodNumber>;
    filters: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    excludes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    paths?: string[];
    recursive?: boolean;
    debounceMs?: number;
    batchSize?: number;
    filters?: string[];
    excludes?: string[];
}, {
    paths?: string[];
    recursive?: boolean;
    debounceMs?: number;
    batchSize?: number;
    filters?: string[];
    excludes?: string[];
}>;
export type MonitoringConfig = z.infer<typeof MonitoringConfigSchema>;
export declare const CacheEntrySchema: z.ZodObject<{
    key: z.ZodString;
    value: z.ZodAny;
    timestamp: z.ZodDate;
    ttl: z.ZodNumber;
    size: z.ZodNumber;
    hits: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    value?: any;
    timestamp?: Date;
    size?: number;
    key?: string;
    ttl?: number;
    hits?: number;
}, {
    value?: any;
    timestamp?: Date;
    size?: number;
    key?: string;
    ttl?: number;
    hits?: number;
}>;
export type CacheEntry = z.infer<typeof CacheEntrySchema>;
export declare const CacheStatsSchema: z.ZodObject<{
    totalEntries: z.ZodNumber;
    hitRate: z.ZodNumber;
    missRate: z.ZodNumber;
    totalSize: z.ZodNumber;
    evictions: z.ZodNumber;
    lastCleanup: z.ZodOptional<z.ZodDate>;
}, "strip", z.ZodTypeAny, {
    totalSize?: number;
    totalEntries?: number;
    hitRate?: number;
    missRate?: number;
    evictions?: number;
    lastCleanup?: Date;
}, {
    totalSize?: number;
    totalEntries?: number;
    hitRate?: number;
    missRate?: number;
    evictions?: number;
    lastCleanup?: Date;
}>;
export type CacheStats = z.infer<typeof CacheStatsSchema>;
export declare enum FileSystemErrorCode {
    PATH_NOT_FOUND = "PATH_NOT_FOUND",
    ACCESS_DENIED = "ACCESS_DENIED",
    DISK_FULL = "DISK_FULL",
    INVALID_PATH = "INVALID_PATH",
    OPERATION_FAILED = "OPERATION_FAILED",
    ATOMIC_FAILURE = "ATOMIC_FAILURE",
    VERIFICATION_FAILED = "VERIFICATION_FAILED",
    LOCK_TIMEOUT = "LOCK_TIMEOUT",
    CACHE_MISS = "CACHE_MISS",
    DEPENDENCY_CYCLE = "DEPENDENCY_CYCLE",
    ARTIFACT_CORRUPTED = "ARTIFACT_CORRUPTED",
    RECOVERY_FAILED = "RECOVERY_FAILED"
}
export declare class FileSystemError extends Error {
    code: FileSystemErrorCode;
    context?: any;
    recoverable: boolean;
    constructor(code: FileSystemErrorCode, message: string, context?: any, recoverable?: boolean);
}
export declare const FileSystemConfigSchema: z.ZodObject<{
    agentsDir: z.ZodString;
    outputDir: z.ZodString;
    tempDir: z.ZodString;
    cacheDir: z.ZodOptional<z.ZodString>;
    maxCacheSize: z.ZodDefault<z.ZodNumber>;
    maxCacheEntries: z.ZodDefault<z.ZodNumber>;
    cacheTtl: z.ZodDefault<z.ZodNumber>;
    enableWatching: z.ZodDefault<z.ZodBoolean>;
    enableCaching: z.ZodDefault<z.ZodBoolean>;
    enableAtomicOps: z.ZodDefault<z.ZodBoolean>;
    backupOnWrite: z.ZodDefault<z.ZodBoolean>;
    verifyOperations: z.ZodDefault<z.ZodBoolean>;
    monitoringConfig: z.ZodOptional<z.ZodObject<{
        paths: z.ZodArray<z.ZodString, "many">;
        recursive: z.ZodDefault<z.ZodBoolean>;
        debounceMs: z.ZodDefault<z.ZodNumber>;
        batchSize: z.ZodDefault<z.ZodNumber>;
        filters: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        excludes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        paths?: string[];
        recursive?: boolean;
        debounceMs?: number;
        batchSize?: number;
        filters?: string[];
        excludes?: string[];
    }, {
        paths?: string[];
        recursive?: boolean;
        debounceMs?: number;
        batchSize?: number;
        filters?: string[];
        excludes?: string[];
    }>>;
}, "strip", z.ZodTypeAny, {
    agentsDir?: string;
    outputDir?: string;
    tempDir?: string;
    cacheDir?: string;
    maxCacheSize?: number;
    maxCacheEntries?: number;
    cacheTtl?: number;
    enableWatching?: boolean;
    enableCaching?: boolean;
    enableAtomicOps?: boolean;
    backupOnWrite?: boolean;
    verifyOperations?: boolean;
    monitoringConfig?: {
        paths?: string[];
        recursive?: boolean;
        debounceMs?: number;
        batchSize?: number;
        filters?: string[];
        excludes?: string[];
    };
}, {
    agentsDir?: string;
    outputDir?: string;
    tempDir?: string;
    cacheDir?: string;
    maxCacheSize?: number;
    maxCacheEntries?: number;
    cacheTtl?: number;
    enableWatching?: boolean;
    enableCaching?: boolean;
    enableAtomicOps?: boolean;
    backupOnWrite?: boolean;
    verifyOperations?: boolean;
    monitoringConfig?: {
        paths?: string[];
        recursive?: boolean;
        debounceMs?: number;
        batchSize?: number;
        filters?: string[];
        excludes?: string[];
    };
}>;
export type FileSystemConfig = z.infer<typeof FileSystemConfigSchema>;
//# sourceMappingURL=filesystem.d.ts.map