/**
 * JSON Schema definitions for all Wundr MCP tools
 * These schemas define the input parameters for each CLI command wrapper
 *
 * @module @wundr/mcp-server/tools/schemas
 */
import { z } from 'zod';
import { RagFileSearchSchema, RagStoreManageSchema, RagContextBuilderSchema, RagToolSchemaEntries } from './rag/schemas';
/**
 * Common options shared across multiple tools
 */
export declare const CommonOptionsSchema: z.ZodObject<{
    verbose: z.ZodOptional<z.ZodBoolean>;
    dryRun: z.ZodOptional<z.ZodBoolean>;
    format: z.ZodOptional<z.ZodEnum<["json", "table", "text"]>>;
}, "strip", z.ZodTypeAny, {
    format?: "text" | "json" | "table" | undefined;
    verbose?: boolean | undefined;
    dryRun?: boolean | undefined;
}, {
    format?: "text" | "json" | "table" | undefined;
    verbose?: boolean | undefined;
    dryRun?: boolean | undefined;
}>;
/**
 * Schema for computer-setup main command
 */
export declare const ComputerSetupSchema: z.ZodObject<{
    subcommand: z.ZodDefault<z.ZodOptional<z.ZodEnum<["run", "resume", "validate", "doctor", "install", "profile", "team", "backup", "rollback", "claude-config"]>>>;
    profile: z.ZodOptional<z.ZodEnum<["frontend", "backend", "fullstack", "devops", "ml"]>>;
    team: z.ZodOptional<z.ZodString>;
    mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<["interactive", "automated", "minimal"]>>>;
    skipExisting: z.ZodOptional<z.ZodBoolean>;
    parallel: z.ZodOptional<z.ZodBoolean>;
    report: z.ZodOptional<z.ZodBoolean>;
    dryRun: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    mode: "interactive" | "automated" | "minimal";
    subcommand: "backup" | "run" | "resume" | "validate" | "doctor" | "install" | "profile" | "team" | "rollback" | "claude-config";
    dryRun?: boolean | undefined;
    profile?: "frontend" | "backend" | "fullstack" | "devops" | "ml" | undefined;
    team?: string | undefined;
    skipExisting?: boolean | undefined;
    parallel?: boolean | undefined;
    report?: boolean | undefined;
}, {
    mode?: "interactive" | "automated" | "minimal" | undefined;
    dryRun?: boolean | undefined;
    profile?: "frontend" | "backend" | "fullstack" | "devops" | "ml" | undefined;
    team?: string | undefined;
    subcommand?: "backup" | "run" | "resume" | "validate" | "doctor" | "install" | "profile" | "team" | "rollback" | "claude-config" | undefined;
    skipExisting?: boolean | undefined;
    parallel?: boolean | undefined;
    report?: boolean | undefined;
}>;
export type ComputerSetupInput = z.infer<typeof ComputerSetupSchema>;
/**
 * Schema for computer-setup claude-config subcommand
 */
export declare const ClaudeConfigSchema: z.ZodObject<{
    skipBackup: z.ZodOptional<z.ZodBoolean>;
    overwrite: z.ZodOptional<z.ZodBoolean>;
    verbose: z.ZodOptional<z.ZodBoolean>;
    dryRun: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    verbose?: boolean | undefined;
    dryRun?: boolean | undefined;
    skipBackup?: boolean | undefined;
    overwrite?: boolean | undefined;
}, {
    verbose?: boolean | undefined;
    dryRun?: boolean | undefined;
    skipBackup?: boolean | undefined;
    overwrite?: boolean | undefined;
}>;
export type ClaudeConfigInput = z.infer<typeof ClaudeConfigSchema>;
/**
 * Schema for computer-setup backup subcommand
 */
export declare const BackupSchema: z.ZodObject<{
    action: z.ZodEnum<["list", "create", "verify", "cleanup"]>;
    backupId: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    action: "list" | "create" | "verify" | "cleanup";
    backupId?: string | undefined;
}, {
    action: "list" | "create" | "verify" | "cleanup";
    backupId?: string | undefined;
}>;
export type BackupInput = z.infer<typeof BackupSchema>;
/**
 * Schema for computer-setup rollback subcommand
 */
export declare const RollbackSchema: z.ZodObject<{
    backupId: z.ZodString;
    component: z.ZodOptional<z.ZodString>;
    force: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    backupId: string;
    force?: boolean | undefined;
    component?: string | undefined;
}, {
    backupId: string;
    force?: boolean | undefined;
    component?: string | undefined;
}>;
export type RollbackInput = z.infer<typeof RollbackSchema>;
/**
 * Schema for project-init command
 */
export declare const ProjectInitSchema: z.ZodObject<{
    name: z.ZodOptional<z.ZodString>;
    template: z.ZodDefault<z.ZodOptional<z.ZodEnum<["default", "monorepo", "frontend", "backend", "fullstack", "api", "library"]>>>;
    skipGit: z.ZodOptional<z.ZodBoolean>;
    skipInstall: z.ZodOptional<z.ZodBoolean>;
    monorepo: z.ZodOptional<z.ZodBoolean>;
    directory: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    template: "default" | "frontend" | "backend" | "fullstack" | "monorepo" | "api" | "library";
    name?: string | undefined;
    monorepo?: boolean | undefined;
    skipGit?: boolean | undefined;
    skipInstall?: boolean | undefined;
    directory?: string | undefined;
}, {
    name?: string | undefined;
    monorepo?: boolean | undefined;
    template?: "default" | "frontend" | "backend" | "fullstack" | "monorepo" | "api" | "library" | undefined;
    skipGit?: boolean | undefined;
    skipInstall?: boolean | undefined;
    directory?: string | undefined;
}>;
export type ProjectInitInput = z.infer<typeof ProjectInitSchema>;
/**
 * Schema for claude-setup consolidated command
 */
