@nice2dev/ui-tools 1.0.10

package/dist/education.d.ts

@@ -0,0 +1,1135 @@
+/**
+ * @file education.ts
+ * @module @nice2dev/ui-tools
+ * @description PRO-25 — Education & E-Learning Suite
+ *
+ * Types for lesson/course editing, quiz & assessment, interactive learning,
+ * dashboards, progress tracking, scheduling, and LMS integrations.
+ */
+/** Content type */
+export type EduContentType = 'text' | 'image' | 'video' | 'audio' | 'quiz' | 'interactive' | 'assignment' | 'discussion' | 'embed';
+/** Difficulty level */
+export type DifficultyLevel = 'beginner' | 'elementary' | 'intermediate' | 'advanced' | 'expert';
+/** Course status */
+export type CourseStatus = 'draft' | 'review' | 'published' | 'archived';
+/** Enrollment status */
+export type EnrollmentStatus = 'enrolled' | 'completed' | 'dropped' | 'waitlisted' | 'pending';
+/** Lesson editor config */
+export interface LessonEditorConfig {
+    project?: EduProject;
+    contentTypes?: EduContentType[];
+    templates?: LessonTemplate[];
+    scormSettings?: SCORMSettings;
+    xapiSettings?: xAPISettings;
+}
+/** Educational project */
+export interface EduProject {
+    id: string;
+    name: string;
+    description?: string;
+    defaultLanguage?: string;
+    supportedLanguages?: string[];
+}
+/** Lesson */
+export interface Lesson {
+    id: string;
+    title: string;
+    description?: string;
+    sections: LessonSection[];
+    duration?: number;
+    difficulty: DifficultyLevel;
+    prerequisites?: string[];
+    objectives?: LearningObjective[];
+    tags?: string[];
+    status: CourseStatus;
+    version?: number;
+    author: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/** Lesson section */
+export interface LessonSection {
+    id: string;
+    type: EduContentType;
+    order: number;
+    content: SectionContent;
+    settings?: SectionSettings;
+}
+/** Section content */
+export interface SectionContent {
+    text?: RichTextContent;
+    image?: ImageContent;
+    video?: VideoContent;
+    audio?: AudioContent;
+    quiz?: QuizReference;
+    interactive?: InteractiveContent;
+    embed?: EmbedContent;
+}
+/** Rich text content */
+export interface RichTextContent {
+    html: string;
+    markdown?: string;
+    latex?: string;
+}
+/** Image content */
+export interface ImageContent {
+    url: string;
+    alt: string;
+    caption?: string;
+    width?: number;
+    height?: number;
+}
+/** Video content */
+export interface VideoContent {
+    url: string;
+    provider?: VideoProvider;
+    duration?: number;
+    thumbnail?: string;
+    captions?: Caption[];
+    chapters?: VideoChapter[];
+    interactive?: InteractiveVideoConfig;
+}
+/** Video provider */
+export type VideoProvider = 'youtube' | 'vimeo' | 'wistia' | 'self-hosted' | 'stream';
+/** Caption */
+export interface Caption {
+    language: string;
+    url: string;
+    label?: string;
+}
+/** Video chapter */
+export interface VideoChapter {
+    title: string;
+    startTime: number;
+    endTime?: number;
+}
+/** Interactive video config */
+export interface InteractiveVideoConfig {
+    questions: VideoQuestion[];
+    bookmarks?: VideoBookmark[];
+    branches?: VideoBranch[];
+}
+/** Video question */
+export interface VideoQuestion {
+    id: string;
+    timestamp: number;
+    pauseVideo?: boolean;
+    questionId: string;
+    required?: boolean;
+}
+/** Video bookmark */
+export interface VideoBookmark {
+    id: string;
+    timestamp: number;
+    label: string;
+}
+/** Video branch */
+export interface VideoBranch {
+    id: string;
+    timestamp: number;
+    choices: BranchChoice[];
+}
+/** Branch choice */
+export interface BranchChoice {
+    label: string;
+    targetTime?: number;
+    targetVideoId?: string;
+}
+/** Audio content */
+export interface AudioContent {
+    url: string;
+    duration?: number;
+    transcript?: string;
+}
+/** Quiz reference */
+export interface QuizReference {
+    quizId: string;
+    inline?: boolean;
+    required?: boolean;
+}
+/** Interactive content */
+export interface InteractiveContent {
+    type: InteractiveType;
+    config: Record<string, unknown>;
+}
+/** Interactive type */
+export type InteractiveType = 'whiteboard' | 'flashcard' | 'simulation' | 'code_playground' | 'lab' | 'game';
+/** Embed content */
+export interface EmbedContent {
+    url: string;
+    provider?: string;
+    width?: number;
+    height?: number;
+}
+/** Section settings */
+export interface SectionSettings {
+    collapsible?: boolean;
+    defaultCollapsed?: boolean;
+    completion?: CompletionCriteria;
+}
+/** Completion criteria */
+export interface CompletionCriteria {
+    type: 'view' | 'time' | 'interaction' | 'score';
+    threshold?: number;
+    minTime?: number;
+    minScore?: number;
+}
+/** Learning objective */
+export interface LearningObjective {
+    id: string;
+    description: string;
+    bloomLevel?: BloomLevel;
+    measurable?: boolean;
+}
+/** Bloom's taxonomy level */
+export type BloomLevel = 'remember' | 'understand' | 'apply' | 'analyze' | 'evaluate' | 'create';
+/** Lesson template */
+export interface LessonTemplate {
+    id: string;
+    name: string;
+    description?: string;
+    type: LessonType;
+    sections: LessonSection[];
+}
+/** Lesson type */
+export type LessonType = 'lecture' | 'exercise' | 'lab' | 'project' | 'discussion' | 'assessment';
+/** Course */
+export interface Course {
+    id: string;
+    title: string;
+    subtitle?: string;
+    description?: string;
+    image?: string;
+    modules: CourseModule[];
+    instructors: Instructor[];
+    duration?: CourseDuration;
+    difficulty: DifficultyLevel;
+    prerequisites?: CoursePrerequisite[];
+    outcomes?: string[];
+    certification?: CertificationConfig;
+    pricing?: CoursePricing;
+    enrollment?: EnrollmentConfig;
+    status: CourseStatus;
+    publishedAt?: Date;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/** Course module */
+export interface CourseModule {
+    id: string;
+    title: string;
+    description?: string;
+    lessons: string[];
+    duration?: number;
+    order: number;
+    unlockCriteria?: UnlockCriteria;
+}
+/** Unlock criteria */
+export interface UnlockCriteria {
+    type: 'sequential' | 'date' | 'completion';
+    prerequisiteModules?: string[];
+    unlockDate?: Date;
+    requiredScore?: number;
+}
+/** Instructor */
+export interface Instructor {
+    id: string;
+    name: string;
+    avatar?: string;
+    bio?: string;
+    title?: string;
+    expertise?: string[];
+}
+/** Course duration */
+export interface CourseDuration {
+    estimated: number;
+    unit: 'hours' | 'weeks' | 'months';
+    selfPaced?: boolean;
+}
+/** Course prerequisite */
+export interface CoursePrerequisite {
+    type: 'course' | 'skill' | 'assessment';
+    referenceId?: string;
+    description: string;
+    required: boolean;
+}
+/** Certification config */
+export interface CertificationConfig {
+    enabled: boolean;
+    passingScore?: number;
+    certificate?: CertificateTemplate;
+    badge?: BadgeConfig;
+    expiration?: CertExpiration;
+}
+/** Certificate template */
+export interface CertificateTemplate {
+    id: string;
+    name: string;
+    design: string;
+    fields: CertField[];
+}
+/** Certificate field */
+export interface CertField {
+    name: string;
+    type: 'text' | 'date' | 'image' | 'qr';
+    value?: string;
+    position: {
+        x: number;
+        y: number;
+    };
+}
+/** Badge config */
+export interface BadgeConfig {
+    enabled: boolean;
+    image: string;
+    name: string;
+    description?: string;
+    criteria?: string;
+}
+/** Certification expiration */
+export interface CertExpiration {
+    enabled: boolean;
+    duration?: number;
+    unit?: 'months' | 'years';
+    renewalRequired?: boolean;
+}
+/** Course pricing */
+export interface CoursePricing {
+    type: 'free' | 'paid' | 'subscription';
+    price?: number;
+    currency?: string;
+    discounts?: Discount[];
+}
+/** Discount */
+export interface Discount {
+    code: string;
+    type: 'percentage' | 'fixed';
+    value: number;
+    validUntil?: Date;
+}
+/** Enrollment config */
+export interface EnrollmentConfig {
+    open: boolean;
+    capacity?: number;
+    waitlist?: boolean;
+    approval?: boolean;
+    startDate?: Date;
+    endDate?: Date;
+}
+/** Curriculum */
+export interface Curriculum {
+    id: string;
+    name: string;
+    description?: string;
+    terms: Term[];
+    totalCredits?: number;
+    graduationRequirements?: GraduationRequirement[];
+}
+/** Term (semester/quarter) */
+export interface Term {
+    id: string;
+    name: string;
+    startDate: Date;
+    endDate: Date;
+    courses: TermCourse[];
+}
+/** Term course */
+export interface TermCourse {
+    courseId: string;
+    credits?: number;
+    required?: boolean;
+    schedule?: CourseSchedule;
+}
+/** Course schedule */
+export interface CourseSchedule {
+    days: DayOfWeek[];
+    startTime: string;
+    endTime: string;
+    room?: string;
+}
+/** Day of week */
+export type DayOfWeek = 'monday' | 'tuesday' | 'wednesday' | 'thursday' | 'friday' | 'saturday' | 'sunday';
+/** Graduation requirement */
+export interface GraduationRequirement {
+    type: 'credits' | 'courses' | 'gpa';
+    value: number;
+    category?: string;
+}
+/** Learning path */
+export interface LearningPath {
+    id: string;
+    name: string;
+    description?: string;
+    nodes: PathNode[];
+    edges: PathEdge[];
+    estimatedDuration?: number;
+}
+/** Path node */
+export interface PathNode {
+    id: string;
+    type: 'course' | 'milestone' | 'skill';
+    referenceId?: string;
+    title: string;
+    position: {
+        x: number;
+        y: number;
+    };
+}
+/** Path edge */
+export interface PathEdge {
+    source: string;
+    target: string;
+    type?: 'required' | 'optional' | 'recommended';
+}
+/** Quiz */
+export interface Quiz {
+    id: string;
+    title: string;
+    description?: string;
+    instructions?: string;
+    questions: Question[];
+    settings: QuizSettings;
+    gradingConfig?: GradingConfig;
+    analytics?: QuizAnalytics;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/** Quiz settings */
+export interface QuizSettings {
+    timeLimit?: number;
+    attempts?: number;
+    shuffleQuestions?: boolean;
+    shuffleAnswers?: boolean;
+    showCorrectAnswers?: ShowAnswersMode;
+    passingScore?: number;
+    requireCompletion?: boolean;
+    lockAfterSubmit?: boolean;
+    poolConfig?: QuestionPoolConfig;
+}
+/** Show answers mode */
+export type ShowAnswersMode = 'never' | 'immediately' | 'after_due' | 'after_all_attempts';
+/** Question pool config */
+export interface QuestionPoolConfig {
+    enabled: boolean;
+    pools: QuestionPool[];
+}
+/** Question pool */
+export interface QuestionPool {
+    bankId: string;
+    count: number;
+    tags?: string[];
+    difficulty?: DifficultyLevel;
+}
+/** Question */
+export interface Question {
+    id: string;
+    type: QuestionType;
+    stem: string;
+    media?: MediaAttachment[];
+    points: number;
+    difficulty?: DifficultyLevel;
+    tags?: string[];
+    hint?: string;
+    explanation?: string;
+    feedback?: QuestionFeedback;
+    options?: QuestionOption[];
+    correctAnswer?: CorrectAnswer;
+    rubric?: GradingRubric;
+    metadata?: QuestionMetadata;
+}
+/** Question type */
+export type QuestionType = 'multiple_choice' | 'multiple_select' | 'true_false' | 'matching' | 'fill_blank' | 'short_answer' | 'essay' | 'math' | 'code' | 'drawing' | 'hotspot' | 'ranking';
+/** Media attachment */
+export interface MediaAttachment {
+    type: 'image' | 'audio' | 'video';
+    url: string;
+    alt?: string;
+}
+/** Question feedback */
+export interface QuestionFeedback {
+    correct?: string;
+    incorrect?: string;
+    partial?: string;
+}
+/** Question option */
+export interface QuestionOption {
+    id: string;
+    text: string;
+    media?: MediaAttachment;
+    correct?: boolean;
+    feedback?: string;
+    matchTarget?: string;
+}
+/** Correct answer */
+export interface CorrectAnswer {
+    type: 'exact' | 'contains' | 'regex' | 'range' | 'code_output';
+    value?: string | number | string[];
+    min?: number;
+    max?: number;
+    caseSensitive?: boolean;
+    testCases?: CodeTestCase[];
+}
+/** Code test case */
+export interface CodeTestCase {
+    input: string;
+    expectedOutput: string;
+    hidden?: boolean;
+    points?: number;
+}
+/** Grading rubric */
+export interface GradingRubric {
+    criteria: RubricCriterion[];
+    maxPoints: number;
+}
+/** Rubric criterion */
+export interface RubricCriterion {
+    name: string;
+    description?: string;
+    levels: RubricLevel[];
+    weight?: number;
+}
+/** Rubric level */
+export interface RubricLevel {
+    score: number;
+    label: string;
+    description: string;
+}
+/** Question metadata */
+export interface QuestionMetadata {
+    author?: string;
+    source?: string;
+    usageCount?: number;
+    averageScore?: number;
+    discriminationIndex?: number;
+}
+/** Grading config */
+export interface GradingConfig {
+    autoGrade?: boolean;
+    partialCredit?: boolean;
+    negativeMarking?: boolean;
+    negativeMarkValue?: number;
+    roundingMode?: 'none' | 'nearest' | 'up' | 'down';
+}
+/** Quiz analytics */
+export interface QuizAnalytics {
+    attempts: number;
+    averageScore: number;
+    medianScore: number;
+    passRate: number;
+    averageTime: number;
+    questionStats: QuestionStats[];
+}
+/** Question stats */
+export interface QuestionStats {
+    questionId: string;
+    correctRate: number;
+    averageTime: number;
+    skippedRate: number;
+    discrimination: number;
+}
+/** Question bank */
+export interface QuestionBank {
+    id: string;
+    name: string;
+    description?: string;
+    questions: Question[];
+    tags: string[];
+    subject?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/** Exam */
+export interface Exam {
+    id: string;
+    title: string;
+    description?: string;
+    sections: ExamSection[];
+    settings: ExamSettings;
+    schedule?: ExamSchedule;
+    proctoring?: ProctoringConfig;
+}
+/** Exam section */
+export interface ExamSection {
+    id: string;
+    title: string;
+    instructions?: string;
+    questions: Question[];
+    timeLimit?: number;
+    optional?: boolean;
+}
+/** Exam settings */
+export interface ExamSettings extends QuizSettings {
+    lockdownBrowser?: boolean;
+    disableCopyPaste?: boolean;
+    webcamRequired?: boolean;
+    idVerification?: boolean;
+}
+/** Exam schedule */
+export interface ExamSchedule {
+    startDate: Date;
+    endDate: Date;
+    durationMinutes: number;
+    accommodations?: ExamAccommodation[];
+}
+/** Exam accommodation */
+export interface ExamAccommodation {
+    studentId: string;
+    extraTime?: number;
+    separateRoom?: boolean;
+    notes?: string;
+}
+/** Proctoring config */
+export interface ProctoringConfig {
+    enabled: boolean;
+    provider?: ProctoringProvider;
+    settings?: ProctoringSettings;
+}
+/** Proctoring provider */
+export type ProctoringProvider = 'proctoru' | 'examity' | 'honorlock' | 'native';
+/** Proctoring settings */
+export interface ProctoringSettings {
+    webcam?: boolean;
+    screenShare?: boolean;
+    lockdownBrowser?: boolean;
+    idCheck?: boolean;
+    aiMonitoring?: boolean;
+}
+/** Whiteboard config */
+export interface WhiteboardConfig {
+    width?: number;
+    height?: number;
+    tools?: WhiteboardTool[];
+    collaboration?: CollaborationConfig;
+    recording?: RecordingConfig;
+}
+/** Whiteboard tool */
+export interface WhiteboardTool {
+    id: string;
+    type: WhiteboardToolType;
+    enabled: boolean;
+    settings?: Record<string, unknown>;
+}
+/** Whiteboard tool type */
+export type WhiteboardToolType = 'pen' | 'highlighter' | 'eraser' | 'text' | 'shape' | 'line' | 'arrow' | 'sticky_note' | 'image' | 'latex' | 'pointer' | 'select';
+/** Collaboration config */
+export interface CollaborationConfig {
+    enabled: boolean;
+    maxParticipants?: number;
+    roles?: CollaborationRole[];
+    cursors?: boolean;
+    chat?: boolean;
+}
+/** Collaboration role */
+export interface CollaborationRole {
+    name: string;
+    canDraw?: boolean;
+    canErase?: boolean;
+    canAddText?: boolean;
+    canDelete?: boolean;
+}
+/** Recording config */
+export interface RecordingConfig {
+    enabled: boolean;
+    autoStart?: boolean;
+    format?: 'webm' | 'mp4';
+    includeAudio?: boolean;
+}
+/** Flashcard deck */
+export interface FlashcardDeck {
+    id: string;
+    name: string;
+    description?: string;
+    cards: Flashcard[];
+    algorithm: SpacedRepetitionAlgorithm;
+    settings?: FlashcardSettings;
+    stats?: DeckStats;
+}
+/** Flashcard */
+export interface Flashcard {
+    id: string;
+    front: CardContent;
+    back: CardContent;
+    tags?: string[];
+    difficulty?: DifficultyLevel;
+    srData?: SpacedRepetitionData;
+}
+/** Card content */
+export interface CardContent {
+    text?: string;
+    html?: string;
+    image?: string;
+    audio?: string;
+    latex?: string;
+}
+/** Spaced repetition algorithm */
+export type SpacedRepetitionAlgorithm = 'sm2' | 'fsrs' | 'leitner' | 'custom';
+/** Spaced repetition data */
+export interface SpacedRepetitionData {
+    interval: number;
+    easeFactor: number;
+    repetitions: number;
+    nextReview: Date;
+    lastReview?: Date;
+}
+/** Flashcard settings */
+export interface FlashcardSettings {
+    newCardsPerDay?: number;
+    reviewsPerDay?: number;
+    autoAdvance?: boolean;
+    showProgress?: boolean;
+}
+/** Deck stats */
+export interface DeckStats {
+    totalCards: number;
+    newCards: number;
+    learningCards: number;
+    reviewCards: number;
+    masteredCards: number;
+    averageRetention?: number;
+}
+/** Code playground config */
+export interface CodePlaygroundConfig {
+    language: ProgrammingLanguage;
+    theme?: EditorTheme;
+    initialCode?: string;
+    testCases?: CodeTestCase[];
+    sandbox?: SandboxConfig;
+    features?: PlaygroundFeatures;
+}
+/** Programming language */
+export type ProgrammingLanguage = 'python' | 'javascript' | 'typescript' | 'java' | 'cpp' | 'csharp' | 'ruby' | 'go' | 'rust' | 'php' | 'sql' | 'scratch';
+/** Editor theme */
+export type EditorTheme = 'vs' | 'vs-dark' | 'monokai' | 'dracula' | 'github';
+/** Sandbox config */
+export interface SandboxConfig {
+    timeout?: number;
+    memoryLimit?: number;
+    allowNetwork?: boolean;
+    allowFileSystem?: boolean;
+}
+/** Playground features */
+export interface PlaygroundFeatures {
+    autocomplete?: boolean;
+    debugging?: boolean;
+    variableInspector?: boolean;
+    stepExecution?: boolean;
+    console?: boolean;
+    visualization?: boolean;
+}
+/** Virtual lab */
+export interface VirtualLab {
+    id: string;
+    title: string;
+    subject: LabSubject;
+    simulations: Simulation[];
+    instructions?: string;
+    objectives?: string[];
+}
+/** Lab subject */
+export type LabSubject = 'physics' | 'chemistry' | 'biology' | 'engineering' | 'computer_science';
+/** Simulation */
+export interface Simulation {
+    id: string;
+    name: string;
+    type: SimulationType;
+    parameters: SimParameter[];
+    initialState?: Record<string, unknown>;
+}
+/** Simulation type */
+export type SimulationType = 'physics_motion' | 'physics_electricity' | 'chemistry_reaction' | 'chemistry_titration' | 'biology_cell' | 'biology_genetics' | 'circuit';
+/** Simulation parameter */
+export interface SimParameter {
+    name: string;
+    type: 'number' | 'boolean' | 'select';
+    min?: number;
+    max?: number;
+    step?: number;
+    options?: string[];
+    default?: unknown;
+    unit?: string;
+}
+/** Student dashboard config */
+export interface StudentDashboardConfig {
+    widgets?: StudentWidget[];
+    layout?: DashboardLayout;
+    notifications?: NotificationConfig;
+}
+/** Student widget */
+export type StudentWidget = 'my_courses' | 'upcoming_deadlines' | 'grades' | 'achievements' | 'study_time' | 'calendar' | 'messages' | 'recommendations';
+/** Dashboard layout */
+export interface DashboardLayout {
+    columns?: number;
+    widgets: WidgetPosition[];
+}
+/** Widget position */
+export interface WidgetPosition {
+    widget: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Notification config */
+export interface NotificationConfig {
+    email?: boolean;
+    push?: boolean;
+    sms?: boolean;
+    types?: NotificationType[];
+}
+/** Notification type */
+export type NotificationType = 'deadline' | 'grade' | 'announcement' | 'message' | 'achievement';
+/** Teacher dashboard config */
+export interface TeacherDashboardConfig {
+    widgets?: TeacherWidget[];
+    classes?: ClassOverview[];
+    gradingQueue?: GradingQueueConfig;
+}
+/** Teacher widget */
+export type TeacherWidget = 'class_overview' | 'student_progress' | 'grading_queue' | 'attendance' | 'announcements' | 'calendar' | 'reports';
+/** Class overview */
+export interface ClassOverview {
+    classId: string;
+    name: string;
+    studentCount: number;
+    averageProgress: number;
+    upcomingDeadlines: number;
+    pendingGrading: number;
+}
+/** Grading queue config */
+export interface GradingQueueConfig {
+    sortBy?: 'date' | 'course' | 'type';
+    filter?: GradingFilter;
+}
+/** Grading filter */
+export interface GradingFilter {
+    courseIds?: string[];
+    types?: AssignmentType[];
+    dateRange?: DateRange;
+}
+/** Assignment type */
+export type AssignmentType = 'quiz' | 'essay' | 'project' | 'homework' | 'exam';
+/** Date range */
+export interface DateRange {
+    start: Date;
+    end: Date;
+}
+/** Admin dashboard config */
+export interface AdminDashboardConfig {
+    overview?: SchoolOverview;
+    analytics?: AnalyticsConfig;
+    resources?: ResourceOverview;
+}
+/** School overview */
+export interface SchoolOverview {
+    totalStudents: number;
+    totalTeachers: number;
+    totalCourses: number;
+    activeEnrollments: number;
+    completionRate: number;
+}
+/** Analytics config */
+export interface AnalyticsConfig {
+    metrics?: AnalyticsMetric[];
+    dateRange?: DateRange;
+    granularity?: 'day' | 'week' | 'month';
+}
+/** Analytics metric */
+export type AnalyticsMetric = 'enrollments' | 'completions' | 'engagement' | 'grades' | 'attendance';
+/** Resource overview */
+export interface ResourceOverview {
+    rooms: number;
+    equipment: number;
+    utilizationRate: number;
+}
+/** Progress tracker config */
+export interface ProgressTrackerConfig {
+    trackingMode: TrackingMode;
+    competencies?: Competency[];
+    milestones?: Milestone[];
+    alerts?: ProgressAlert[];
+}
+/** Tracking mode */
+export type TrackingMode = 'mastery' | 'time_based' | 'competency' | 'hybrid';
+/** Competency */
+export interface Competency {
+    id: string;
+    name: string;
+    description?: string;
+    skills: Skill[];
+    masteryThreshold?: number;
+}
+/** Skill */
+export interface Skill {
+    id: string;
+    name: string;
+    level?: DifficultyLevel;
+    assessments?: string[];
+}
+/** Milestone */
+export interface Milestone {
+    id: string;
+    name: string;
+    requirements: MilestoneRequirement[];
+    reward?: MilestoneReward;
+}
+/** Milestone requirement */
+export interface MilestoneRequirement {
+    type: 'course' | 'skill' | 'score' | 'time';
+    referenceId?: string;
+    value: number;
+}
+/** Milestone reward */
+export interface MilestoneReward {
+    type: 'badge' | 'certificate' | 'points' | 'unlock';
+    value?: string | number;
+}
+/** Progress alert */
+export interface ProgressAlert {
+    condition: AlertCondition;
+    action: AlertAction;
+}
+/** Alert condition */
+export interface AlertCondition {
+    type: 'behind' | 'at_risk' | 'inactive' | 'failing';
+    threshold?: number;
+    duration?: number;
+}
+/** Alert action */
+export interface AlertAction {
+    type: 'email' | 'notification' | 'flag' | 'intervention';
+    recipients?: string[];
+    message?: string;
+}
+/** Student progress */
+export interface StudentProgress {
+    studentId: string;
+    courseId: string;
+    overallProgress: number;
+    moduleProgress: ModuleProgress[];
+    timeSpent: number;
+    lastActive: Date;
+    status: ProgressStatus;
+    grade?: number;
+    competencies?: CompetencyProgress[];
+}
+/** Module progress */
+export interface ModuleProgress {
+    moduleId: string;
+    progress: number;
+    completed: boolean;
+    score?: number;
+    timeSpent: number;
+}
+/** Progress status */
+export type ProgressStatus = 'on_track' | 'ahead' | 'behind' | 'at_risk' | 'completed';
+/** Competency progress */
+export interface CompetencyProgress {
+    competencyId: string;
+    mastery: number;
+    skills: SkillProgress[];
+}
+/** Skill progress */
+export interface SkillProgress {
+    skillId: string;
+    level: number;
+    assessments: number;
+}
+/** Gradebook config */
+export interface GradebookConfig {
+    gradingScale: GradingScale;
+    categories: GradeCategory[];
+    weightingMode?: WeightingMode;
+    dropLowest?: number;
+    roundingRule?: RoundingRule;
+}
+/** Grading scale */
+export interface GradingScale {
+    type: 'percentage' | 'points' | 'letter' | 'pass_fail';
+    thresholds?: GradeThreshold[];
+}
+/** Grade threshold */
+export interface GradeThreshold {
+    grade: string;
+    minScore: number;
+    gpa?: number;
+}
+/** Grade category */
+export interface GradeCategory {
+    id: string;
+    name: string;
+    weight: number;
+    dropLowest?: number;
+}
+/** Weighting mode */
+export type WeightingMode = 'percentage' | 'points' | 'equal';
+/** Rounding rule */
+export type RoundingRule = 'none' | 'nearest' | 'up' | 'down' | 'nearest_half';
+/** Timetable config */
+export interface TimetableConfig {
+    term: Term;
+    constraints: ScheduleConstraint[];
+    rooms: Room[];
+    autoSchedule?: AutoScheduleConfig;
+}
+/** Schedule constraint */
+export interface ScheduleConstraint {
+    type: ConstraintType;
+    priority: 'required' | 'preferred' | 'optional';
+    parameters: Record<string, unknown>;
+}
+/** Constraint type */
+export type ConstraintType = 'teacher_availability' | 'room_capacity' | 'room_equipment' | 'no_consecutive' | 'preferred_time' | 'lunch_break';
+/** Room */
+export interface Room {
+    id: string;
+    name: string;
+    building?: string;
+    floor?: number;
+    capacity: number;
+    equipment?: string[];
+    type?: RoomType;
+    available?: Availability[];
+}
+/** Room type */
+export type RoomType = 'classroom' | 'lecture_hall' | 'lab' | 'computer_lab' | 'gym' | 'auditorium';
+/** Availability */
+export interface Availability {
+    dayOfWeek: DayOfWeek;
+    startTime: string;
+    endTime: string;
+}
+/** Auto schedule config */
+export interface AutoScheduleConfig {
+    algorithm: SchedulingAlgorithm;
+    maxIterations?: number;
+    optimizeFor?: OptimizationGoal[];
+}
+/** Scheduling algorithm */
+export type SchedulingAlgorithm = 'genetic' | 'constraint_satisfaction' | 'simulated_annealing';
+/** Optimization goal */
+export type OptimizationGoal = 'minimize_gaps' | 'teacher_preferences' | 'room_utilization' | 'student_conflicts';
+/** Attendance config */
+export interface AttendanceConfig {
+    methods?: AttendanceMethod[];
+    statuses?: AttendanceStatus[];
+    policies?: AttendancePolicy[];
+}
+/** Attendance method */
+export type AttendanceMethod = 'manual' | 'qr_code' | 'nfc' | 'biometric' | 'geofence';
+/** Attendance status */
+export interface AttendanceStatus {
+    id: string;
+    name: string;
+    code: string;
+    counted?: boolean;
+    excusable?: boolean;
+    color?: string;
+}
+/** Attendance policy */
+export interface AttendancePolicy {
+    name: string;
+    minAttendance: number;
+    consequences?: string;
+    exceptions?: string[];
+}
+/** Attendance record */
+export interface AttendanceRecord {
+    id: string;
+    studentId: string;
+    classId: string;
+    date: Date;
+    status: string;
+    checkInTime?: Date;
+    checkOutTime?: Date;
+    excuse?: ExcuseRecord;
+    notes?: string;
+}
+/** Excuse record */
+export interface ExcuseRecord {
+    type: ExcuseType;
+    description?: string;
+    document?: string;
+    approved?: boolean;
+    approvedBy?: string;
+}
+/** Excuse type */
+export type ExcuseType = 'medical' | 'family' | 'school_activity' | 'religious' | 'other';
+/** SCORM settings */
+export interface SCORMSettings {
+    version: SCORMVersion;
+    completionCriteria?: SCORMCompletion;
+    tracking?: SCORMTracking;
+}
+/** SCORM version */
+export type SCORMVersion = '1.2' | '2004_3rd' | '2004_4th';
+/** SCORM completion */
+export interface SCORMCompletion {
+    threshold?: number;
+    requireScore?: boolean;
+    requireTime?: boolean;
+}
+/** SCORM tracking */
+export interface SCORMTracking {
+    objectives?: boolean;
+    interactions?: boolean;
+    suspendData?: boolean;
+}
+/** xAPI settings */
+export interface xAPISettings {
+    endpoint: string;
+    auth?: xAPIAuth;
+    actor?: xAPIActor;
+    verbMapping?: VerbMapping[];
+}
+/** xAPI auth */
+export interface xAPIAuth {
+    type: 'basic' | 'oauth';
+    username?: string;
+    password?: string;
+    token?: string;
+}
+/** xAPI actor */
+export interface xAPIActor {
+    mbox?: string;
+    name?: string;
+    account?: xAPIAccount;
+}
+/** xAPI account */
+export interface xAPIAccount {
+    homePage: string;
+    name: string;
+}
+/** Verb mapping */
+export interface VerbMapping {
+    action: string;
+    verb: {
+        id: string;
+        display: Record<string, string>;
+    };
+}
+/** LMS integration config */
+export interface LMSIntegrationConfig {
+    provider: LMSProvider;
+    credentials: LMSCredentials;
+    syncConfig?: LMSSyncConfig;
+}
+/** LMS provider */
+export type LMSProvider = 'canvas' | 'moodle' | 'blackboard' | 'google_classroom' | 'microsoft_teams';
+/** LMS credentials */
+export interface LMSCredentials {
+    apiUrl: string;
+    apiKey?: string;
+    clientId?: string;
+    clientSecret?: string;
+    accessToken?: string;
+}
+/** LMS sync config */
+export interface LMSSyncConfig {
+    courses?: boolean;
+    users?: boolean;
+    grades?: boolean;
+    assignments?: boolean;
+    syncInterval?: number;
+    direction?: 'import' | 'export' | 'both';
+}
+//# sourceMappingURL=education.d.ts.map