/**
 * MCP Tool Definitions
 *
 * Tool implementations for LearnGraph MCP server.
 * These tools enable Claude to interact with knowledge graphs.
 *
 * @packageDocumentation
 */
import { z } from 'zod';
import type { GraphStorage } from '../types/index.js';
import type { McpToolResult } from './types.js';
export declare const ListSkillsSchema: z.ZodObject<{
    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
    offset: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
    bloomLevel: z.ZodOptional<z.ZodEnum<["remember", "understand", "apply", "analyze", "evaluate", "create"]>>;
    tag: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    offset: number;
    limit: number;
    bloomLevel?: "remember" | "understand" | "apply" | "analyze" | "evaluate" | "create" | undefined;
    tag?: string | undefined;
}, {
    bloomLevel?: "remember" | "understand" | "apply" | "analyze" | "evaluate" | "create" | undefined;
    offset?: number | undefined;
    limit?: number | undefined;
    tag?: string | undefined;
}>;
export declare const GetSkillSchema: z.ZodObject<{
    skillId: z.ZodString;
}, "strip", z.ZodTypeAny, {
    skillId: string;
}, {
    skillId: string;
}>;
export declare const CreateSkillSchema: z.ZodObject<{
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    bloomLevel: z.ZodEnum<["remember", "understand", "apply", "analyze", "evaluate", "create"]>;
    estimatedMinutes: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
    tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
}, "strip", z.ZodTypeAny, {
    name: string;
    bloomLevel: "remember" | "understand" | "apply" | "analyze" | "evaluate" | "create";
    estimatedMinutes: number;
    tags: string[];
    description?: string | undefined;
}, {
    name: string;
    bloomLevel: "remember" | "understand" | "apply" | "analyze" | "evaluate" | "create";
    description?: string | undefined;
    estimatedMinutes?: number | undefined;
    tags?: string[] | undefined;
}>;
export declare const SearchSkillsSchema: z.ZodObject<{
    query: z.ZodString;
    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
}, "strip", z.ZodTypeAny, {
    limit: number;
    query: string;
}, {
    query: string;
    limit?: number | undefined;
}>;
export declare const GetPrerequisitesSchema: z.ZodObject<{
    skillId: z.ZodString;
    depth: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
}, "strip", z.ZodTypeAny, {
    skillId: string;
    depth: number;
}, {
    skillId: string;
    depth?: number | undefined;
}>;
export declare const GetDependentsSchema: z.ZodObject<{
    skillId: z.ZodString;
    depth: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
}, "strip", z.ZodTypeAny, {
    skillId: string;
    depth: number;
}, {
    skillId: string;
    depth?: number | undefined;
}>;
export declare const GetLearningPathSchema: z.ZodObject<{
    targetSkillId: z.ZodString;
    masteredSkillIds: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
}, "strip", z.ZodTypeAny, {
    targetSkillId: string;
    masteredSkillIds: string[];
}, {
    targetSkillId: string;
    masteredSkillIds?: string[] | undefined;
}>;
export declare const GetZpdSkillsSchema: z.ZodObject<{
    masteredSkillIds: z.ZodArray<z.ZodString, "many">;
    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
}, "strip", z.ZodTypeAny, {
    limit: number;
    masteredSkillIds: string[];
}, {
    masteredSkillIds: string[];
    limit?: number | undefined;
}>;
export declare const CreatePrerequisiteSchema: z.ZodObject<{
    sourceSkillId: z.ZodString;
    targetSkillId: z.ZodString;
    strength: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
    type: z.ZodDefault<z.ZodOptional<z.ZodEnum<["hard", "soft", "recommended"]>>>;
}, "strip", z.ZodTypeAny, {
    strength: number;
    type: "hard" | "soft" | "recommended";
    targetSkillId: string;
    sourceSkillId: string;
}, {
    targetSkillId: string;
    sourceSkillId: string;
    strength?: number | undefined;
    type?: "hard" | "soft" | "recommended" | undefined;
}>;
export declare const GetGraphStatsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
export declare const ValidateCurriculumSchema: z.ZodObject<{
    checkCycles: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    checkOrphans: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
}, "strip", z.ZodTypeAny, {
    checkCycles: boolean;
    checkOrphans: boolean;
}, {
    checkCycles?: boolean | undefined;
    checkOrphans?: boolean | undefined;
}>;
/**
 * List skills in the graph
 */