export declare const ClaudeSetupSchema: z.ZodObject<{
    subcommand: z.ZodDefault<z.ZodOptional<z.ZodEnum<["install", "mcp", "agents", "validate", "extension", "optimize"]>>>;
    skipChrome: z.ZodOptional<z.ZodBoolean>;
    skipMcp: z.ZodOptional<z.ZodBoolean>;
    skipAgents: z.ZodOptional<z.ZodBoolean>;
    tool: z.ZodOptional<z.ZodString>;
    profile: z.ZodOptional<z.ZodEnum<["frontend", "backend", "fullstack", "devops"]>>;
    agents: z.ZodOptional<z.ZodString>;
    fix: z.ZodOptional<z.ZodBoolean>;
    force: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    subcommand: "optimize" | "validate" | "install" | "mcp" | "agents" | "extension";
    tool?: string | undefined;
    force?: boolean | undefined;
    profile?: "frontend" | "backend" | "fullstack" | "devops" | undefined;
    agents?: string | undefined;
    skipChrome?: boolean | undefined;
    skipMcp?: boolean | undefined;
    skipAgents?: boolean | undefined;
    fix?: boolean | undefined;
}, {
    tool?: string | undefined;
    force?: boolean | undefined;
    profile?: "frontend" | "backend" | "fullstack" | "devops" | undefined;
    subcommand?: "optimize" | "validate" | "install" | "mcp" | "agents" | "extension" | undefined;
    agents?: string | undefined;
    skipChrome?: boolean | undefined;
    skipMcp?: boolean | undefined;
    skipAgents?: boolean | undefined;
    fix?: boolean | undefined;
}>;
export type ClaudeSetupInput = z.infer<typeof ClaudeSetupSchema>;
/**
 * Schema for drift-detection command
 */
export declare const DriftDetectionSchema: z.ZodObject<{
    action: z.ZodEnum<["check", "baseline", "trends", "report"]>;
    path: z.ZodOptional<z.ZodString>;
    baselineId: z.ZodOptional<z.ZodString>;
    threshold: z.ZodOptional<z.ZodNumber>;
    categories: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    format: z.ZodDefault<z.ZodOptional<z.ZodEnum<["json", "table", "markdown"]>>>;
    baselineStoreName: z.ZodOptional<z.ZodString>;
    currentStoreName: z.ZodOptional<z.ZodString>;
    enableSemanticAnalysis: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
}, "strip", z.ZodTypeAny, {
    action: "report" | "check" | "baseline" | "trends";
    format: "json" | "markdown" | "table";
    enableSemanticAnalysis: boolean;
    path?: string | undefined;
    baselineId?: string | undefined;
    threshold?: number | undefined;
    categories?: string[] | undefined;
    baselineStoreName?: string | undefined;
    currentStoreName?: string | undefined;
}, {
    action: "report" | "check" | "baseline" | "trends";
    path?: string | undefined;
    format?: "json" | "markdown" | "table" | undefined;
    baselineId?: string | undefined;
    threshold?: number | undefined;
    categories?: string[] | undefined;
    baselineStoreName?: string | undefined;
    currentStoreName?: string | undefined;
    enableSemanticAnalysis?: boolean | undefined;
}>;
export type DriftDetectionInput = z.infer<typeof DriftDetectionSchema>;
/**
 * Schema for pattern-standardize command
 */
export declare const PatternStandardizeSchema: z.ZodObject<{
    action: z.ZodEnum<["fix", "review", "list", "configure"]>;
    pattern: z.ZodOptional<z.ZodEnum<["error-handling", "import-ordering", "naming-conventions", "logging", "all"]>>;
    path: z.ZodOptional<z.ZodString>;
    autoFix: z.ZodOptional<z.ZodBoolean>;
    dryRun: z.ZodOptional<z.ZodBoolean>;
    severity: z.ZodOptional<z.ZodEnum<["error", "warning", "info"]>>;
}, "strip", z.ZodTypeAny, {
    action: "list" | "fix" | "review" | "configure";
    path?: string | undefined;
    severity?: "info" | "warning" | "error" | undefined;
    dryRun?: boolean | undefined;
    pattern?: "logging" | "error-handling" | "import-ordering" | "naming-conventions" | "all" | undefined;
    autoFix?: boolean | undefined;
}, {
    action: "list" | "fix" | "review" | "configure";
    path?: string | undefined;
    severity?: "info" | "warning" | "error" | undefined;
    dryRun?: boolean | undefined;
    pattern?: "logging" | "error-handling" | "import-ordering" | "naming-conventions" | "all" | undefined;
    autoFix?: boolean | undefined;
}>;
export type PatternStandardizeInput = z.infer<typeof PatternStandardizeSchema>;
/**
 * Schema for monorepo-manage command
 */
export declare const MonorepoManageSchema: z.ZodObject<{
    action: z.ZodEnum<["init", "add-package", "check-circular", "sync-versions", "list-packages", "graph"]>;
    packageName: z.ZodOptional<z.ZodString>;
    packageType: z.ZodOptional<z.ZodEnum<["library", "app", "tool", "plugin"]>>;
    template: z.ZodOptional<z.ZodString>;
    scope: z.ZodOptional<z.ZodString>;
    format: z.ZodDefault<z.ZodOptional<z.ZodEnum<["json", "table", "graph"]>>>;
}, "strip", z.ZodTypeAny, {
    action: "init" | "add-package" | "check-circular" | "sync-versions" | "list-packages" | "graph";
    format: "json" | "table" | "graph";
    template?: string | undefined;
    packageName?: string | undefined;
    packageType?: "tool" | "library" | "app" | "plugin" | undefined;
    scope?: string | undefined;
}, {
    action: "init" | "add-package" | "check-circular" | "sync-versions" | "list-packages" | "graph";
    format?: "json" | "table" | "graph" | undefined;
    template?: string | undefined;
    packageName?: string | undefined;
    packageType?: "tool" | "library" | "app" | "plugin" | undefined;
    scope?: string | undefined;
}>;
export type MonorepoManageInput = z.infer<typeof MonorepoManageSchema>;
/**
 * Schema for governance-report command
 */
