@hydralms/components 0.1.3 → 0.3.0

package/dist/license/HydraContext.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+export type HydraPlan = 'pro' | 'free' | 'validating' | 'invalid';
+export interface HydraLicenseContextValue {
+    plan: HydraPlan;
+    isPro: boolean;
+}
+export declare const HydraLicenseContext: import('react').Context<HydraLicenseContextValue>;
+export interface HydraLicenseProviderProps {
+    licenseKey?: string;
+    validateUrl?: string;
+    children: ReactNode;
+}
+/** Provides license state to all HydraLMS components.
+ * When `validateUrl` is omitted or empty, all features are unlocked (dev mode).
+ */
+export declare function HydraLicenseProvider({ licenseKey, validateUrl, children }: HydraLicenseProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/license/ProBadge.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+/** Wraps children with a subtle "HydraLMS Pro" upgrade badge when the module requires a pro license. */
+export declare function ProBadge({ children, feature }: {
+    children: ReactNode;
+    feature?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/license/index.d.ts

@@ -0,0 +1,7 @@
+export { HydraLicenseProvider, HydraLicenseContext } from './HydraContext';
+export type { HydraPlan, HydraLicenseContextValue, HydraLicenseProviderProps } from './HydraContext';
+export { useHydraLicense } from './useHydraLicense';
+export { isProModule, PRO_MODULES } from './tiers';
+export type { ProModuleName } from './tiers';
+export { ProBadge } from './ProBadge';
+export { withProGate } from './withProGate';

package/dist/license/tiers.d.ts

@@ -0,0 +1,3 @@
+export declare const PRO_MODULES: Set<"QuizModule" | "FlashcardLab" | "CoursePlayer" | "ExamModule" | "SurveyModule" | "GradeCenterModule" | "AssignmentModule" | "CertificateModule" | "DiscussionModule" | "StudentDashboardModule" | "CourseCatalogModule" | "StudentProfileModule">;
+export type ProModuleName = typeof PRO_MODULES extends Set<infer T> ? T : never;
+export declare function isProModule(name: string): boolean;

package/dist/license/useHydraLicense.d.ts

@@ -0,0 +1,6 @@
+import { HydraLicenseContextValue } from './HydraContext';
+/** Returns the current HydraLMS license status. Pro modules render with a
+ * watermark badge when `isPro` is false. Wrap your app in `<HydraProvider>`
+ * with a valid license key to unlock all features.
+ */
+export declare function useHydraLicense(): HydraLicenseContextValue;

package/dist/license/validate.d.ts

@@ -0,0 +1,13 @@
+export type KeyResult = 'valid-pro' | 'valid-free' | 'invalid' | 'no-key' | 'skip';
+export interface ValidationResponse {
+    valid: boolean;
+    plan: 'pro' | 'enterprise' | null;
+}
+/**
+ * Validate a license key against the validation endpoint.
+ * @param rawKey - The license key string, or null if not provided.
+ * @param validateUrl - The validation endpoint URL. Empty string skips validation (dev mode).
+ */
+export declare function validateKey(rawKey: string | null, validateUrl: string): Promise<KeyResult>;
+/** Whether a watermark should be shown for the given key result. */
+export declare function shouldShowWatermark(result: KeyResult): boolean;

package/dist/license/withProGate.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+/** Higher-order component that wraps a pro-tier module with ProBadge when unlicensed. */
+export declare function withProGate<P extends object>(Component: React.ComponentType<P>, moduleName: string): {
+    (props: P): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/modules/AssignmentModule/AssignmentModule.d.ts

@@ -0,0 +1,5 @@
+import { AssignmentModuleProps } from './types';
+export declare const AssignmentModule: {
+    (props: AssignmentModuleProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/modules/AssignmentModule/types.d.ts

@@ -0,0 +1,69 @@
+import { ReactNode } from 'react';
+import { SubmissionData } from '../../sections/AssignmentSubmission/types';
+import { RubricCriterion } from '../../sections/RubricView/types';
+/**
+ * AssignmentModule — a complete assignment experience with instructions,
+ * submission, and confirmation/grade review.
+ *
+ * Steps: Instructions → Work (AssignmentSubmission) → Confirmation.
+ * Optionally shows a grading rubric in both the instructions and
+ * graded confirmation views.
+ *
+ * @example
+ * <AssignmentModule
+ *   title="Week 3 Essay"
+ *   instructions={<p>Write a 500-word essay on React hooks.</p>}
+ *   submissionTypes={["text", "file"]}
+ *   rubric={rubricCriteria}
+ *   onSubmit={(submission) => submitAssignment(submission)}
+ * />
+ */
+export interface AssignmentModuleProps {
+    /** Assignment title */
+    title: string;
+    /** Assignment instructions (rich content) */
+    instructions: ReactNode;
+    /** Due date as ISO string */
+    dueDate?: string;
+    /** Maximum score points */
+    maxScore?: number;
+    /** Allowed submission types */
+    submissionTypes: ("text" | "file" | "url")[];
+    /** File upload constraints */
+    fileConstraints?: {
+        maxFiles?: number;
+        maxSizeMB?: number;
+        acceptedTypes?: string;
+    };
+    /** Rubric criteria for grading (shown in instructions and graded confirmation) */
+    rubric?: RubricCriterion[];
+    /** Existing submission for editing/viewing */
+    existingSubmission?: SubmissionData;
+    /** Current submission status. @default "not_started" */
+    status?: "not_started" | "draft" | "submitted" | "late" | "graded" | "resubmit";
+    /** Grade data when graded */
+    grade?: {
+        score: number;
+        feedback?: ReactNode;
+        /** Selected rubric level UIDs per criterion UID */
+        rubricLevels?: Record<string, string>;
+    };
+    /** Called on final submission */
+    onSubmit?: (submission: SubmissionData) => void;
+    /** Called when the assignment is submitted or draft-saved, with the full result */
+    onComplete?: (result: AssignmentModuleResult) => void;
+    /** Called on draft save */
+    onSaveDraft?: (submission: SubmissionData) => void;
+    /** When true, disables interactions for preview/demo mode. @default false */
+    readOnly?: boolean;
+    /** CSS class name for the root element */
+    className?: string;
+    /** Inline styles for the root element */
+    style?: React.CSSProperties;
+}
+export interface AssignmentModuleResult {
+    /** The submitted data */
+    submission: SubmissionData;
+    /** Status after submission */
+    status: "not_started" | "draft" | "submitted" | "late" | "graded" | "resubmit";
+}

package/dist/modules/CertificateModule/CertificateModule.d.ts

@@ -0,0 +1,5 @@
+import { CertificateModuleProps } from './types';
+export declare const CertificateModule: {
+    (props: CertificateModuleProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/modules/CertificateModule/types.d.ts

@@ -0,0 +1,51 @@
+import { Requirement } from '../../sections/RequirementsChecklist/types';
+import { CertificateVariant } from '../../sections/CertificateViewer/types';
+/**
+ * CertificateModule — a certificate-earning flow with requirements tracking
+ * and certificate display.
+ *
+ * Steps: Requirements (checklist + progress) → Certificate (CertificateViewer).
+ * The certificate step is only accessible when all requirements are met.
+ *
+ * @example
+ * <CertificateModule
+ *   courseTitle="React Fundamentals"
+ *   recipientName="Jane Smith"
+ *   organizationName="HydraLMS Academy"
+ *   requirements={requirements}
+ *   overallProgress={100}
+ * />
+ */
+export interface CertificateModuleProps {
+    /** Course or program title */
+    courseTitle: string;
+    /** Recipient's full name */
+    recipientName: string;
+    /** Issuing organization name */
+    organizationName: string;
+    /** Organization logo URL */
+    organizationLogo?: string;
+    /** Signatory information */
+    signatory?: {
+        name: string;
+        title: string;
+    };
+    /** Completion date (used on the certificate) */
+    completionDate?: string;
+    /** Certificate visual variant. @default "modern" */
+    certificateVariant?: CertificateVariant;
+    /** Completion requirements */
+    requirements: Requirement[];
+    /** Overall course progress (0-100). When omitted, derived from requirements completion. */
+    overallProgress?: number;
+    /** Called when a requirement item is clicked */
+    onRequirementClick?: (uid: string) => void;
+    /** Called when the certificate is first displayed. @default undefined */
+    onComplete?: () => void;
+    /** When true, disables interactions for preview/demo mode. @default false */
+    readOnly?: boolean;
+    /** CSS class name for the root element */
+    className?: string;
+    /** Inline styles for the root element */
+    style?: React.CSSProperties;
+}

package/dist/modules/CourseCatalogModule/CourseCatalogModule.d.ts

@@ -0,0 +1,5 @@
+import { CourseCatalogModuleProps } from './types';
+export declare const CourseCatalogModule: {
+    (props: CourseCatalogModuleProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/modules/CourseCatalogModule/types.d.ts

@@ -0,0 +1,43 @@
+import { CourseInfo } from '../../sections/CourseCatalog/types';
+import { EnrollmentCourse, Prerequisite } from '../../sections/EnrollmentWizard/types';
+/**
+ * CourseCatalogModule — a browse-and-enroll course catalog module.
+ *
+ * Master-detail layout: CourseCatalog (browse) ↔ EnrollmentWizard (enroll).
+ * Clicking a course drills into the enrollment flow; a back button returns to browsing.
+ *
+ * @example
+ * <CourseCatalogModule
+ *   title="Course Catalog"
+ *   courses={courses}
+ *   categories={categories}
+ *   enrollmentData={enrollmentData}
+ *   onEnroll={(courseUid) => handleEnroll(courseUid)}
+ * />
+ */
+export interface CourseCatalogModuleProps {
+    /** Catalog title */
+    title?: string;
+    /** Courses to display */
+    courses: CourseInfo[];
+    /** Optional categories for filtering */
+    categories?: {
+        uid: string;
+        label: string;
+    }[];
+    /** Enrollment data keyed by course UID — provides course details and prerequisites for the enrollment wizard */
+    enrollmentData?: Record<string, {
+        course: EnrollmentCourse;
+        prerequisites?: Prerequisite[];
+    }>;
+    /** Called when a user confirms enrollment */
+    onEnroll: (courseUid: string) => void;
+    /** Called when a course is opened (for lazy-loading enrollment data) */
+    onCourseOpen?: (courseUid: string) => void;
+    /** When true, disables interactions for preview/demo mode. @default false */
+    readOnly?: boolean;
+    /** CSS class name for the root element */
+    className?: string;
+    /** Inline styles for the root element */
+    style?: React.CSSProperties;
+}

package/dist/modules/CoursePlayer/CoursePlayer.d.ts

@@ -1,2 +1,5 @@
 import { CoursePlayerProps } from './types';
-export declare function CoursePlayer({ courseTitle, curriculum, progress, items, initialItemUid, onItemComplete, onItemChange, sidebarCollapsed, readOnly, className, style, }: CoursePlayerProps): import("react/jsx-runtime").JSX.Element;
+export declare const CoursePlayer: {
+    (props: CoursePlayerProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/modules/DiscussionModule/DiscussionModule.d.ts

@@ -0,0 +1,5 @@
+import { DiscussionModuleProps } from './types';
+export declare const DiscussionModule: {
+    (props: DiscussionModuleProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/modules/DiscussionModule/types.d.ts

@@ -0,0 +1,47 @@
+import { DiscussionUser, DiscussionPost } from '../../sections/DiscussionThread/types';
+import { ForumTopic } from '../../sections/ForumBoard/types';
+/**
+ * DiscussionModule — a master-detail discussion forum with topic list and thread view.
+ *
+ * Panel-based layout: ForumBoard (topic list) ↔ DiscussionThread (thread detail).
+ * Clicking a topic drills into the thread; a back button returns to the board.
+ *
+ * @example
+ * <DiscussionModule
+ *   forumTitle="Class Discussion"
+ *   topics={topics}
+ *   threads={threadData}
+ *   currentUser={user}
+ *   onCreateTopic={(title, content) => createTopic(title, content)}
+ *   onReply={(topicUid, parentUid, content) => postReply(topicUid, parentUid, content)}
+ * />
+ */
+export interface DiscussionModuleProps {
+    /** Forum title */
+    forumTitle?: string;
+    /** List of discussion topics */
+    topics: ForumTopic[];
+    /** The currently authenticated user */
+    currentUser: DiscussionUser;
+    /** Thread data keyed by topic UID */
+    threads: Record<string, {
+        rootPost: DiscussionPost;
+        replies: DiscussionPost[];
+    }>;
+    /** Called when a new topic is created */
+    onCreateTopic?: (title: string, content: string) => void;
+    /** Called when a reply is posted */
+    onReply?: (topicUid: string, parentUid: string, content: string) => void;
+    /** Called when a like is toggled */
+    onToggleLike?: (topicUid: string, postUid: string) => void;
+    /** Called when a post is marked as the answer */
+    onMarkAnswer?: (topicUid: string, postUid: string) => void;
+    /** Called when a topic is opened (for lazy loading thread data) */
+    onTopicOpen?: (topicUid: string) => void;
+    /** When true, disables all interactions */
+    readOnly?: boolean;
+    /** CSS class name for the root element */
+    className?: string;
+    /** Inline styles for the root element */
+    style?: React.CSSProperties;
+}

package/dist/modules/ExamModule/ExamModule.d.ts

@@ -0,0 +1,5 @@
+import { ExamModuleProps } from './types';
+export declare const ExamModule: {
+    (props: ExamModuleProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/modules/ExamModule/types.d.ts

@@ -0,0 +1,55 @@
+import { ReactNode } from 'react';
+import { QuestionData } from '../../questions/types';
+import { AssessmentResult } from '../_shared/types';
+/**
+ * ExamModule — a formal timed exam experience with intro, exam, and results steps.
+ *
+ * Wraps ExamSession with an intro screen showing rules/instructions and a
+ * results screen with scoring, stats, and optional answer review.
+ *
+ * @example
+ * <ExamModule
+ *   title="Midterm Exam"
+ *   instructions={<p>You have 60 minutes. No notes allowed.</p>}
+ *   questions={questions}
+ *   timeLimitSeconds={3600}
+ *   passingScore={70}
+ *   onComplete={(result) => saveResult(result)}
+ * />
+ */
+export interface ExamModuleProps {
+    /** Exam title displayed on the intro screen */
+    title: string;
+    /** Exam description displayed on the intro screen */
+    description?: string;
+    /** Exam rules/instructions rendered on the intro screen */
+    instructions?: ReactNode;
+    /** Ordered list of questions */
+    questions: QuestionData[];
+    /** Time limit in seconds (required for exams) */
+    timeLimitSeconds: number;
+    /** Passing threshold as a percentage (e.g. 70 means 70%) */
+    passingScore?: number;
+    /** Whether the user can go back to previous questions. @default true */
+    allowBackNavigation?: boolean;
+    /** Auto-submit when time runs out. @default true */
+    autoSubmitOnTimeout?: boolean;
+    /** Seconds remaining at which to show a time warning */
+    timeWarningThreshold?: number;
+    /** Whether to allow retaking the exam from the results screen. @default false */
+    allowRetake?: boolean;
+    /** Whether to show correct/incorrect answer highlighting in the review. @default true */
+    showReview?: boolean;
+    /** Called when the exam is completed (submitted) */
+    onComplete?: (result: ExamModuleResult) => void;
+    /** When true, disables interactions for preview/demo mode. @default false */
+    readOnly?: boolean;
+    /** CSS class name for the root element */
+    className?: string;
+    /** Inline styles for the root element */
+    style?: React.CSSProperties;
+}
+export interface ExamModuleResult extends AssessmentResult {
+    /** Whether the submission was triggered by timeout */
+    wasAutoSubmitted: boolean;
+}

package/dist/modules/FlashcardLab/FlashcardLab.d.ts

@@ -1,2 +1,5 @@
 import { FlashcardLabProps } from './types';
-export declare function FlashcardLab({ decks, showShuffleToggle, defaultShuffled, allowMultiSelect, onComplete, className, style, }: FlashcardLabProps): import("react/jsx-runtime").JSX.Element;
+export declare const FlashcardLab: {
+    (props: FlashcardLabProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/modules/FlashcardLab/types.d.ts

@@ -26,6 +26,8 @@ export interface FlashcardLabProps {
     allowMultiSelect?: boolean;
     /** Called when the user completes a study session */
     onComplete?: (result: FlashcardLabResult) => void;
+    /** When true, disables interactions for preview/demo mode. @default false */
+    readOnly?: boolean;
     /** CSS class name for the root element */
     className?: string;
     /** Inline styles for the root element */

package/dist/modules/GradeCenterModule/GradeCenterModule.d.ts

@@ -0,0 +1,5 @@
+import { GradeCenterModuleProps } from './types';
+export declare const GradeCenterModule: {
+    (props: GradeCenterModuleProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/modules/GradeCenterModule/types.d.ts

@@ -0,0 +1,56 @@
+import { GradeItem, GradeCategory, OverallGrade } from '../../sections/GradebookTable/types';
+import { ModuleProgress, ActivityItem, Achievement } from '../../sections/ProgressDashboard/types';
+import { AssessmentScore } from '../../sections/AssessmentReview/types';
+import { QuestionData, SessionAnswer } from '../../questions/types';
+/**
+ * GradeCenterModule — a tabbed grade center with gradebook, progress dashboard,
+ * and drill-down into individual assessment reviews.
+ *
+ * Combines GradebookTable, ProgressDashboard, and AssessmentReview sections
+ * in a master-detail layout with tab navigation.
+ *
+ * @example
+ * <GradeCenterModule
+ *   courseTitle="React Fundamentals"
+ *   gradeItems={items}
+ *   overallGrade={overallGrade}
+ *   progressData={{ overallProgress: 75, totalTimeSpent: 45000, modules: [] }}
+ *   reviewData={{ quiz1: { questions, sessionAnswers, score } }}
+ * />
+ */
+export interface GradeCenterModuleProps {
+    /** Course title shown in the header */
+    courseTitle?: string;
+    /** Grade items (assignments, quizzes, etc.) */
+    gradeItems: GradeItem[];
+    /** Optional category grouping */
+    categories?: GradeCategory[];
+    /** Overall course grade summary */
+    overallGrade?: OverallGrade;
+    /** Whether to show the weight column in the gradebook */
+    showWeights?: boolean;
+    /** Data for the progress tab — tab is hidden if not provided */
+    progressData?: {
+        overallProgress: number;
+        totalTimeSpent: number;
+        modules: ModuleProgress[];
+        recentActivity?: ActivityItem[];
+        streak?: {
+            currentDays: number;
+            longestDays: number;
+        };
+        achievements?: Achievement[];
+    };
+    /** Review data keyed by grade item UID — enables drill-down on click */
+    reviewData?: Record<string, {
+        questions: QuestionData[];
+        sessionAnswers: SessionAnswer[];
+        score?: AssessmentScore;
+    }>;
+    /** When true, disables interactions for preview/demo mode. @default false */
+    readOnly?: boolean;
+    /** CSS class name for the root element */
+    className?: string;
+    /** Inline styles for the root element */
+    style?: React.CSSProperties;
+}

package/dist/modules/QuizModule/QuizModule.d.ts

@@ -1,2 +1,5 @@
 import { QuizModuleProps } from './types';
-export declare function QuizModule({ title, description, questions, timeLimitSeconds, passingScore, allowRetake, onComplete, showReview, className, style, }: QuizModuleProps): import("react/jsx-runtime").JSX.Element;
+export declare const QuizModule: {
+    (props: QuizModuleProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/modules/QuizModule/types.d.ts

@@ -1,4 +1,5 @@
-import { QuestionData, SessionAnswer } from '../../questions/types';
+import { QuestionData, QuestionMaterial } from '../../questions/types';
+import { AssessmentResult } from '../_shared/types';
 /**
  * QuizModule — a complete multi-step assessment experience.
  *
@@ -33,22 +34,17 @@ export interface QuizModuleProps {
     onComplete?: (result: QuizModuleResult) => void;
     /** Whether to show correct/incorrect answer highlighting in the review. @default true */
     showReview?: boolean;
+    /**
+     * Related materials keyed by question UID. When provided, a "Materials"
+     * button appears in the question header, opening a drawer with content blocks.
+     */
+    questionMaterials?: QuestionMaterial[];
+    /** When true, disables interactions for preview/demo mode. @default false */
+    readOnly?: boolean;
     /** CSS class name for the root element */
     className?: string;
     /** Inline styles for the root element */
     style?: React.CSSProperties;
 }
-export interface QuizModuleResult {
-    /** The user's submitted answers */
-    answers: SessionAnswer[];
-    /** Number of correct answers */
-    correct: number;
-    /** Total number of questions */
-    total: number;
-    /** Score as a percentage (0-100) */
-    percentage: number;
-    /** Whether the user passed (only meaningful when passingScore is set) */
-    passed: boolean;
-    /** Total time taken in seconds */
-    timeElapsedSeconds: number;
+export interface QuizModuleResult extends AssessmentResult {
 }

package/dist/modules/StudentDashboardModule/StudentDashboardModule.d.ts

@@ -0,0 +1,5 @@
+import { StudentDashboardModuleProps } from './types';
+export declare const StudentDashboardModule: {
+    (props: StudentDashboardModuleProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/modules/StudentDashboardModule/types.d.ts

@@ -0,0 +1,54 @@
+import { CourseInfo } from '../../sections/CourseCatalog/types';
+import { Announcement } from '../../sections/AnnouncementFeed/types';
+import { ModuleProgress, ActivityItem, Achievement } from '../../sections/ProgressDashboard/types';
+/**
+ * StudentDashboardModule — a multi-tab student home page.
+ *
+ * Combines ProgressDashboard, CourseCatalog, and AnnouncementFeed in a tabbed layout
+ * to provide a complete student landing page experience.
+ *
+ * @example
+ * <StudentDashboardModule
+ *   studentName="Jane"
+ *   overallProgress={72}
+ *   totalTimeSpent={14400}
+ *   modules={[]}
+ *   enrolledCourses={courses}
+ *   onCourseClick={(uid) => navigate(`/courses/${uid}`)}
+ * />
+ */
+export interface StudentDashboardModuleProps {
+    /** Student's display name */
+    studentName: string;
+    /** Overall progress percentage (0-100) */
+    overallProgress: number;
+    /** Total time spent in seconds */
+    totalTimeSpent: number;
+    /** Per-module progress data */
+    modules: ModuleProgress[];
+    /** Recent activity items */
+    recentActivity?: ActivityItem[];
+    /** Streak data */
+    streak?: {
+        currentDays: number;
+        longestDays: number;
+    };
+    /** Achievements */
+    achievements?: Achievement[];
+    /** Enrolled courses for the courses tab */
+    enrolledCourses: CourseInfo[];
+    /** Called when a course is clicked */
+    onCourseClick: (courseUid: string) => void;
+    /** Announcements for the announcements tab */
+    announcements?: Announcement[];
+    /** Called when an announcement is selected */
+    onAnnouncementSelect?: (announcement: Announcement) => void;
+    /** Called when an announcement is marked as read */
+    onMarkRead?: (uid: string) => void;
+    /** When true, disables interactions for preview/demo mode. @default false */
+    readOnly?: boolean;
+    /** CSS class name for the root element */
+    className?: string;
+    /** Inline styles for the root element */
+    style?: React.CSSProperties;
+}

package/dist/modules/StudentProfileModule/StudentProfileModule.d.ts

@@ -0,0 +1,5 @@
+import { StudentProfileModuleProps } from './types';
+export declare const StudentProfileModule: {
+    (props: StudentProfileModuleProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/modules/StudentProfileModule/types.d.ts

@@ -0,0 +1,43 @@
+import { StudentInfo, EnrolledCourse, ProfileAchievement, ProfileCertificate } from '../../sections/StudentProfile/types';
+import { CertificateViewerProps } from '../../sections/CertificateViewer/types';
+/**
+ * StudentProfileModule — a tabbed student profile page with certificate drill-down.
+ *
+ * Combines StudentProfile, course list, achievements, and CertificateViewer
+ * in a tabbed layout with drill-down into individual certificates.
+ *
+ * @example
+ * <StudentProfileModule
+ *   student={{ uid: "s1", displayName: "Jane Doe" }}
+ *   enrolledCourses={courses}
+ *   achievements={badges}
+ *   certificates={certs}
+ *   certificateData={{ cert1: { recipientName: "Jane", courseTitle: "React 101", completionDate: "2025-01-01", organizationName: "Hydra Academy" } }}
+ * />
+ */
+export interface StudentProfileModuleProps {
+    /** Student information */
+    student: StudentInfo;
+    /** Enrolled courses */
+    enrolledCourses?: EnrolledCourse[];
+    /** Earned achievements */
+    achievements?: ProfileAchievement[];
+    /** Earned certificates */
+    certificates?: ProfileCertificate[];
+    /** Custom stat cards */
+    stats?: {
+        label: string;
+        value: string;
+        icon?: React.ReactNode;
+    }[];
+    /** Called when a course is clicked */
+    onCourseClick?: (courseUid: string) => void;
+    /** Certificate data keyed by certificate UID — enables drill-down on click */
+    certificateData?: Record<string, CertificateViewerProps>;
+    /** When true, disables interactions for preview/demo mode. @default false */
+    readOnly?: boolean;
+    /** CSS class name for the root element */
+    className?: string;
+    /** Inline styles for the root element */
+    style?: React.CSSProperties;
+}

package/dist/modules/SurveyModule/SurveyModule.d.ts

@@ -0,0 +1,5 @@
+import { SurveyModuleProps } from './types';
+export declare const SurveyModule: {
+    (props: SurveyModuleProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};