/**
 * Learning Path Recommender for Serverless Platforms
 *
 * Recommends curated learning resources based on skill level, platform,
 * and best practices for serverless development.
 */
/**
 * User skill levels for serverless development
 */
export type SkillLevel = 'beginner' | 'intermediate' | 'advanced';
/**
 * Learning resource types
 */
export type ResourceType = 'tutorial' | 'documentation' | 'video' | 'course' | 'sample-project' | 'blog-post' | 'webinar';
/**
 * Complexity rating for sample projects
 */
export type ProjectComplexity = 'basic' | 'intermediate' | 'advanced';
/**
 * Best practice categories
 */
export type BestPracticeCategory = 'performance' | 'security' | 'cost' | 'architecture' | 'monitoring' | 'testing';
/**
 * Severity level for common pitfalls
 */
export type PitfallSeverity = 'critical' | 'high' | 'medium' | 'low';
/**
 * A single learning resource (tutorial, course, video, etc.)
 */
export interface LearningResource {
    id: string;
    title: string;
    url: string;
    type: ResourceType;
    skillLevel: SkillLevel;
    estimatedTime?: string;
    provider?: string;
    description?: string;
    tags?: string[];
    prerequisite?: string;
    lastVerified?: string;
}
/**
 * A best practice guide for a specific category
 */
export interface BestPractice {
    id: string;
    category: BestPracticeCategory;
    title: string;
    description: string;
    priority: 'high' | 'medium' | 'low';
    example?: string;
    relatedResources?: string[];
}
/**
 * A common pitfall with mitigation strategy
 */
export interface CommonPitfall {
    id: string;
    title: string;
    description: string;
    mitigation: string;
    severity: PitfallSeverity;
    example?: string;
    affectedSkillLevels?: SkillLevel[];
}
/**
 * A sample project with complexity rating
 */
export interface SampleProject extends LearningResource {
    complexity: ProjectComplexity;
    estimatedDuration?: string;
    technologies?: string[];
    sourceRepo?: string;
}
/**
 * Data freshness information
 */
export interface DataFreshness {
    lastVerified: string;
    isStale: boolean;
    staleDays: number;
    maxStaleDays: number;
}
/**
 * Complete learning path recommendation result
 */
export interface LearningPathResult {
    platform: string;
    platformId: string;
    skillLevel: SkillLevel;
    tutorials: LearningResource[];
    documentation: LearningResource[];
    videos: LearningResource[];
    courses: LearningResource[];
    sampleProjects: SampleProject[];
    bestPractices: BestPractice[];
    commonPitfalls: CommonPitfall[];
    dataFreshness: DataFreshness;
    nextSteps: string[];
    estimatedLearningTime?: string;
}
/**
 * Skill detection result with confidence
 */
export interface SkillDetectionResult {
    skillLevel: SkillLevel;
    confidence: 'low' | 'medium' | 'high';
    signals: string[];
    justification: string;
}
/**
 * Detect user skill level from natural language input
 *
 * Analyzes keywords and patterns to determine if user is beginner/intermediate/advanced
 * @param userInput - User's description of their experience
 * @returns SkillDetectionResult with detected level and confidence
 */
export declare function detectSkillLevel(userInput: string): SkillDetectionResult;
/**
 * Recommend learning path for a specific platform and skill level
 *
 * @param platformId - ID of the serverless platform
 * @param skillLevel - Optional skill level (will default to 'beginner' if not provided)
 * @returns Complete learning path recommendation
 */
export declare function recommendLearningPath(platformId: string, skillLevel?: SkillLevel): LearningPathResult;
/**
 * Get all available platform IDs
 */
export declare function getAvailablePlatforms(): string[];
/**
 * Get platforms with fresh data (not stale)
 */
export declare function getFreshPlatforms(maxStaleDays?: number): string[];
/**
 * Get stale platforms (data not verified within max days)
 */
export declare function getStalePlatforms(maxStaleDays?: number): string[];
/**
 * Get learning resources for a specific category and platform
 */
export declare function getResourcesByType(platformId: string, resourceType: ResourceType, skillLevel?: SkillLevel): LearningResource[];
/**
 * Validate learning path data integrity
 */
export declare function validateLearningPathData(): {
    isValid: boolean;
    errors: string[];
    warnings: string[];
};
//# sourceMappingURL=learning-path-recommender.d.ts.map