export declare const GovernanceReportSchema: z.ZodObject<{
    reportType: z.ZodEnum<["weekly", "monthly", "compliance", "quality", "security", "custom"]>;
    period: z.ZodDefault<z.ZodOptional<z.ZodEnum<["daily", "weekly", "monthly", "quarterly"]>>>;
    startDate: z.ZodOptional<z.ZodString>;
    endDate: z.ZodOptional<z.ZodString>;
    output: z.ZodOptional<z.ZodString>;
    format: z.ZodDefault<z.ZodOptional<z.ZodEnum<["json", "markdown", "html", "pdf"]>>>;
    includeMetrics: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    format: "json" | "markdown" | "html" | "pdf";
    reportType: "custom" | "weekly" | "monthly" | "compliance" | "quality" | "security";
    period: "weekly" | "monthly" | "daily" | "quarterly";
    startDate?: string | undefined;
    endDate?: string | undefined;
    output?: string | undefined;
    includeMetrics?: string[] | undefined;
}, {
    reportType: "custom" | "weekly" | "monthly" | "compliance" | "quality" | "security";
    format?: "json" | "markdown" | "html" | "pdf" | undefined;
    period?: "weekly" | "monthly" | "daily" | "quarterly" | undefined;
    startDate?: string | undefined;
    endDate?: string | undefined;
    output?: string | undefined;
    includeMetrics?: string[] | undefined;
}>;
export type GovernanceReportInput = z.infer<typeof GovernanceReportSchema>;
/**
 * Schema for dependency-analyze command
 */
export declare const DependencyAnalyzeSchema: z.ZodObject<{
    action: z.ZodEnum<["circular", "unused", "outdated", "security", "graph", "all"]>;
    path: z.ZodOptional<z.ZodString>;
    depth: z.ZodOptional<z.ZodNumber>;
    includeDevDeps: z.ZodOptional<z.ZodBoolean>;
    format: z.ZodDefault<z.ZodOptional<z.ZodEnum<["json", "table", "graph", "dot"]>>>;
    output: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    action: "all" | "graph" | "security" | "circular" | "unused" | "outdated";
    format: "json" | "table" | "graph" | "dot";
    path?: string | undefined;
    output?: string | undefined;
    depth?: number | undefined;
    includeDevDeps?: boolean | undefined;
}, {
    action: "all" | "graph" | "security" | "circular" | "unused" | "outdated";
    path?: string | undefined;
    format?: "json" | "table" | "graph" | "dot" | undefined;
    output?: string | undefined;
    depth?: number | undefined;
    includeDevDeps?: boolean | undefined;
}>;
export type DependencyAnalyzeInput = z.infer<typeof DependencyAnalyzeSchema>;
/**
 * Schema for test-baseline command
 */
export declare const TestBaselineSchema: z.ZodObject<{
    action: z.ZodEnum<["create", "compare", "update", "report"]>;
    baselineId: z.ZodOptional<z.ZodString>;
    path: z.ZodOptional<z.ZodString>;
    coverageThreshold: z.ZodOptional<z.ZodNumber>;
    failOnDecrease: z.ZodOptional<z.ZodBoolean>;
    format: z.ZodDefault<z.ZodOptional<z.ZodEnum<["json", "table", "markdown"]>>>;
    output: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    action: "create" | "update" | "report" | "compare";
    format: "json" | "markdown" | "table";
    path?: string | undefined;
    baselineId?: string | undefined;
    output?: string | undefined;
    coverageThreshold?: number | undefined;
    failOnDecrease?: boolean | undefined;
}, {
    action: "create" | "update" | "report" | "compare";
    path?: string | undefined;
    format?: "json" | "markdown" | "table" | undefined;
    baselineId?: string | undefined;
    output?: string | undefined;
    coverageThreshold?: number | undefined;
    failOnDecrease?: boolean | undefined;
}>;
export type TestBaselineInput = z.infer<typeof TestBaselineSchema>;
export { RagFileSearchSchema, RagStoreManageSchema, RagContextBuilderSchema, RagToolSchemaEntries, };
export type { RagFileSearchInput, RagStoreManageInput, RagContextBuilderInput, RagToolName, } from './rag/schemas';
/**
 * Schema for RAG-powered error debugging
 *
 * Analyzes error messages, extracts key identifiers, searches for relevant
 * context and working examples using RAG, and generates actionable fix suggestions.
 */
export declare const ErrorDebuggerRagSchema: z.ZodObject<{
    errorType: z.ZodEnum<["lint", "typecheck", "build"]>;
    errorMessages: z.ZodArray<z.ZodString, "many">;
    targetPath: z.ZodString;
    maxSuggestionsPerError: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
}, "strip", z.ZodTypeAny, {
    errorType: "lint" | "typecheck" | "build";
    errorMessages: string[];
    targetPath: string;
    maxSuggestionsPerError: number;
}, {
    errorType: "lint" | "typecheck" | "build";
    errorMessages: string[];
    targetPath: string;
    maxSuggestionsPerError?: number | undefined;
}>;
export type ErrorDebuggerRagInput = z.infer<typeof ErrorDebuggerRagSchema>;
/**
 * Schema for RAG-enhanced codebase analysis
 */