export declare function listSkills(storage: GraphStorage, params: z.infer<typeof ListSkillsSchema>): Promise<McpToolResult>;
/**
 * Get a single skill by ID
 */
export declare function getSkill(storage: GraphStorage, params: z.infer<typeof GetSkillSchema>): Promise<McpToolResult>;
/**
 * Create a new skill
 */
export declare function createSkill(storage: GraphStorage, params: z.infer<typeof CreateSkillSchema>): Promise<McpToolResult>;
/**
 * Search skills by name/description
 */
export declare function searchSkills(storage: GraphStorage, params: z.infer<typeof SearchSkillsSchema>): Promise<McpToolResult>;
/**
 * Get prerequisites for a skill
 */
export declare function getPrerequisites(storage: GraphStorage, params: z.infer<typeof GetPrerequisitesSchema>): Promise<McpToolResult>;
/**
 * Get dependents for a skill
 */
export declare function getDependents(storage: GraphStorage, params: z.infer<typeof GetDependentsSchema>): Promise<McpToolResult>;
/**
 * Get learning path to a target skill
 */
export declare function getLearningPath(storage: GraphStorage, params: z.infer<typeof GetLearningPathSchema>): Promise<McpToolResult>;
/**
 * Get skills in the Zone of Proximal Development
 */
export declare function getZpdSkills(storage: GraphStorage, params: z.infer<typeof GetZpdSkillsSchema>): Promise<McpToolResult>;
/**
 * Create a prerequisite relationship
 */
export declare function createPrerequisite(storage: GraphStorage, params: z.infer<typeof CreatePrerequisiteSchema>): Promise<McpToolResult>;
/**
 * Get graph statistics
 */
export declare function getGraphStats(storage: GraphStorage, _params: z.infer<typeof GetGraphStatsSchema>): Promise<McpToolResult>;
/**
 * Validate curriculum structure
 */
export declare function validateCurriculum(storage: GraphStorage, params: z.infer<typeof ValidateCurriculumSchema>): Promise<McpToolResult>;
/**
 * Export all tool definitions for MCP registration
 */