export declare const CodebaseAnalysisRagSchema: z.ZodObject<{
    targetPath: z.ZodString;
    storeName: z.ZodOptional<z.ZodString>;
    forceReindex: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    includePatterns: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
    excludePatterns: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
    analysisCategories: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["architecture", "patterns", "dependencies", "tests", "security"]>, "many">>>;
    maxResultsPerCategory: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
    generateSummary: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
}, "strip", z.ZodTypeAny, {
    includePatterns: string[];
    excludePatterns: string[];
    targetPath: string;
    forceReindex: boolean;
    analysisCategories: ("security" | "architecture" | "patterns" | "dependencies" | "tests")[];
    maxResultsPerCategory: number;
    generateSummary: boolean;
    storeName?: string | undefined;
}, {
    targetPath: string;
    includePatterns?: string[] | undefined;
    excludePatterns?: string[] | undefined;
    storeName?: string | undefined;
    forceReindex?: boolean | undefined;
    analysisCategories?: ("security" | "architecture" | "patterns" | "dependencies" | "tests")[] | undefined;
    maxResultsPerCategory?: number | undefined;
    generateSummary?: boolean | undefined;
}>;
export type CodebaseAnalysisRagInput = z.infer<typeof CodebaseAnalysisRagSchema>;
/**
 * Schema for refactoring impact analysis
 */
export declare const RefactoringImpactSchema: z.ZodObject<{
    targetPath: z.ZodString;
    refactoringTarget: z.ZodString;
    refactoringType: z.ZodEnum<["rename", "move", "extract", "inline", "change-signature", "restructure", "deprecate", "delete"]>;
    searchScope: z.ZodDefault<z.ZodOptional<z.ZodEnum<["local", "project", "workspace"]>>>;
    storeName: z.ZodOptional<z.ZodString>;
    forceReindex: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    includePatterns: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
    excludePatterns: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
    includeTests: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    includeDocs: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    maxResults: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
}, "strip", z.ZodTypeAny, {
    includePatterns: string[];
    excludePatterns: string[];
    maxResults: number;
    includeDocs: boolean;
    targetPath: string;
    forceReindex: boolean;
    refactoringTarget: string;
    refactoringType: "delete" | "rename" | "move" | "extract" | "inline" | "change-signature" | "restructure" | "deprecate";
    searchScope: "local" | "project" | "workspace";
    includeTests: boolean;
    storeName?: string | undefined;
}, {
    targetPath: string;
    refactoringTarget: string;
    refactoringType: "delete" | "rename" | "move" | "extract" | "inline" | "change-signature" | "restructure" | "deprecate";
    includePatterns?: string[] | undefined;
    excludePatterns?: string[] | undefined;
    maxResults?: number | undefined;
    storeName?: string | undefined;
    includeDocs?: boolean | undefined;
    forceReindex?: boolean | undefined;
    searchScope?: "local" | "project" | "workspace" | undefined;
    includeTests?: boolean | undefined;
}>;
export type RefactoringImpactInput = z.infer<typeof RefactoringImpactSchema>;
/**
 * Registry of all tool schemas with metadata
 */
export declare const ToolSchemas: {
    readonly 'computer-setup': {
        readonly schema: z.ZodObject<{
            subcommand: z.ZodDefault<z.ZodOptional<z.ZodEnum<["run", "resume", "validate", "doctor", "install", "profile", "team", "backup", "rollback", "claude-config"]>>>;
            profile: z.ZodOptional<z.ZodEnum<["frontend", "backend", "fullstack", "devops", "ml"]>>;
            team: z.ZodOptional<z.ZodString>;
            mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<["interactive", "automated", "minimal"]>>>;
            skipExisting: z.ZodOptional<z.ZodBoolean>;
            parallel: z.ZodOptional<z.ZodBoolean>;
            report: z.ZodOptional<z.ZodBoolean>;
            dryRun: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            mode: "interactive" | "automated" | "minimal";
            subcommand: "backup" | "run" | "resume" | "validate" | "doctor" | "install" | "profile" | "team" | "rollback" | "claude-config";
            dryRun?: boolean | undefined;
            profile?: "frontend" | "backend" | "fullstack" | "devops" | "ml" | undefined;
            team?: string | undefined;
            skipExisting?: boolean | undefined;
            parallel?: boolean | undefined;
            report?: boolean | undefined;
        }, {
            mode?: "interactive" | "automated" | "minimal" | undefined;
            dryRun?: boolean | undefined;
            profile?: "frontend" | "backend" | "fullstack" | "devops" | "ml" | undefined;
            team?: string | undefined;
            subcommand?: "backup" | "run" | "resume" | "validate" | "doctor" | "install" | "profile" | "team" | "rollback" | "claude-config" | undefined;
            skipExisting?: boolean | undefined;
            parallel?: boolean | undefined;
            report?: boolean | undefined;
        }>;
        readonly description: "Set up a new developer machine with all required tools and configurations";
        readonly category: "setup";
    };
    readonly 'claude-config': {
        readonly schema: z.ZodObject<{
            skipBackup: z.ZodOptional<z.ZodBoolean>;
            overwrite: z.ZodOptional<z.ZodBoolean>;
            verbose: z.ZodOptional<z.ZodBoolean>;
            dryRun: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            verbose?: boolean | undefined;
            dryRun?: boolean | undefined;
            skipBackup?: boolean | undefined;
            overwrite?: boolean | undefined;
        }, {
            verbose?: boolean | undefined;
            dryRun?: boolean | undefined;
            skipBackup?: boolean | undefined;
            overwrite?: boolean | undefined;
        }>;
        readonly description: "Install Claude Code configuration files";
        readonly category: "setup";
    };
    readonly backup: {
        readonly schema: z.ZodObject<{
            action: z.ZodEnum<["list", "create", "verify", "cleanup"]>;
            backupId: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            action: "list" | "create" | "verify" | "cleanup";
            backupId?: string | undefined;
        }, {
            action: "list" | "create" | "verify" | "cleanup";
            backupId?: string | undefined;
        }>;
        readonly description: "Manage configuration backups";
        readonly category: "setup";
    };
    readonly rollback: {
        readonly schema: z.ZodObject<{
            backupId: z.ZodString;
            component: z.ZodOptional<z.ZodString>;
            force: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            backupId: string;
            force?: boolean | undefined;
            component?: string | undefined;
        }, {
            backupId: string;
            force?: boolean | undefined;
            component?: string | undefined;
        }>;
        readonly description: "Rollback to a previous configuration backup";
        readonly category: "setup";
    };
    readonly 'project-init': {
        readonly schema: z.ZodObject<{
            name: z.ZodOptional<z.ZodString>;
            template: z.ZodDefault<z.ZodOptional<z.ZodEnum<["default", "monorepo", "frontend", "backend", "fullstack", "api", "library"]>>>;
            skipGit: z.ZodOptional<z.ZodBoolean>;
            skipInstall: z.ZodOptional<z.ZodBoolean>;
            monorepo: z.ZodOptional<z.ZodBoolean>;
            directory: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            template: "default" | "frontend" | "backend" | "fullstack" | "monorepo" | "api" | "library";
            name?: string | undefined;
            monorepo?: boolean | undefined;
            skipGit?: boolean | undefined;
            skipInstall?: boolean | undefined;
            directory?: string | undefined;
        }, {
            name?: string | undefined;
            monorepo?: boolean | undefined;
            template?: "default" | "frontend" | "backend" | "fullstack" | "monorepo" | "api" | "library" | undefined;
            skipGit?: boolean | undefined;
            skipInstall?: boolean | undefined;
            directory?: string | undefined;
        }>;
        readonly description: "Initialize a new Wundr project with template selection";
        readonly category: "project";
    };
    readonly 'claude-setup': {
        readonly schema: z.ZodObject<{
            subcommand: z.ZodDefault<z.ZodOptional<z.ZodEnum<["install", "mcp", "agents", "validate", "extension", "optimize"]>>>;
            skipChrome: z.ZodOptional<z.ZodBoolean>;
            skipMcp: z.ZodOptional<z.ZodBoolean>;
            skipAgents: z.ZodOptional<z.ZodBoolean>;
            tool: z.ZodOptional<z.ZodString>;
            profile: z.ZodOptional<z.ZodEnum<["frontend", "backend", "fullstack", "devops"]>>;
            agents: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodBoolean>;
            force: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            subcommand: "optimize" | "validate" | "install" | "mcp" | "agents" | "extension";
            tool?: string | undefined;
            force?: boolean | undefined;
            profile?: "frontend" | "backend" | "fullstack" | "devops" | undefined;
            agents?: string | undefined;
            skipChrome?: boolean | undefined;
            skipMcp?: boolean | undefined;
            skipAgents?: boolean | undefined;
            fix?: boolean | undefined;
        }, {
            tool?: string | undefined;
            force?: boolean | undefined;
            profile?: "frontend" | "backend" | "fullstack" | "devops" | undefined;
            subcommand?: "optimize" | "validate" | "install" | "mcp" | "agents" | "extension" | undefined;
            agents?: string | undefined;
            skipChrome?: boolean | undefined;
            skipMcp?: boolean | undefined;
            skipAgents?: boolean | undefined;
            fix?: boolean | undefined;
        }>;
        readonly description: "Setup Claude Code, Ruflo, and MCP tools";
        readonly category: "setup";
    };
    readonly 'drift-detection': {
        readonly schema: z.ZodObject<{
            action: z.ZodEnum<["check", "baseline", "trends", "report"]>;
            path: z.ZodOptional<z.ZodString>;
            baselineId: z.ZodOptional<z.ZodString>;
            threshold: z.ZodOptional<z.ZodNumber>;
            categories: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
            format: z.ZodDefault<z.ZodOptional<z.ZodEnum<["json", "table", "markdown"]>>>;
            baselineStoreName: z.ZodOptional<z.ZodString>;
            currentStoreName: z.ZodOptional<z.ZodString>;
            enableSemanticAnalysis: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
        }, "strip", z.ZodTypeAny, {
            action: "report" | "check" | "baseline" | "trends";
            format: "json" | "markdown" | "table";
            enableSemanticAnalysis: boolean;
            path?: string | undefined;
            baselineId?: string | undefined;
            threshold?: number | undefined;
            categories?: string[] | undefined;
            baselineStoreName?: string | undefined;
            currentStoreName?: string | undefined;
        }, {
            action: "report" | "check" | "baseline" | "trends";
            path?: string | undefined;
            format?: "json" | "markdown" | "table" | undefined;
            baselineId?: string | undefined;
            threshold?: number | undefined;
            categories?: string[] | undefined;
            baselineStoreName?: string | undefined;
            currentStoreName?: string | undefined;
            enableSemanticAnalysis?: boolean | undefined;
        }>;
        readonly description: "Monitor code quality drift and create baselines";
        readonly category: "governance";
    };
    readonly 'pattern-standardize': {
        readonly schema: z.ZodObject<{
            action: z.ZodEnum<["fix", "review", "list", "configure"]>;
            pattern: z.ZodOptional<z.ZodEnum<["error-handling", "import-ordering", "naming-conventions", "logging", "all"]>>;
            path: z.ZodOptional<z.ZodString>;
            autoFix: z.ZodOptional<z.ZodBoolean>;
            dryRun: z.ZodOptional<z.ZodBoolean>;
            severity: z.ZodOptional<z.ZodEnum<["error", "warning", "info"]>>;
        }, "strip", z.ZodTypeAny, {
            action: "list" | "fix" | "review" | "configure";
            path?: string | undefined;
            severity?: "info" | "warning" | "error" | undefined;
            dryRun?: boolean | undefined;
            pattern?: "logging" | "error-handling" | "import-ordering" | "naming-conventions" | "all" | undefined;
            autoFix?: boolean | undefined;
        }, {
            action: "list" | "fix" | "review" | "configure";
            path?: string | undefined;
            severity?: "info" | "warning" | "error" | undefined;
            dryRun?: boolean | undefined;
            pattern?: "logging" | "error-handling" | "import-ordering" | "naming-conventions" | "all" | undefined;
            autoFix?: boolean | undefined;
        }>;
        readonly description: "Auto-fix code patterns to meet standards";
        readonly category: "governance";
    };
    readonly 'monorepo-manage': {
        readonly schema: z.ZodObject<{
            action: z.ZodEnum<["init", "add-package", "check-circular", "sync-versions", "list-packages", "graph"]>;
            packageName: z.ZodOptional<z.ZodString>;
            packageType: z.ZodOptional<z.ZodEnum<["library", "app", "tool", "plugin"]>>;
            template: z.ZodOptional<z.ZodString>;
            scope: z.ZodOptional<z.ZodString>;
            format: z.ZodDefault<z.ZodOptional<z.ZodEnum<["json", "table", "graph"]>>>;
        }, "strip", z.ZodTypeAny, {
            action: "init" | "add-package" | "check-circular" | "sync-versions" | "list-packages" | "graph";
            format: "json" | "table" | "graph";
            template?: string | undefined;
            packageName?: string | undefined;
            packageType?: "tool" | "library" | "app" | "plugin" | undefined;
            scope?: string | undefined;
        }, {
            action: "init" | "add-package" | "check-circular" | "sync-versions" | "list-packages" | "graph";
            format?: "json" | "table" | "graph" | undefined;
            template?: string | undefined;
            packageName?: string | undefined;
            packageType?: "tool" | "library" | "app" | "plugin" | undefined;
            scope?: string | undefined;
        }>;
        readonly description: "Manage monorepo packages and dependencies";
        readonly category: "project";
    };
    readonly 'governance-report': {
        readonly schema: z.ZodObject<{
            reportType: z.ZodEnum<["weekly", "monthly", "compliance", "quality", "security", "custom"]>;
            period: z.ZodDefault<z.ZodOptional<z.ZodEnum<["daily", "weekly", "monthly", "quarterly"]>>>;
            startDate: z.ZodOptional<z.ZodString>;
            endDate: z.ZodOptional<z.ZodString>;
            output: z.ZodOptional<z.ZodString>;
            format: z.ZodDefault<z.ZodOptional<z.ZodEnum<["json", "markdown", "html", "pdf"]>>>;
            includeMetrics: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        }, "strip", z.ZodTypeAny, {
            format: "json" | "markdown" | "html" | "pdf";
            reportType: "custom" | "weekly" | "monthly" | "compliance" | "quality" | "security";
            period: "weekly" | "monthly" | "daily" | "quarterly";
            startDate?: string | undefined;
            endDate?: string | undefined;
            output?: string | undefined;
            includeMetrics?: string[] | undefined;
        }, {
            reportType: "custom" | "weekly" | "monthly" | "compliance" | "quality" | "security";
            format?: "json" | "markdown" | "html" | "pdf" | undefined;
            period?: "weekly" | "monthly" | "daily" | "quarterly" | undefined;
            startDate?: string | undefined;
            endDate?: string | undefined;
            output?: string | undefined;
            includeMetrics?: string[] | undefined;
        }>;
        readonly description: "Generate governance and compliance reports";
        readonly category: "governance";
    };
    readonly 'dependency-analyze': {
        readonly schema: z.ZodObject<{
            action: z.ZodEnum<["circular", "unused", "outdated", "security", "graph", "all"]>;
            path: z.ZodOptional<z.ZodString>;
            depth: z.ZodOptional<z.ZodNumber>;
            includeDevDeps: z.ZodOptional<z.ZodBoolean>;
            format: z.ZodDefault<z.ZodOptional<z.ZodEnum<["json", "table", "graph", "dot"]>>>;
            output: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            action: "all" | "graph" | "security" | "circular" | "unused" | "outdated";
            format: "json" | "table" | "graph" | "dot";
            path?: string | undefined;
            output?: string | undefined;
            depth?: number | undefined;
            includeDevDeps?: boolean | undefined;
        }, {
            action: "all" | "graph" | "security" | "circular" | "unused" | "outdated";
            path?: string | undefined;
            format?: "json" | "table" | "graph" | "dot" | undefined;
            output?: string | undefined;
            depth?: number | undefined;
            includeDevDeps?: boolean | undefined;
        }>;
        readonly description: "Analyze project dependencies for issues";
        readonly category: "analysis";
    };
    readonly 'test-baseline': {
        readonly schema: z.ZodObject<{
            action: z.ZodEnum<["create", "compare", "update", "report"]>;
            baselineId: z.ZodOptional<z.ZodString>;
            path: z.ZodOptional<z.ZodString>;
            coverageThreshold: z.ZodOptional<z.ZodNumber>;
            failOnDecrease: z.ZodOptional<z.ZodBoolean>;
            format: z.ZodDefault<z.ZodOptional<z.ZodEnum<["json", "table", "markdown"]>>>;
            output: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            action: "create" | "update" | "report" | "compare";
            format: "json" | "markdown" | "table";
            path?: string | undefined;
            baselineId?: string | undefined;
            output?: string | undefined;
            coverageThreshold?: number | undefined;
            failOnDecrease?: boolean | undefined;
        }, {
            action: "create" | "update" | "report" | "compare";
            path?: string | undefined;
            format?: "json" | "markdown" | "table" | undefined;
            baselineId?: string | undefined;
            output?: string | undefined;
            coverageThreshold?: number | undefined;
            failOnDecrease?: boolean | undefined;
        }>;
        readonly description: "Manage test coverage baselines";
        readonly category: "testing";
    };
    readonly 'rag-file-search': {
        readonly schema: z.ZodObject<{
            query: z.ZodString;
            paths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
            includePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
            excludePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
            maxResults: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
            minScore: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
            mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<["semantic", "keyword", "hybrid"]>>>;
            includeContent: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
            maxContentLength: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
        }, "strip", z.ZodTypeAny, {
            query: string;
            maxResults: number;
            minScore: number;
            mode: "semantic" | "keyword" | "hybrid";
            includeContent: boolean;
            maxContentLength: number;
            paths?: string[] | undefined;
            includePatterns?: string[] | undefined;
            excludePatterns?: string[] | undefined;
        }, {
            query: string;
            paths?: string[] | undefined;
            includePatterns?: string[] | undefined;
            excludePatterns?: string[] | undefined;
            maxResults?: number | undefined;
            minScore?: number | undefined;
            mode?: "semantic" | "keyword" | "hybrid" | undefined;
            includeContent?: boolean | undefined;
            maxContentLength?: number | undefined;
        }>;
        readonly description: "Search files using semantic, keyword, or hybrid search with relevance scoring";
        readonly category: "rag";
    };
    readonly 'rag-store-manage': {
        readonly schema: z.ZodObject<{
            action: z.ZodEnum<["create", "delete", "list", "status", "index", "clear", "optimize", "backup", "restore"]>;
            storeName: z.ZodOptional<z.ZodString>;
            config: z.ZodOptional<z.ZodObject<{
                type: z.ZodOptional<z.ZodEnum<["memory", "chromadb", "pinecone", "qdrant", "weaviate"]>>;
                embeddingModel: z.ZodOptional<z.ZodEnum<["openai", "cohere", "local", "custom"]>>;
                dimensions: z.ZodOptional<z.ZodNumber>;
                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                type?: "memory" | "chromadb" | "pinecone" | "qdrant" | "weaviate" | undefined;
                metadata?: Record<string, unknown> | undefined;
                embeddingModel?: "custom" | "openai" | "cohere" | "local" | undefined;
                dimensions?: number | undefined;
            }, {
                type?: "memory" | "chromadb" | "pinecone" | "qdrant" | "weaviate" | undefined;
                metadata?: Record<string, unknown> | undefined;
                embeddingModel?: "custom" | "openai" | "cohere" | "local" | undefined;
                dimensions?: number | undefined;
            }>>;
            indexPaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
            backupPath: z.ZodOptional<z.ZodString>;
            force: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            action: "status" | "list" | "create" | "delete" | "index" | "clear" | "optimize" | "backup" | "restore";
            storeName?: string | undefined;
            config?: {
                type?: "memory" | "chromadb" | "pinecone" | "qdrant" | "weaviate" | undefined;
                metadata?: Record<string, unknown> | undefined;
                embeddingModel?: "custom" | "openai" | "cohere" | "local" | undefined;
                dimensions?: number | undefined;
            } | undefined;
            indexPaths?: string[] | undefined;
            backupPath?: string | undefined;
            force?: boolean | undefined;
        }, {
            action: "status" | "list" | "create" | "delete" | "index" | "clear" | "optimize" | "backup" | "restore";
            storeName?: string | undefined;
            config?: {
                type?: "memory" | "chromadb" | "pinecone" | "qdrant" | "weaviate" | undefined;
                metadata?: Record<string, unknown> | undefined;
                embeddingModel?: "custom" | "openai" | "cohere" | "local" | undefined;
                dimensions?: number | undefined;
            } | undefined;
            indexPaths?: string[] | undefined;
            backupPath?: string | undefined;
            force?: boolean | undefined;
        }>;
        readonly description: "Create, manage, and maintain vector stores for RAG operations";
        readonly category: "rag";
    };
    readonly 'rag-context-builder': {
        readonly schema: z.ZodObject<{
            query: z.ZodString;
            strategy: z.ZodDefault<z.ZodOptional<z.ZodEnum<["relevant", "recent", "comprehensive", "focused", "custom"]>>>;
            sources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["files", "store", "memory", "combined"]>, "many">>>;
            maxTokens: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
            storeName: z.ZodOptional<z.ZodString>;
            additionalPaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
            includeCode: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
            includeDocs: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
            conversationHistory: z.ZodOptional<z.ZodArray<z.ZodObject<{
                role: z.ZodEnum<["user", "assistant"]>;
                content: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                content: string;
                role: "user" | "assistant";
            }, {
                content: string;
                role: "user" | "assistant";
            }>, "many">>;
            format: z.ZodDefault<z.ZodOptional<z.ZodEnum<["plain", "markdown", "structured"]>>>;
        }, "strip", z.ZodTypeAny, {
            query: string;
            strategy: "custom" | "relevant" | "recent" | "comprehensive" | "focused";
            sources: ("memory" | "files" | "store" | "combined")[];
            maxTokens: number;
            includeCode: boolean;
            includeDocs: boolean;
            format: "plain" | "markdown" | "structured";
            storeName?: string | undefined;
            additionalPaths?: string[] | undefined;
            conversationHistory?: {
                content: string;
                role: "user" | "assistant";
            }[] | undefined;
        }, {
            query: string;
            storeName?: string | undefined;
            strategy?: "custom" | "relevant" | "recent" | "comprehensive" | "focused" | undefined;
            sources?: ("memory" | "files" | "store" | "combined")[] | undefined;
            maxTokens?: number | undefined;
            additionalPaths?: string[] | undefined;
            includeCode?: boolean | undefined;
            includeDocs?: boolean | undefined;
            conversationHistory?: {
                content: string;
                role: "user" | "assistant";
            }[] | undefined;
            format?: "plain" | "markdown" | "structured" | undefined;
        }>;
        readonly description: "Build optimal context for LLM queries using multiple sources and strategies";
        readonly category: "rag";
    };
    readonly 'codebase-analysis-rag': {
        readonly schema: z.ZodObject<{
            targetPath: z.ZodString;
            storeName: z.ZodOptional<z.ZodString>;
            forceReindex: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
            includePatterns: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
            excludePatterns: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
            analysisCategories: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["architecture", "patterns", "dependencies", "tests", "security"]>, "many">>>;
            maxResultsPerCategory: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
            generateSummary: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
        }, "strip", z.ZodTypeAny, {
            includePatterns: string[];
            excludePatterns: string[];
            targetPath: string;
            forceReindex: boolean;
            analysisCategories: ("security" | "architecture" | "patterns" | "dependencies" | "tests")[];
            maxResultsPerCategory: number;
            generateSummary: boolean;
            storeName?: string | undefined;
        }, {
            targetPath: string;
            includePatterns?: string[] | undefined;
            excludePatterns?: string[] | undefined;
            storeName?: string | undefined;
            forceReindex?: boolean | undefined;
            analysisCategories?: ("security" | "architecture" | "patterns" | "dependencies" | "tests")[] | undefined;
            maxResultsPerCategory?: number | undefined;
            generateSummary?: boolean | undefined;
        }>;
        readonly description: "Analyze a codebase using RAG-enhanced semantic search to understand architecture, patterns, dependencies, tests, and security measures";
        readonly category: "rag";
    };
    readonly 'refactoring-impact': {
        readonly schema: z.ZodObject<{
            targetPath: z.ZodString;
            refactoringTarget: z.ZodString;
            refactoringType: z.ZodEnum<["rename", "move", "extract", "inline", "change-signature", "restructure", "deprecate", "delete"]>;
            searchScope: z.ZodDefault<z.ZodOptional<z.ZodEnum<["local", "project", "workspace"]>>>;
            storeName: z.ZodOptional<z.ZodString>;
            forceReindex: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
            includePatterns: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
            excludePatterns: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
            includeTests: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
            includeDocs: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
            maxResults: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
        }, "strip", z.ZodTypeAny, {
            includePatterns: string[];
            excludePatterns: string[];
            maxResults: number;
            includeDocs: boolean;
            targetPath: string;
            forceReindex: boolean;
            refactoringTarget: string;
            refactoringType: "delete" | "rename" | "move" | "extract" | "inline" | "change-signature" | "restructure" | "deprecate";
            searchScope: "local" | "project" | "workspace";
            includeTests: boolean;
            storeName?: string | undefined;
        }, {
            targetPath: string;
            refactoringTarget: string;
            refactoringType: "delete" | "rename" | "move" | "extract" | "inline" | "change-signature" | "restructure" | "deprecate";
            includePatterns?: string[] | undefined;
            excludePatterns?: string[] | undefined;
            maxResults?: number | undefined;
            storeName?: string | undefined;
            includeDocs?: boolean | undefined;
            forceReindex?: boolean | undefined;
            searchScope?: "local" | "project" | "workspace" | undefined;
            includeTests?: boolean | undefined;
        }>;
        readonly description: "Analyze the potential impact of a refactoring operation using RAG search to find affected files, tests, and documentation";
        readonly category: "rag";
    };
    readonly 'error-debugger-rag': {
        readonly schema: z.ZodObject<{
            errorType: z.ZodEnum<["lint", "typecheck", "build"]>;
            errorMessages: z.ZodArray<z.ZodString, "many">;
            targetPath: z.ZodString;
            maxSuggestionsPerError: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
        }, "strip", z.ZodTypeAny, {
            errorType: "lint" | "typecheck" | "build";
            errorMessages: string[];
            targetPath: string;
            maxSuggestionsPerError: number;
        }, {
            errorType: "lint" | "typecheck" | "build";
            errorMessages: string[];
            targetPath: string;
            maxSuggestionsPerError?: number | undefined;
        }>;
        readonly description: "Debug errors using RAG-powered analysis with intelligent fix suggestions";
        readonly category: "rag";
    };
};
export type ToolName = keyof typeof ToolSchemas;
/**
 * Convert Zod schema to JSON Schema for MCP tool registration
 */
export declare function zodToJsonSchema(zodSchema: z.ZodType<any>): Record<string, unknown>;
/**
 * Get JSON Schema for a specific tool
 */
export declare function getToolJsonSchema(toolName: ToolName): Record<string, unknown>;
/**
 * Get all tool JSON schemas
 */
export declare function getAllToolJsonSchemas(): Record<string, {
    schema: Record<string, unknown>;
    description: string;
    category: string;
}>;
//# sourceMappingURL=schemas.d.ts.map