export declare const TOOL_DEFINITIONS: {
    readonly list_skills: {
        readonly description: "List all skills in the knowledge graph with optional filtering by Bloom's Taxonomy level or tags.";
        readonly inputSchema: z.ZodObject<{
            limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
            offset: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
            bloomLevel: z.ZodOptional<z.ZodEnum<["remember", "understand", "apply", "analyze", "evaluate", "create"]>>;
            tag: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            offset: number;
            limit: number;
            bloomLevel?: "remember" | "understand" | "apply" | "analyze" | "evaluate" | "create" | undefined;
            tag?: string | undefined;
        }, {
            bloomLevel?: "remember" | "understand" | "apply" | "analyze" | "evaluate" | "create" | undefined;
            offset?: number | undefined;
            limit?: number | undefined;
            tag?: string | undefined;
        }>;
        readonly handler: typeof listSkills;
    };
    readonly get_skill: {
        readonly description: "Get detailed information about a specific skill including its prerequisites and dependents.";
        readonly inputSchema: z.ZodObject<{
            skillId: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            skillId: string;
        }, {
            skillId: string;
        }>;
        readonly handler: typeof getSkill;
    };
    readonly create_skill: {
        readonly description: "Create a new skill in the knowledge graph with name, Bloom's level, and optional metadata.";
        readonly inputSchema: z.ZodObject<{
            name: z.ZodString;
            description: z.ZodOptional<z.ZodString>;
            bloomLevel: z.ZodEnum<["remember", "understand", "apply", "analyze", "evaluate", "create"]>;
            estimatedMinutes: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
            tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
        }, "strip", z.ZodTypeAny, {
            name: string;
            bloomLevel: "remember" | "understand" | "apply" | "analyze" | "evaluate" | "create";
            estimatedMinutes: number;
            tags: string[];
            description?: string | undefined;
        }, {
            name: string;
            bloomLevel: "remember" | "understand" | "apply" | "analyze" | "evaluate" | "create";
            description?: string | undefined;
            estimatedMinutes?: number | undefined;
            tags?: string[] | undefined;
        }>;
        readonly handler: typeof createSkill;
    };
    readonly search_skills: {
        readonly description: "Search for skills by name, description, or tags using fuzzy matching.";
        readonly inputSchema: z.ZodObject<{
            query: z.ZodString;
            limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
        }, "strip", z.ZodTypeAny, {
            limit: number;
            query: string;
        }, {
            query: string;
            limit?: number | undefined;
        }>;
        readonly handler: typeof searchSkills;
    };
    readonly get_prerequisites: {
        readonly description: "Get all prerequisite skills for a given skill, optionally traversing multiple levels deep.";
        readonly inputSchema: z.ZodObject<{
            skillId: z.ZodString;
            depth: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
        }, "strip", z.ZodTypeAny, {
            skillId: string;
            depth: number;
        }, {
            skillId: string;
            depth?: number | undefined;
        }>;
        readonly handler: typeof getPrerequisites;
    };
    readonly get_dependents: {
        readonly description: "Get all skills that depend on a given skill as a prerequisite.";
        readonly inputSchema: z.ZodObject<{
            skillId: z.ZodString;
            depth: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
        }, "strip", z.ZodTypeAny, {
            skillId: string;
            depth: number;
        }, {
            skillId: string;
            depth?: number | undefined;
        }>;
        readonly handler: typeof getDependents;
    };
    readonly get_learning_path: {
        readonly description: "Generate an optimal learning path to a target skill, considering already mastered skills.";
        readonly inputSchema: z.ZodObject<{
            targetSkillId: z.ZodString;
            masteredSkillIds: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
        }, "strip", z.ZodTypeAny, {
            targetSkillId: string;
            masteredSkillIds: string[];
        }, {
            targetSkillId: string;
            masteredSkillIds?: string[] | undefined;
        }>;
        readonly handler: typeof getLearningPath;
    };
    readonly get_zpd_skills: {
        readonly description: "Get skills in the learner's Zone of Proximal Development - skills they're ready to learn based on mastered prerequisites.";
        readonly inputSchema: z.ZodObject<{
            masteredSkillIds: z.ZodArray<z.ZodString, "many">;
            limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
        }, "strip", z.ZodTypeAny, {
            limit: number;
            masteredSkillIds: string[];
        }, {
            masteredSkillIds: string[];
            limit?: number | undefined;
        }>;
        readonly handler: typeof getZpdSkills;
    };
    readonly create_prerequisite: {
        readonly description: "Create a prerequisite relationship between two skills (source skill is required before target skill).";
        readonly inputSchema: z.ZodObject<{
            sourceSkillId: z.ZodString;
            targetSkillId: z.ZodString;
            strength: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
            type: z.ZodDefault<z.ZodOptional<z.ZodEnum<["hard", "soft", "recommended"]>>>;
        }, "strip", z.ZodTypeAny, {
            strength: number;
            type: "hard" | "soft" | "recommended";
            targetSkillId: string;
            sourceSkillId: string;
        }, {
            targetSkillId: string;
            sourceSkillId: string;
            strength?: number | undefined;
            type?: "hard" | "soft" | "recommended" | undefined;
        }>;
        readonly handler: typeof createPrerequisite;
    };
    readonly get_graph_stats: {
        readonly description: "Get statistics about the knowledge graph including skill counts, edge counts, and Bloom's Taxonomy distribution.";
        readonly inputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
        readonly handler: typeof getGraphStats;
    };
    readonly validate_curriculum: {
        readonly description: "Validate the curriculum structure checking for cycles and orphaned skills.";
        readonly inputSchema: z.ZodObject<{
            checkCycles: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
            checkOrphans: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
        }, "strip", z.ZodTypeAny, {
            checkCycles: boolean;
            checkOrphans: boolean;
        }, {
            checkCycles?: boolean | undefined;
            checkOrphans?: boolean | undefined;
        }>;
        readonly handler: typeof validateCurriculum;
    };
};
export type ToolName = keyof typeof TOOL_DEFINITIONS;
//# sourceMappingURL=tools.d.ts.map