@speakableio/core 1.0.20 → 1.0.22

package/dist/index.native.d.ts

@@ -1,5 +1,9 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React from 'react';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { QueryClient } from '@tanstack/react-query';
 import { FirebaseFirestoreTypes, Timestamp } from '@react-native-firebase/firestore';
-import { Firestore, getDoc, getDocs, addDoc, setDoc, updateDoc, deleteDoc, runTransaction, writeBatch, doc, collection, query, serverTimestamp, orderBy, limit, startAt, startAfter, endAt, endBefore, where, increment, Timestamp as Timestamp$1 } from 'firebase/firestore';
+import { Firestore, getDoc, getDocs, addDoc, setDoc, updateDoc, deleteDoc, runTransaction, writeBatch, doc, collection, query, serverTimestamp, orderBy, limit, startAt, startAfter, endAt, endBefore, where, increment, Timestamp as Timestamp$1, FieldValue } from 'firebase/firestore';
 
 type FirebaseInstance = FirebaseFirestoreTypes.Module | Firestore;
 interface FirestoreHelpers {
@@ -27,6 +31,45 @@ interface FirestoreHelpers {
 type CustomTimestamp = Timestamp | Timestamp$1;
 type CallableFunction<T = any, R = any> = (data: T) => Promise<R>;
 
+declare enum FeedbackTypesCard {
+    SuggestedResponse = "suggested_response",
+    Wida = "wida",
+    GrammarInsights = "grammar_insights",
+    Actfl = "actfl",
+    ProficiencyLevel = "proficiency_level"
+}
+declare enum LeniencyCard {
+    CONFIDENCE = "confidence",
+    EASY = "easy",
+    NORMAL = "normal",
+    HARD = "hard"
+}
+declare const LENIENCY_OPTIONS: {
+    label: string;
+    value: LeniencyCard;
+}[];
+declare const STUDENT_LEVELS_OPTIONS: {
+    label: string;
+    description: string;
+    value: string;
+}[];
+declare const BASE_RESPOND_FIELD_VALUES: {
+    title: string;
+    allowRetries: boolean;
+    respondTime: number;
+    maxCharacters: number;
+};
+declare const BASE_REPEAT_FIELD_VALUES: {
+    repeat: number;
+};
+declare const BASE_MULTIPLE_CHOICE_FIELD_VALUES: {
+    MCQType: string;
+    answer: string[];
+    choices: {
+        option: string;
+        value: string;
+    }[];
+};
 declare enum VerificationCardStatus {
     VERIFIED = "VERIFIED",
     WARNING = "WARNING",
@@ -34,7 +77,16 @@ declare enum VerificationCardStatus {
     NOT_WORKING = "NOT_WORKING",
     NOT_CHECKED = "NOT_CHECKED"
 }
+declare const CARDS_COLLECTION = "flashcards";
+type RefsCardsFiresotre = `${typeof CARDS_COLLECTION}/${string}`;
+declare const refsCardsFiresotre: {
+    allCards: string;
+    card: (id: string) => `flashcards/${string}`;
+};
 
+interface PageActivityWithId extends PageActivity {
+    id: string;
+}
 interface PageActivity {
     owners: string[];
     checked?: boolean;
@@ -112,6 +164,428 @@ declare const enum ActivityPageType {
     MEDIA_PAGE = "MEDIA_PAGE",
     SHORT_ANSWER = "SHORT_ANSWER"
 }
+declare const RESPOND_PAGE_ACTIVITY_TYPES: ActivityPageType[];
+declare const MULTIPLE_CHOICE_PAGE_ACTIVITY_TYPES: ActivityPageType[];
+declare const REPEAT_PAGE_ACTIVITY_TYPES: ActivityPageType[];
+declare const RESPOND_WRITE_PAGE_ACTIVITY_TYPES: ActivityPageType[];
+declare const RESPOND_AUDIO_PAGE_ACTIVITY_TYPES: ActivityPageType[];
+
+declare const cardsQueryKeys: {
+    all: string[];
+    one: (params: {
+        cardId: string;
+    }) => string[];
+};
+declare function useCards({ cardIds, enabled, asObject, }: {
+    cardIds: string[];
+    enabled: boolean;
+    asObject?: boolean;
+}): {
+    cards: PageActivityWithId[];
+    cardsObject: Record<string, PageActivityWithId> | null;
+    cardsQueries: _tanstack_react_query.UseQueryResult<{
+        type: ActivityPageType;
+        id: string;
+        owners: string[];
+        checked?: boolean;
+        completed?: boolean;
+        media_area_id?: string | null;
+        media_area_layout?: "left" | "right" | null;
+        score?: number;
+        verificationStatus?: VerificationCardStatus;
+        native_text?: string;
+        repeat?: number;
+        language?: string | null;
+        image?: {
+            path?: string | null;
+            url?: string;
+        };
+        audio?: {
+            path?: string | null;
+            url?: string;
+        } | null;
+        notes?: string;
+        difficulty?: string;
+        default_language?: string;
+        target_text?: string;
+        grading_criteria?: string;
+        scoring_type?: string;
+        grading_method?: "simple" | "rubric" | "manual" | "standards_based";
+        feedback_types?: string[];
+        rubricId?: string;
+        prompt?: string;
+        title?: string;
+        passing_score?: number;
+        maxCharacters?: number;
+        answer?: string[];
+        choices?: {
+            value: string;
+            option: string;
+        }[];
+        MCQType?: string;
+        multipleAttemptsAllowed?: boolean;
+        allowRetries?: boolean;
+        question?: string;
+        respondTime?: number;
+        hidePrompt?: boolean;
+        videoUrl?: string;
+        link?: string;
+        text?: string;
+        isListenAloud?: boolean;
+        embedCode?: string;
+        attempt?: number;
+        correct?: number;
+        autoGrade?: boolean;
+        points?: number;
+        shuffle?: boolean;
+        translation?: string;
+        includeAIContext?: boolean;
+        media_area_context_ref?: string | null;
+        standardId?: string;
+        target_proficiency_level?: string;
+        allowTTS?: boolean;
+        feedback_language?: string | null;
+        correct_answer?: string | null;
+        limit_attempts?: boolean;
+        max_attempts?: number;
+        rich_text?: string;
+    } | null, Error>[];
+};
+declare function useCreateCard(): {
+    mutationCreateCard: _tanstack_react_query.UseMutationResult<{
+        id: string;
+    } & Partial<PageActivity>, Error, {
+        data: Partial<PageActivity>;
+    }, unknown>;
+};
+declare function useCreateCards(): {
+    mutationCreateCards: _tanstack_react_query.UseMutationResult<{
+        id: string;
+        owners: string[];
+        checked?: boolean;
+        completed?: boolean;
+        media_area_id?: string | null;
+        media_area_layout?: "left" | "right" | null;
+        score?: number;
+        verificationStatus?: VerificationCardStatus;
+        native_text?: string;
+        repeat?: number;
+        language?: string | null;
+        image?: {
+            path?: string | null;
+            url?: string;
+        };
+        audio?: {
+            path?: string | null;
+            url?: string;
+        } | null;
+        notes?: string;
+        difficulty?: string;
+        default_language?: string;
+        target_text?: string;
+        type: ActivityPageType;
+        grading_criteria?: string;
+        scoring_type?: string;
+        grading_method?: "simple" | "rubric" | "manual" | "standards_based";
+        feedback_types?: string[];
+        rubricId?: string;
+        prompt?: string;
+        title?: string;
+        passing_score?: number;
+        maxCharacters?: number;
+        answer?: string[];
+        choices?: {
+            value: string;
+            option: string;
+        }[];
+        MCQType?: string;
+        multipleAttemptsAllowed?: boolean;
+        allowRetries?: boolean;
+        question?: string;
+        respondTime?: number;
+        hidePrompt?: boolean;
+        videoUrl?: string;
+        link?: string;
+        text?: string;
+        isListenAloud?: boolean;
+        embedCode?: string;
+        attempt?: number;
+        correct?: number;
+        autoGrade?: boolean;
+        points?: number;
+        shuffle?: boolean;
+        translation?: string;
+        includeAIContext?: boolean;
+        media_area_context_ref?: string | null;
+        standardId?: string;
+        target_proficiency_level?: string;
+        allowTTS?: boolean;
+        feedback_language?: string | null;
+        correct_answer?: string | null;
+        limit_attempts?: boolean;
+        max_attempts?: number;
+        rich_text?: string;
+    }[], Error, {
+        cards: PageActivity[];
+    }, unknown>;
+};
+declare function getCardFromCache({ cardId, queryClient, }: {
+    cardId: string;
+    queryClient: QueryClient;
+}): PageActivityWithId | undefined;
+declare function updateCardInCache({ cardId, card, queryClient, }: {
+    cardId: string;
+    card: PageActivityWithId | null;
+    queryClient: QueryClient;
+}): void;
+declare function useGetCard({ cardId, enabled }: {
+    cardId: string;
+    enabled?: boolean;
+}): _tanstack_react_query.UseQueryResult<{
+    type: ActivityPageType;
+    id: string;
+    owners: string[];
+    checked?: boolean;
+    completed?: boolean;
+    media_area_id?: string | null;
+    media_area_layout?: "left" | "right" | null;
+    score?: number;
+    verificationStatus?: VerificationCardStatus;
+    native_text?: string;
+    repeat?: number;
+    language?: string | null;
+    image?: {
+        path?: string | null;
+        url?: string;
+    };
+    audio?: {
+        path?: string | null;
+        url?: string;
+    } | null;
+    notes?: string;
+    difficulty?: string;
+    default_language?: string;
+    target_text?: string;
+    grading_criteria?: string;
+    scoring_type?: string;
+    grading_method?: "simple" | "rubric" | "manual" | "standards_based";
+    feedback_types?: string[];
+    rubricId?: string;
+    prompt?: string;
+    title?: string;
+    passing_score?: number;
+    maxCharacters?: number;
+    answer?: string[];
+    choices?: {
+        value: string;
+        option: string;
+    }[];
+    MCQType?: string;
+    multipleAttemptsAllowed?: boolean;
+    allowRetries?: boolean;
+    question?: string;
+    respondTime?: number;
+    hidePrompt?: boolean;
+    videoUrl?: string;
+    link?: string;
+    text?: string;
+    isListenAloud?: boolean;
+    embedCode?: string;
+    attempt?: number;
+    correct?: number;
+    autoGrade?: boolean;
+    points?: number;
+    shuffle?: boolean;
+    translation?: string;
+    includeAIContext?: boolean;
+    media_area_context_ref?: string | null;
+    standardId?: string;
+    target_proficiency_level?: string;
+    allowTTS?: boolean;
+    feedback_language?: string | null;
+    correct_answer?: string | null;
+    limit_attempts?: boolean;
+    max_attempts?: number;
+    rich_text?: string;
+} | null, Error>;
+
+declare const createCardRepo: () => {
+    createCard: (args_0: {
+        data: Partial<PageActivity>;
+    }) => Promise<{
+        id: string;
+    } & Partial<PageActivity>>;
+    createCards: (args_0: {
+        cards: PageActivity[];
+    }) => Promise<{
+        id: string;
+        owners: string[];
+        checked?: boolean;
+        completed?: boolean;
+        media_area_id?: string | null;
+        media_area_layout?: "left" | "right" | null;
+        score?: number;
+        verificationStatus?: VerificationCardStatus;
+        native_text?: string;
+        repeat?: number;
+        language?: string | null;
+        image?: {
+            path?: string | null;
+            url?: string;
+        };
+        audio?: {
+            path?: string | null;
+            url?: string;
+        } | null;
+        notes?: string;
+        difficulty?: string;
+        default_language?: string;
+        target_text?: string;
+        type: ActivityPageType;
+        grading_criteria?: string;
+        scoring_type?: string;
+        grading_method?: "simple" | "rubric" | "manual" | "standards_based";
+        feedback_types?: string[];
+        rubricId?: string;
+        prompt?: string;
+        title?: string;
+        passing_score?: number;
+        maxCharacters?: number;
+        answer?: string[];
+        choices?: {
+            value: string;
+            option: string;
+        }[];
+        MCQType?: string;
+        multipleAttemptsAllowed?: boolean;
+        allowRetries?: boolean;
+        question?: string;
+        respondTime?: number;
+        hidePrompt?: boolean;
+        videoUrl?: string;
+        link?: string;
+        text?: string;
+        isListenAloud?: boolean;
+        embedCode?: string;
+        attempt?: number;
+        correct?: number;
+        autoGrade?: boolean;
+        points?: number;
+        shuffle?: boolean;
+        translation?: string;
+        includeAIContext?: boolean;
+        media_area_context_ref?: string | null;
+        standardId?: string;
+        target_proficiency_level?: string;
+        allowTTS?: boolean;
+        feedback_language?: string | null;
+        correct_answer?: string | null;
+        limit_attempts?: boolean;
+        max_attempts?: number;
+        rich_text?: string;
+    }[]>;
+    getCard: (params: {
+        cardId: string;
+    }) => Promise<{
+        type: ActivityPageType;
+        id: string;
+        owners: string[];
+        checked?: boolean;
+        completed?: boolean;
+        media_area_id?: string | null;
+        media_area_layout?: "left" | "right" | null;
+        score?: number;
+        verificationStatus?: VerificationCardStatus;
+        native_text?: string;
+        repeat?: number;
+        language?: string | null;
+        image?: {
+            path?: string | null;
+            url?: string;
+        };
+        audio?: {
+            path?: string | null;
+            url?: string;
+        } | null;
+        notes?: string;
+        difficulty?: string;
+        default_language?: string;
+        target_text?: string;
+        grading_criteria?: string;
+        scoring_type?: string;
+        grading_method?: "simple" | "rubric" | "manual" | "standards_based";
+        feedback_types?: string[];
+        rubricId?: string;
+        prompt?: string;
+        title?: string;
+        passing_score?: number;
+        maxCharacters?: number;
+        answer?: string[];
+        choices?: {
+            value: string;
+            option: string;
+        }[];
+        MCQType?: string;
+        multipleAttemptsAllowed?: boolean;
+        allowRetries?: boolean;
+        question?: string;
+        respondTime?: number;
+        hidePrompt?: boolean;
+        videoUrl?: string;
+        link?: string;
+        text?: string;
+        isListenAloud?: boolean;
+        embedCode?: string;
+        attempt?: number;
+        correct?: number;
+        autoGrade?: boolean;
+        points?: number;
+        shuffle?: boolean;
+        translation?: string;
+        includeAIContext?: boolean;
+        media_area_context_ref?: string | null;
+        standardId?: string;
+        target_proficiency_level?: string;
+        allowTTS?: boolean;
+        feedback_language?: string | null;
+        correct_answer?: string | null;
+        limit_attempts?: boolean;
+        max_attempts?: number;
+        rich_text?: string;
+    } | null>;
+};
+
+declare function checkIsRepeatPage(cardType: ActivityPageType | undefined): boolean;
+declare function checkIsMCPage(cardType: ActivityPageType | undefined): boolean;
+declare function checkIsRespondPage(cardType: ActivityPageType | undefined): boolean;
+declare function checkIsRespondWrittenPage(cardType: ActivityPageType | undefined): boolean;
+declare function checkIsRespondAudioPage(cardType: ActivityPageType | undefined): boolean;
+declare const checkIsMediaPage: (cardType: ActivityPageType | undefined) => boolean;
+declare const checkIsShortAnswerPage: (cardType: ActivityPageType | undefined) => boolean;
+declare const checkTypePageActivity: (cardType: ActivityPageType | undefined) => {
+    isRespondAudio: boolean;
+    isRespondWritten: boolean;
+    isRespond: boolean;
+    isMC: boolean;
+    isRepeat: boolean;
+    isMediaPage: boolean;
+    isShortAnswer: boolean;
+    hasSomeType: boolean;
+};
+
+declare function getPagePrompt(card: PageActivityWithId | undefined): {
+    has: boolean;
+    text: string;
+    rich_text: string;
+    isTextEqualToRichText: boolean;
+};
+
+declare const getTotalCompletedCards: (pageScores: Score["cards"] | undefined) => number;
+
+declare const getLabelPage: (pageType: ActivityPageType | undefined) => {
+    short: string;
+    long: string;
+};
 
 interface Assignment {
     name: string;
@@ -159,11 +633,151 @@ interface Assignment {
     chat_experience?: boolean;
     showScores?: boolean;
 }
+type AssignmentAnalyticsType$1 = 'macro' | 'gradebook' | 'cards' | 'student' | 'student_summary';
 interface AssignmentWithId extends Assignment {
     id: string;
     isAvailable: boolean;
     scores?: unknown;
 }
+interface Score {
+    userId: string;
+    owners: string[];
+    progress: number;
+    score: number;
+    cards?: {
+        [cardId: string]: PageScore;
+    };
+    courseId?: string;
+    firstLoad?: boolean;
+    googleClassroomUserId?: string;
+    skippedCards?: number;
+    lastPlayed?: CustomTimestamp;
+    startDate?: CustomTimestamp;
+    submissionDate?: CustomTimestamp;
+    status?: 'SUBMITTED' | 'PENDING_REVIEW' | 'IN_PROGRESS' | 'FINALIZED';
+    submitted?: boolean;
+    successfulCards?: number;
+    total_voiceSuccess?: number;
+    total_voice_attempts?: number;
+    total_words_spoken?: number;
+    history?: PageScore[];
+    attempts?: number;
+    assignmentId?: string;
+    setId?: string;
+    score_is_overridden?: boolean;
+    reviewed?: boolean;
+    triage?: {
+        version?: string;
+        improvements?: string[];
+        reasons?: string[];
+        updatedAt?: CustomTimestamp;
+        confidence?: number;
+        category?: 'excellent' | 'doing_ok' | 'needs_attention' | 'unknown';
+        by?: string;
+        summary?: string;
+        strengths?: string[];
+    };
+}
+interface ScoreWithId extends Score {
+    id: string;
+}
+interface PageScore {
+    voiceSuccess?: number;
+    voiceAttempts?: number;
+    voiceFail?: number;
+    completed?: boolean;
+    attempts?: number;
+    correct?: number;
+    success?: boolean;
+    aiSuccess?: boolean;
+    grading_method?: 'simple' | 'rubric' | 'manual' | 'standards_based' | null;
+    grammar_insights?: {
+        type?: string;
+        justification?: string;
+        error?: boolean;
+        correction?: string;
+    }[];
+    promptSuccess?: boolean;
+    score?: number;
+    simple_grading?: {
+        justification?: string;
+        success?: boolean;
+    };
+    suggested_response?: string;
+    summary?: string;
+    transcript?: string | null;
+    errors?: any;
+    improvedResponse?: string;
+    audio?: string | null;
+    actfl?: {
+        justification: string;
+        level: string;
+        key_indicators?: string[];
+    };
+    wida?: {
+        justification: string;
+        level: string;
+        key_indicators?: string[];
+    };
+    earned_points?: number;
+    fileName?: string | null;
+    max_points?: number;
+    passing_score?: number;
+    rubric?: {
+        description: string;
+        justification: string;
+        maxPoints: number;
+        score: number;
+        score_title: string;
+        title: string;
+    }[] | null;
+    scoring_type?: string;
+    history?: PageScore[];
+    media_area_opened?: boolean;
+    noFeedbackAvailable?: boolean;
+    proficiency_level?: {
+        standardId: string;
+        level: string;
+        justification: string;
+        key_indicators?: string[];
+    };
+    status?: string | null;
+    transcriptError?: boolean;
+    feedbackError?: boolean;
+    totalTrys?: {
+        markedCorrect?: boolean;
+        selectedOption?: string | string[];
+        attemptedAt?: CustomTimestamp;
+        messageAttemptId?: string;
+    }[];
+    tryAgain?: boolean;
+    updatedAt?: CustomTimestamp;
+    messageAttemptId?: string;
+    unmetCriteria?: {
+        criterion: string;
+        suggestion: string;
+        explanation: string;
+    }[];
+    meetsCriteria?: boolean;
+    actionableSteps?: string[];
+    rubric_results?: {
+        title: string;
+        score: number;
+        score_title: string;
+        justification: string;
+        maxPoints: number;
+        description: string;
+    }[];
+    target_proficiency_level?: string;
+    hint?: string[];
+    reviewed?: boolean;
+    error?: ('feedback_error' | 'transcript_error' | 'summary_error' | 'audio_upload_error' | 'unknown' | null)[];
+    stagedResponse?: {
+        audio?: string | null;
+        fileName?: string | null;
+        transcript?: string | null;
+    } | null;
+}
 
 declare enum AssignmentAnalyticsType {
     Macro = "macro",
@@ -174,6 +788,397 @@ declare enum AssignmentAnalyticsType {
     All = "all"
 }
 
+declare const createAssignmentRepo: () => {
+    getAssignment: (params: {
+        assignmentId: string;
+        currentUserId: string;
+        analyticType?: AssignmentAnalyticsType;
+        studentId?: string;
+    }) => Promise<AssignmentWithId | {
+        scores: any;
+        id: string;
+        isAvailable: boolean;
+        name: string;
+        description: string;
+        scheduledTime?: string | null;
+        dueTime?: {
+            hours: number;
+            minutes: number;
+            nanos: number;
+        };
+        speakableio: boolean;
+        owners: string[];
+        image: {
+            path: string | null;
+            url: string;
+        };
+        dueDate: {
+            day: number;
+            month: number;
+            year: number;
+        };
+        teacherName: string;
+        courseWorkId: string | null;
+        dueDateTimestamp: CustomTimestamp;
+        scheduledTimeTimestamp: number;
+        active: boolean;
+        voice: string | null;
+        setId: string;
+        dateMade: {
+            seconds: number;
+            nanoseconds: number;
+        };
+        maxPoints: number;
+        courseId: string;
+        isAssessment: boolean;
+        ltiDeeplink?: string;
+        content?: string[];
+        weights?: Record<string, number>;
+        language?: string;
+        types?: { [key in ActivityPageType]?: number; };
+        aiEnabled?: boolean;
+        chat_experience?: boolean;
+        showScores?: boolean;
+    } | null>;
+    attachScoresAssignment: (args_0: {
+        assignments: AssignmentWithId[];
+        analyticType: AssignmentAnalyticsType;
+        studentId?: string;
+        currentUserId: string;
+    }) => Promise<{
+        scores: any;
+        id: string;
+        isAvailable: boolean;
+        name: string;
+        description: string;
+        scheduledTime?: string | null;
+        dueTime?: {
+            hours: number;
+            minutes: number;
+            nanos: number;
+        };
+        speakableio: boolean;
+        owners: string[];
+        image: {
+            path: string | null;
+            url: string;
+        };
+        dueDate: {
+            day: number;
+            month: number;
+            year: number;
+        };
+        teacherName: string;
+        courseWorkId: string | null;
+        dueDateTimestamp: CustomTimestamp;
+        scheduledTimeTimestamp: number;
+        active: boolean;
+        voice: string | null;
+        setId: string;
+        dateMade: {
+            seconds: number;
+            nanoseconds: number;
+        };
+        maxPoints: number;
+        courseId: string;
+        isAssessment: boolean;
+        ltiDeeplink?: string;
+        content?: string[];
+        weights?: Record<string, number>;
+        language?: string;
+        types?: { [key in ActivityPageType]?: number; };
+        aiEnabled?: boolean;
+        chat_experience?: boolean;
+        showScores?: boolean;
+    }[]>;
+    getAssignmentScores: (args_0: {
+        assignmentId: string;
+        currentUserId: string;
+        analyticType?: AssignmentAnalyticsType;
+        studentId?: string;
+    }) => Promise<{
+        scores: unknown;
+        id: string;
+    } | undefined>;
+    getAllAssignments: () => Promise<(AssignmentWithId & {
+        id: string;
+    })[]>;
+};
+
+declare const assignmentQueryKeys: {
+    all: readonly ["assignments"];
+    byId: (id: string) => readonly ["assignments", string];
+    list: () => readonly ["assignments", "list"];
+};
+declare function useAssignment({ assignmentId, enabled, analyticType, userId, }: {
+    assignmentId: string;
+    enabled?: boolean;
+    analyticType?: AssignmentAnalyticsType;
+    userId: string;
+}): _tanstack_react_query.UseQueryResult<AssignmentWithId | {
+    scores: any;
+    id: string;
+    isAvailable: boolean;
+    name: string;
+    description: string;
+    scheduledTime?: string | null;
+    dueTime?: {
+        hours: number;
+        minutes: number;
+        nanos: number;
+    };
+    speakableio: boolean;
+    owners: string[];
+    image: {
+        path: string | null;
+        url: string;
+    };
+    dueDate: {
+        day: number;
+        month: number;
+        year: number;
+    };
+    teacherName: string;
+    courseWorkId: string | null;
+    dueDateTimestamp: CustomTimestamp;
+    scheduledTimeTimestamp: number;
+    active: boolean;
+    voice: string | null;
+    setId: string;
+    dateMade: {
+        seconds: number;
+        nanoseconds: number;
+    };
+    maxPoints: number;
+    courseId: string;
+    isAssessment: boolean;
+    ltiDeeplink?: string;
+    content?: string[];
+    weights?: Record<string, number>;
+    language?: string;
+    types?: { [key in ActivityPageType]?: number; };
+    aiEnabled?: boolean;
+    chat_experience?: boolean;
+    showScores?: boolean;
+} | null, Error>;
+
+declare const scoreQueryKeys: {
+    all: readonly ["scores"];
+    byId: (id: string) => readonly ["scores", string];
+    list: () => readonly ["scores", "list"];
+};
+declare function useScore({ isAssignment, activityId, userId, courseId, enabled, googleClassroomUserId, }: {
+    userId: string;
+    isAssignment: boolean;
+    activityId: string;
+    courseId?: string;
+    enabled?: boolean;
+    googleClassroomUserId?: string;
+}): _tanstack_react_query.UseQueryResult<ScoreWithId, Error>;
+declare function useUpdateScore(): {
+    mutationUpdateScore: _tanstack_react_query.UseMutationResult<Promise<void>, Error, {
+        userId: string;
+        data: Partial<Score>;
+        isAssignment: boolean;
+        activityId: string;
+    }, {
+        previousData: Partial<Score> | undefined;
+    }>;
+};
+declare function useUpdateCardScore({ isAssignment, activityId, userId, cardIds, weights, }: {
+    isAssignment: boolean;
+    userId: string;
+    activityId: string;
+    cardIds: string[];
+    weights: Record<string, number>;
+}): {
+    mutationUpdateCardScore: _tanstack_react_query.UseMutationResult<{
+        cardId: string;
+        scoresUpdated: Score;
+    }, Error, {
+        cardId: string;
+        cardScore: PageScore;
+    }, {
+        previousData: Score | undefined;
+    }>;
+};
+declare function useClearScore(): {
+    mutationClearScore: _tanstack_react_query.UseMutationResult<{
+        update: Partial<Score>;
+        activityId: string;
+    }, Error, {
+        isAssignment: boolean;
+        cardId: string;
+        cardScores: PageScore;
+        userId: string;
+        activityId: string;
+    }, unknown>;
+};
+declare function useClearScoreV2(): {
+    mutationClearScore: _tanstack_react_query.UseMutationResult<{
+        update: Partial<Score>;
+        activityId: string;
+    }, Error, {
+        isAssignment: boolean;
+        cardId: string;
+        cardScores: PageScore;
+        userId: string;
+        activityId: string;
+    }, unknown>;
+};
+declare function useSubmitAssignmentScore({ onAssignmentSubmitted, studentName, }: {
+    onAssignmentSubmitted: (assignmentId: string) => void;
+    studentName: string;
+}): {
+    submitAssignmentScore: _tanstack_react_query.UseMutateAsyncFunction<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: unknown;
+        message?: undefined;
+    }, Error, {
+        assignment: {
+            id: string;
+            name: string;
+            owners: string[];
+            courseId: string;
+            courseWorkId: string;
+            isAssessment: boolean;
+            maxPoints: number;
+        };
+        userId: string;
+        cardIds: string[];
+        weights: Record<string, number>;
+        scores: Score;
+        status: Score["status"];
+    }, unknown>;
+    isLoading: boolean;
+};
+declare function useSubmitPracticeScore(): {
+    submitPracticeScore: _tanstack_react_query.UseMutateAsyncFunction<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: unknown;
+        message?: undefined;
+    }, Error, {
+        setId: string;
+        userId: string;
+        scores: Score;
+    }, unknown>;
+    isLoading: boolean;
+};
+
+interface SetWithId extends Set {
+    id: string;
+}
+interface Set {
+    id: string;
+    language: string;
+    ownerName: string;
+    weights: Record<string, number>;
+    repeat?: number;
+    voice?: string;
+    averagePhraseLength?: number;
+    passing_score?: number;
+    organizations?: string[];
+    description: string;
+    image: {
+        url: string;
+        path: null | string;
+    };
+    additionalLanguages?: string[];
+    owners: string[];
+    name: string;
+    content: string[];
+    types: {
+        [key in ActivityPageType]?: number;
+    };
+    defaultLanguage: string;
+    createdAt: FieldValue;
+    public: boolean;
+    defaultRubricId?: string;
+    difficulty?: string;
+    end_screen?: {
+        variant: 0 | 1 | 2;
+        title: string;
+        description: string;
+    };
+    mcAllowRetries?: boolean;
+    welcome_screen?: {
+        variant: 'colored' | 'blank';
+    };
+    poorFunctionalityWarning?: boolean;
+    status?: 'draft' | 'published';
+    subjects?: any[];
+    respondAllowRetries?: boolean;
+    respondAllowTTS?: boolean;
+    feedbackLanguage?: string;
+    respondMaxCharacters?: number;
+    respondMaxTime?: number;
+}
+
+declare const setsQueryKeys: {
+    all: string[];
+    one: (params: {
+        setId: string;
+    }) => string[];
+};
+declare const useSet: ({ setId, enabled }: {
+    setId: string;
+    enabled?: boolean;
+}) => _tanstack_react_query.UseQueryResult<SetWithId | null, Error>;
+declare function getSetFromCache({ setId, queryClient, }: {
+    setId: string | undefined;
+    queryClient: QueryClient;
+}): SetWithId | null | undefined;
+declare function updateSetInCache({ set, queryClient, }: {
+    set: SetWithId;
+    queryClient: QueryClient;
+}): void;
+
+declare const SETS_COLLECTION = "sets";
+type RefsSetsFirestore = `${typeof SETS_COLLECTION}/${string}`;
+declare const refsSetsFirestore: {
+    allSets: string;
+    set: (id: string) => `sets/${string}`;
+};
+
+declare const createSetRepo: () => {
+    getSet: (args_0: {
+        setId: string;
+    }) => Promise<SetWithId | null>;
+};
+
+declare const SPEAKABLE_NOTIFICATIONS: {
+    readonly NEW_ASSIGNMENT: "new_assignment";
+    readonly ASSESSMENT_SUBMITTED: "assessment_submitted";
+    readonly ASSESSMENT_SCORED: "assessment_scored";
+    readonly NEW_COMMENT: "NEW_COMMENT";
+};
+type SpeakableNotificationType = (typeof SPEAKABLE_NOTIFICATIONS)[keyof typeof SPEAKABLE_NOTIFICATIONS];
+declare const SpeakableNotificationTypes: {
+    NEW_ASSIGNMENT: string;
+    FEEDBACK_FROM_TEACHER: string;
+    MESSAGE_FROM_STUDENT: string;
+    PHRASE_MARKED_CORRECT: string;
+    STUDENT_PROGRESS: string;
+    PLAYLIST_FOLLOWERS: string;
+    PLAYLIST_PLAYS: string;
+    ASSESSMENT_SUBMITTED: string;
+    ASSESSMENT_SCORED: string;
+    NEW_COMMENT: string;
+};
+
+declare const useCreateNotification: () => {
+    createNotification: (type: SpeakableNotificationType, data: any) => Promise<any>;
+};
+
+type FsClient = ReturnType<typeof createFsClientBase>;
 type FsClientParams = Omit<Parameters<typeof createFsClientBase>[0], 'helpers'>;
 declare function createFsClientBase({ db, helpers, httpsCallable, logEvent, }: {
     db: FirebaseInstance;
@@ -444,6 +1449,1570 @@ declare function createFsClientBase({ db, helpers, httpsCallable, logEvent, }: {
     };
 };
 
+interface UserProfile {
+    googleClassroomUserId: string;
+    image: {
+        url: string;
+        path: string;
+    };
+    displayName: string;
+    isTeacher?: boolean;
+    isStudent?: boolean;
+    roles?: string[];
+}
+interface UserAuth {
+    uid: string;
+    email: string;
+    displayName: string | null;
+}
+interface Lti {
+    data: {
+        services: {
+            serviceKey: string;
+        };
+    };
+}
+interface User {
+    profile: UserProfile;
+    auth: UserAuth;
+    lti: Lti;
+    roles: string[];
+}
+
+declare const SpeakablePlanTypes: {
+    readonly basic: "basic";
+    readonly teacher_pro: "teacher_pro";
+    readonly school_starter: "school_starter";
+    readonly organization: "organization";
+    readonly starter: "starter";
+    readonly growth: "growth";
+    readonly professional: "professional";
+};
+
+interface Permissions {
+    loaded: boolean;
+    loading: boolean;
+    permissions: string[];
+    plan: keyof typeof SpeakablePlanTypes;
+    subscriptionId: string;
+    isInstitutionPlan: boolean;
+    type: string;
+    contact: string;
+    hasStudentPortfolios?: boolean;
+    refreshDate: string;
+    isStripePlan: boolean;
+    freeOrgTrialExpired?: boolean;
+}
+
+interface FsContext {
+    speakableApi: Awaited<FsClient>;
+    queryClient: QueryClient;
+    user: User;
+    permissions: Permissions;
+}
+declare const FsCtx: React.Context<FsContext | null>;
+declare function SpeakableProvider({ user, children, queryClient, permissions, fsClient, }: {
+    children: React.ReactNode;
+    fsClient: FsClient;
+    permissions: Permissions;
+    queryClient: QueryClient;
+    user: User;
+}): react_jsx_runtime.JSX.Element | null;
+declare function useSpeakableApi(): FsContext;
+
+declare function getTranscript(model: 'gemini' | 'assemblyai', args: {
+    language: string;
+    audioUrl: string;
+    prompt?: string;
+}): Promise<string | null>;
+
+declare const getRespondCardTool: ({ language, standard, }: {
+    language: string;
+    standard: string;
+}) => {
+    tool_choice: {
+        type: string;
+        function: {
+            name: string;
+        };
+    };
+    tools: {
+        type: string;
+        function: {
+            name: string;
+            description: string;
+            parameters: {
+                type: string;
+                required: string[];
+                properties: {
+                    success: {
+                        type: string;
+                        description: string;
+                    };
+                    errors: {
+                        type: string;
+                        items: {
+                            type: string;
+                            required: string[];
+                            properties: {
+                                error: {
+                                    type: string;
+                                    description: string;
+                                };
+                                correction: {
+                                    type: string;
+                                    description: string;
+                                };
+                                justification: {
+                                    type: string;
+                                    description: string;
+                                };
+                                grammar_error_type: {
+                                    type: string;
+                                    enum: string[];
+                                    description: string;
+                                };
+                            };
+                        };
+                        description: string;
+                    };
+                    compliments: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                        description: string;
+                    };
+                    improvedResponse: {
+                        type: string;
+                        description: string;
+                    };
+                    score: {
+                        type: string;
+                        description: string;
+                    };
+                    score_justification: {
+                        type: string;
+                        description: string;
+                    };
+                };
+            };
+        };
+    }[];
+};
+
+declare function debounce<T extends (...args: any[]) => Promise<any>>(func: T, waitFor: number): (...args: Parameters<T>) => Promise<ReturnType<T>>;
+
+declare const purify: (word: string) => string;
+declare const cleanString: (words: string) => string | string[];
+declare const getWordHash: (word: string, language: string) => string;
+declare function getPhraseLength(phrase: string, input?: string): number;
+
+declare function useActivity({ id, isAssignment, onAssignmentSubmitted, ltiData, }: {
+    id: string;
+    isAssignment: boolean;
+    onAssignmentSubmitted: (assignmentId: string) => void;
+    ltiData?: {
+        lineItemId?: string;
+        lti_id?: string;
+        serviceKey?: string;
+    };
+}): {
+    set: {
+        data: SetWithId | null | undefined;
+        query: _tanstack_react_query.UseQueryResult<SetWithId | null, Error>;
+    };
+    cards: {
+        data: Record<string, PageActivityWithId> | null;
+        query: _tanstack_react_query.UseQueryResult<{
+            type: ActivityPageType;
+            id: string;
+            owners: string[];
+            checked?: boolean;
+            completed?: boolean;
+            media_area_id?: string | null;
+            media_area_layout?: "left" | "right" | null;
+            score?: number;
+            verificationStatus?: VerificationCardStatus;
+            native_text?: string;
+            repeat?: number;
+            language?: string | null;
+            image?: {
+                path?: string | null;
+                url?: string;
+            };
+            audio?: {
+                path?: string | null;
+                url?: string;
+            } | null;
+            notes?: string;
+            difficulty?: string;
+            default_language?: string;
+            target_text?: string;
+            grading_criteria?: string;
+            scoring_type?: string;
+            grading_method?: "simple" | "rubric" | "manual" | "standards_based";
+            feedback_types?: string[];
+            rubricId?: string;
+            prompt?: string;
+            title?: string;
+            passing_score?: number;
+            maxCharacters?: number;
+            answer?: string[];
+            choices?: {
+                value: string;
+                option: string;
+            }[];
+            MCQType?: string;
+            multipleAttemptsAllowed?: boolean;
+            allowRetries?: boolean;
+            question?: string;
+            respondTime?: number;
+            hidePrompt?: boolean;
+            videoUrl?: string;
+            link?: string;
+            text?: string;
+            isListenAloud?: boolean;
+            embedCode?: string;
+            attempt?: number;
+            correct?: number;
+            autoGrade?: boolean;
+            points?: number;
+            shuffle?: boolean;
+            translation?: string;
+            includeAIContext?: boolean;
+            media_area_context_ref?: string | null;
+            standardId?: string;
+            target_proficiency_level?: string;
+            allowTTS?: boolean;
+            feedback_language?: string | null;
+            correct_answer?: string | null;
+            limit_attempts?: boolean;
+            max_attempts?: number;
+            rich_text?: string;
+        } | null, Error>[];
+        cardsArray: PageActivityWithId[];
+    };
+    assignment: {
+        data: AssignmentWithId | {
+            scores: any;
+            id: string;
+            isAvailable: boolean;
+            name: string;
+            description: string;
+            scheduledTime?: string | null;
+            dueTime?: {
+                hours: number;
+                minutes: number;
+                nanos: number;
+            };
+            speakableio: boolean;
+            owners: string[];
+            image: {
+                path: string | null;
+                url: string;
+            };
+            dueDate: {
+                day: number;
+                month: number;
+                year: number;
+            };
+            teacherName: string;
+            courseWorkId: string | null;
+            dueDateTimestamp: CustomTimestamp;
+            scheduledTimeTimestamp: number;
+            active: boolean;
+            voice: string | null;
+            setId: string;
+            dateMade: {
+                seconds: number;
+                nanoseconds: number;
+            };
+            maxPoints: number;
+            courseId: string;
+            isAssessment: boolean;
+            ltiDeeplink?: string;
+            content?: string[];
+            weights?: Record<string, number>;
+            language?: string;
+            types?: { [key in ActivityPageType]?: number; };
+            aiEnabled?: boolean;
+            chat_experience?: boolean;
+            showScores?: boolean;
+        } | null | undefined;
+        query: _tanstack_react_query.UseQueryResult<AssignmentWithId | {
+            scores: any;
+            id: string;
+            isAvailable: boolean;
+            name: string;
+            description: string;
+            scheduledTime?: string | null;
+            dueTime?: {
+                hours: number;
+                minutes: number;
+                nanos: number;
+            };
+            speakableio: boolean;
+            owners: string[];
+            image: {
+                path: string | null;
+                url: string;
+            };
+            dueDate: {
+                day: number;
+                month: number;
+                year: number;
+            };
+            teacherName: string;
+            courseWorkId: string | null;
+            dueDateTimestamp: CustomTimestamp;
+            scheduledTimeTimestamp: number;
+            active: boolean;
+            voice: string | null;
+            setId: string;
+            dateMade: {
+                seconds: number;
+                nanoseconds: number;
+            };
+            maxPoints: number;
+            courseId: string;
+            isAssessment: boolean;
+            ltiDeeplink?: string;
+            content?: string[];
+            weights?: Record<string, number>;
+            language?: string;
+            types?: { [key in ActivityPageType]?: number; };
+            aiEnabled?: boolean;
+            chat_experience?: boolean;
+            showScores?: boolean;
+        } | null, Error>;
+    };
+    scores: {
+        data: ScoreWithId | undefined;
+        query: _tanstack_react_query.UseQueryResult<ScoreWithId, Error>;
+        actions: {
+            update: (data: Partial<Score>) => void;
+            clear: ({ cardId, wasCompleted, }: {
+                cardId: string;
+                wasCompleted?: boolean;
+            }) => void;
+            submit: () => Promise<{
+                success: boolean;
+                message: string;
+                error?: undefined;
+            } | {
+                success: boolean;
+                error: unknown;
+                message?: undefined;
+            }>;
+            updateCard: (cardId: string, cardScore: PageScore) => void;
+            logGradingStandardEntry: ({ cardId, gradingStandard, type, }: {
+                cardId: string;
+                gradingStandard: {
+                    level: string;
+                    justification: string;
+                };
+                type: "actfl" | "wida" | "custom";
+            }) => void;
+        };
+    };
+};
+
+interface CreditContract {
+    allocationSource: string;
+    createdAt: string;
+    creditsAllocatedThisPeriod: number;
+    effectivePlanId: string;
+    email: string;
+    isUnlimited: boolean;
+    lastUpdatedAt: string;
+    ownerType: string;
+    periodStart: string;
+    periodEnd: string;
+    planTermEndTimestamp: string | null;
+    sourceDetails: Record<string, unknown>;
+    creditsAvailable?: number;
+    topOffCreditsAvailable?: number;
+}
+declare const creditQueryKeys: {
+    userCredits: (uid: string) => readonly ["userCredits", string];
+};
+declare const useUserCredits: () => {
+    data: {
+        id: string;
+        userId: string;
+        email: string;
+        effectivePlanId: string;
+        status: string;
+        isUnlimited: boolean;
+        creditsAvailable: number;
+        creditsAllocatedThisPeriod: number;
+        topOffCreditsAvailable: number;
+        topOffCreditsTotal: number;
+        allocationSource: string;
+        sourceDetails: {};
+        periodStart: null;
+        periodEnd: null;
+        planTermEndTimestamp: null;
+        ownerType: string;
+        createdAt: string;
+        lastUpdatedAt: string;
+    } | {
+        totalCreditsAvailable: number;
+        allocationSource: string;
+        createdAt: string;
+        creditsAllocatedThisPeriod: number;
+        effectivePlanId: string;
+        email: string;
+        isUnlimited: boolean;
+        lastUpdatedAt: string;
+        ownerType: string;
+        periodStart: string;
+        periodEnd: string;
+        planTermEndTimestamp: string | null;
+        sourceDetails: Record<string, unknown>;
+        creditsAvailable?: number;
+        topOffCreditsAvailable?: number;
+        id: string;
+        userId?: undefined;
+        status?: undefined;
+        topOffCreditsTotal?: undefined;
+    };
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<{
+        id: string;
+        userId: string;
+        email: string;
+        effectivePlanId: string;
+        status: string;
+        isUnlimited: boolean;
+        creditsAvailable: number;
+        creditsAllocatedThisPeriod: number;
+        topOffCreditsAvailable: number;
+        topOffCreditsTotal: number;
+        allocationSource: string;
+        sourceDetails: {};
+        periodStart: null;
+        periodEnd: null;
+        planTermEndTimestamp: null;
+        ownerType: string;
+        createdAt: string;
+        lastUpdatedAt: string;
+    } | {
+        totalCreditsAvailable: number;
+        allocationSource: string;
+        createdAt: string;
+        creditsAllocatedThisPeriod: number;
+        effectivePlanId: string;
+        email: string;
+        isUnlimited: boolean;
+        lastUpdatedAt: string;
+        ownerType: string;
+        periodStart: string;
+        periodEnd: string;
+        planTermEndTimestamp: string | null;
+        sourceDetails: Record<string, unknown>;
+        creditsAvailable?: number;
+        topOffCreditsAvailable?: number;
+        id: string;
+        userId?: undefined;
+        status?: undefined;
+        topOffCreditsTotal?: undefined;
+    }, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<{
+        id: string;
+        userId: string;
+        email: string;
+        effectivePlanId: string;
+        status: string;
+        isUnlimited: boolean;
+        creditsAvailable: number;
+        creditsAllocatedThisPeriod: number;
+        topOffCreditsAvailable: number;
+        topOffCreditsTotal: number;
+        allocationSource: string;
+        sourceDetails: {};
+        periodStart: null;
+        periodEnd: null;
+        planTermEndTimestamp: null;
+        ownerType: string;
+        createdAt: string;
+        lastUpdatedAt: string;
+    } | {
+        totalCreditsAvailable: number;
+        allocationSource: string;
+        createdAt: string;
+        creditsAllocatedThisPeriod: number;
+        effectivePlanId: string;
+        email: string;
+        isUnlimited: boolean;
+        lastUpdatedAt: string;
+        ownerType: string;
+        periodStart: string;
+        periodEnd: string;
+        planTermEndTimestamp: string | null;
+        sourceDetails: Record<string, unknown>;
+        creditsAvailable?: number;
+        topOffCreditsAvailable?: number;
+        id: string;
+        userId?: undefined;
+        status?: undefined;
+        topOffCreditsTotal?: undefined;
+    }>;
+} | {
+    data: {
+        id: string;
+        userId: string;
+        email: string;
+        effectivePlanId: string;
+        status: string;
+        isUnlimited: boolean;
+        creditsAvailable: number;
+        creditsAllocatedThisPeriod: number;
+        topOffCreditsAvailable: number;
+        topOffCreditsTotal: number;
+        allocationSource: string;
+        sourceDetails: {};
+        periodStart: null;
+        periodEnd: null;
+        planTermEndTimestamp: null;
+        ownerType: string;
+        createdAt: string;
+        lastUpdatedAt: string;
+    } | {
+        totalCreditsAvailable: number;
+        allocationSource: string;
+        createdAt: string;
+        creditsAllocatedThisPeriod: number;
+        effectivePlanId: string;
+        email: string;
+        isUnlimited: boolean;
+        lastUpdatedAt: string;
+        ownerType: string;
+        periodStart: string;
+        periodEnd: string;
+        planTermEndTimestamp: string | null;
+        sourceDetails: Record<string, unknown>;
+        creditsAvailable?: number;
+        topOffCreditsAvailable?: number;
+        id: string;
+        userId?: undefined;
+        status?: undefined;
+        topOffCreditsTotal?: undefined;
+    };
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<{
+        id: string;
+        userId: string;
+        email: string;
+        effectivePlanId: string;
+        status: string;
+        isUnlimited: boolean;
+        creditsAvailable: number;
+        creditsAllocatedThisPeriod: number;
+        topOffCreditsAvailable: number;
+        topOffCreditsTotal: number;
+        allocationSource: string;
+        sourceDetails: {};
+        periodStart: null;
+        periodEnd: null;
+        planTermEndTimestamp: null;
+        ownerType: string;
+        createdAt: string;
+        lastUpdatedAt: string;
+    } | {
+        totalCreditsAvailable: number;
+        allocationSource: string;
+        createdAt: string;
+        creditsAllocatedThisPeriod: number;
+        effectivePlanId: string;
+        email: string;
+        isUnlimited: boolean;
+        lastUpdatedAt: string;
+        ownerType: string;
+        periodStart: string;
+        periodEnd: string;
+        planTermEndTimestamp: string | null;
+        sourceDetails: Record<string, unknown>;
+        creditsAvailable?: number;
+        topOffCreditsAvailable?: number;
+        id: string;
+        userId?: undefined;
+        status?: undefined;
+        topOffCreditsTotal?: undefined;
+    }, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<{
+        id: string;
+        userId: string;
+        email: string;
+        effectivePlanId: string;
+        status: string;
+        isUnlimited: boolean;
+        creditsAvailable: number;
+        creditsAllocatedThisPeriod: number;
+        topOffCreditsAvailable: number;
+        topOffCreditsTotal: number;
+        allocationSource: string;
+        sourceDetails: {};
+        periodStart: null;
+        periodEnd: null;
+        planTermEndTimestamp: null;
+        ownerType: string;
+        createdAt: string;
+        lastUpdatedAt: string;
+    } | {
+        totalCreditsAvailable: number;
+        allocationSource: string;
+        createdAt: string;
+        creditsAllocatedThisPeriod: number;
+        effectivePlanId: string;
+        email: string;
+        isUnlimited: boolean;
+        lastUpdatedAt: string;
+        ownerType: string;
+        periodStart: string;
+        periodEnd: string;
+        planTermEndTimestamp: string | null;
+        sourceDetails: Record<string, unknown>;
+        creditsAvailable?: number;
+        topOffCreditsAvailable?: number;
+        id: string;
+        userId?: undefined;
+        status?: undefined;
+        topOffCreditsTotal?: undefined;
+    }>;
+} | {
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<{
+        id: string;
+        userId: string;
+        email: string;
+        effectivePlanId: string;
+        status: string;
+        isUnlimited: boolean;
+        creditsAvailable: number;
+        creditsAllocatedThisPeriod: number;
+        topOffCreditsAvailable: number;
+        topOffCreditsTotal: number;
+        allocationSource: string;
+        sourceDetails: {};
+        periodStart: null;
+        periodEnd: null;
+        planTermEndTimestamp: null;
+        ownerType: string;
+        createdAt: string;
+        lastUpdatedAt: string;
+    } | {
+        totalCreditsAvailable: number;
+        allocationSource: string;
+        createdAt: string;
+        creditsAllocatedThisPeriod: number;
+        effectivePlanId: string;
+        email: string;
+        isUnlimited: boolean;
+        lastUpdatedAt: string;
+        ownerType: string;
+        periodStart: string;
+        periodEnd: string;
+        planTermEndTimestamp: string | null;
+        sourceDetails: Record<string, unknown>;
+        creditsAvailable?: number;
+        topOffCreditsAvailable?: number;
+        id: string;
+        userId?: undefined;
+        status?: undefined;
+        topOffCreditsTotal?: undefined;
+    }, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<{
+        id: string;
+        userId: string;
+        email: string;
+        effectivePlanId: string;
+        status: string;
+        isUnlimited: boolean;
+        creditsAvailable: number;
+        creditsAllocatedThisPeriod: number;
+        topOffCreditsAvailable: number;
+        topOffCreditsTotal: number;
+        allocationSource: string;
+        sourceDetails: {};
+        periodStart: null;
+        periodEnd: null;
+        planTermEndTimestamp: null;
+        ownerType: string;
+        createdAt: string;
+        lastUpdatedAt: string;
+    } | {
+        totalCreditsAvailable: number;
+        allocationSource: string;
+        createdAt: string;
+        creditsAllocatedThisPeriod: number;
+        effectivePlanId: string;
+        email: string;
+        isUnlimited: boolean;
+        lastUpdatedAt: string;
+        ownerType: string;
+        periodStart: string;
+        periodEnd: string;
+        planTermEndTimestamp: string | null;
+        sourceDetails: Record<string, unknown>;
+        creditsAvailable?: number;
+        topOffCreditsAvailable?: number;
+        id: string;
+        userId?: undefined;
+        status?: undefined;
+        topOffCreditsTotal?: undefined;
+    }>;
+} | {
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<{
+        id: string;
+        userId: string;
+        email: string;
+        effectivePlanId: string;
+        status: string;
+        isUnlimited: boolean;
+        creditsAvailable: number;
+        creditsAllocatedThisPeriod: number;
+        topOffCreditsAvailable: number;
+        topOffCreditsTotal: number;
+        allocationSource: string;
+        sourceDetails: {};
+        periodStart: null;
+        periodEnd: null;
+        planTermEndTimestamp: null;
+        ownerType: string;
+        createdAt: string;
+        lastUpdatedAt: string;
+    } | {
+        totalCreditsAvailable: number;
+        allocationSource: string;
+        createdAt: string;
+        creditsAllocatedThisPeriod: number;
+        effectivePlanId: string;
+        email: string;
+        isUnlimited: boolean;
+        lastUpdatedAt: string;
+        ownerType: string;
+        periodStart: string;
+        periodEnd: string;
+        planTermEndTimestamp: string | null;
+        sourceDetails: Record<string, unknown>;
+        creditsAvailable?: number;
+        topOffCreditsAvailable?: number;
+        id: string;
+        userId?: undefined;
+        status?: undefined;
+        topOffCreditsTotal?: undefined;
+    }, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<{
+        id: string;
+        userId: string;
+        email: string;
+        effectivePlanId: string;
+        status: string;
+        isUnlimited: boolean;
+        creditsAvailable: number;
+        creditsAllocatedThisPeriod: number;
+        topOffCreditsAvailable: number;
+        topOffCreditsTotal: number;
+        allocationSource: string;
+        sourceDetails: {};
+        periodStart: null;
+        periodEnd: null;
+        planTermEndTimestamp: null;
+        ownerType: string;
+        createdAt: string;
+        lastUpdatedAt: string;
+    } | {
+        totalCreditsAvailable: number;
+        allocationSource: string;
+        createdAt: string;
+        creditsAllocatedThisPeriod: number;
+        effectivePlanId: string;
+        email: string;
+        isUnlimited: boolean;
+        lastUpdatedAt: string;
+        ownerType: string;
+        periodStart: string;
+        periodEnd: string;
+        planTermEndTimestamp: string | null;
+        sourceDetails: Record<string, unknown>;
+        creditsAvailable?: number;
+        topOffCreditsAvailable?: number;
+        id: string;
+        userId?: undefined;
+        status?: undefined;
+        topOffCreditsTotal?: undefined;
+    }>;
+} | {
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<{
+        id: string;
+        userId: string;
+        email: string;
+        effectivePlanId: string;
+        status: string;
+        isUnlimited: boolean;
+        creditsAvailable: number;
+        creditsAllocatedThisPeriod: number;
+        topOffCreditsAvailable: number;
+        topOffCreditsTotal: number;
+        allocationSource: string;
+        sourceDetails: {};
+        periodStart: null;
+        periodEnd: null;
+        planTermEndTimestamp: null;
+        ownerType: string;
+        createdAt: string;
+        lastUpdatedAt: string;
+    } | {
+        totalCreditsAvailable: number;
+        allocationSource: string;
+        createdAt: string;
+        creditsAllocatedThisPeriod: number;
+        effectivePlanId: string;
+        email: string;
+        isUnlimited: boolean;
+        lastUpdatedAt: string;
+        ownerType: string;
+        periodStart: string;
+        periodEnd: string;
+        planTermEndTimestamp: string | null;
+        sourceDetails: Record<string, unknown>;
+        creditsAvailable?: number;
+        topOffCreditsAvailable?: number;
+        id: string;
+        userId?: undefined;
+        status?: undefined;
+        topOffCreditsTotal?: undefined;
+    }, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<{
+        id: string;
+        userId: string;
+        email: string;
+        effectivePlanId: string;
+        status: string;
+        isUnlimited: boolean;
+        creditsAvailable: number;
+        creditsAllocatedThisPeriod: number;
+        topOffCreditsAvailable: number;
+        topOffCreditsTotal: number;
+        allocationSource: string;
+        sourceDetails: {};
+        periodStart: null;
+        periodEnd: null;
+        planTermEndTimestamp: null;
+        ownerType: string;
+        createdAt: string;
+        lastUpdatedAt: string;
+    } | {
+        totalCreditsAvailable: number;
+        allocationSource: string;
+        createdAt: string;
+        creditsAllocatedThisPeriod: number;
+        effectivePlanId: string;
+        email: string;
+        isUnlimited: boolean;
+        lastUpdatedAt: string;
+        ownerType: string;
+        periodStart: string;
+        periodEnd: string;
+        planTermEndTimestamp: string | null;
+        sourceDetails: Record<string, unknown>;
+        creditsAvailable?: number;
+        topOffCreditsAvailable?: number;
+        id: string;
+        userId?: undefined;
+        status?: undefined;
+        topOffCreditsTotal?: undefined;
+    }>;
+} | {
+    data: {
+        id: string;
+        userId: string;
+        email: string;
+        effectivePlanId: string;
+        status: string;
+        isUnlimited: boolean;
+        creditsAvailable: number;
+        creditsAllocatedThisPeriod: number;
+        topOffCreditsAvailable: number;
+        topOffCreditsTotal: number;
+        allocationSource: string;
+        sourceDetails: {};
+        periodStart: null;
+        periodEnd: null;
+        planTermEndTimestamp: null;
+        ownerType: string;
+        createdAt: string;
+        lastUpdatedAt: string;
+    } | {
+        totalCreditsAvailable: number;
+        allocationSource: string;
+        createdAt: string;
+        creditsAllocatedThisPeriod: number;
+        effectivePlanId: string;
+        email: string;
+        isUnlimited: boolean;
+        lastUpdatedAt: string;
+        ownerType: string;
+        periodStart: string;
+        periodEnd: string;
+        planTermEndTimestamp: string | null;
+        sourceDetails: Record<string, unknown>;
+        creditsAvailable?: number;
+        topOffCreditsAvailable?: number;
+        id: string;
+        userId?: undefined;
+        status?: undefined;
+        topOffCreditsTotal?: undefined;
+    };
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<{
+        id: string;
+        userId: string;
+        email: string;
+        effectivePlanId: string;
+        status: string;
+        isUnlimited: boolean;
+        creditsAvailable: number;
+        creditsAllocatedThisPeriod: number;
+        topOffCreditsAvailable: number;
+        topOffCreditsTotal: number;
+        allocationSource: string;
+        sourceDetails: {};
+        periodStart: null;
+        periodEnd: null;
+        planTermEndTimestamp: null;
+        ownerType: string;
+        createdAt: string;
+        lastUpdatedAt: string;
+    } | {
+        totalCreditsAvailable: number;
+        allocationSource: string;
+        createdAt: string;
+        creditsAllocatedThisPeriod: number;
+        effectivePlanId: string;
+        email: string;
+        isUnlimited: boolean;
+        lastUpdatedAt: string;
+        ownerType: string;
+        periodStart: string;
+        periodEnd: string;
+        planTermEndTimestamp: string | null;
+        sourceDetails: Record<string, unknown>;
+        creditsAvailable?: number;
+        topOffCreditsAvailable?: number;
+        id: string;
+        userId?: undefined;
+        status?: undefined;
+        topOffCreditsTotal?: undefined;
+    }, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<{
+        id: string;
+        userId: string;
+        email: string;
+        effectivePlanId: string;
+        status: string;
+        isUnlimited: boolean;
+        creditsAvailable: number;
+        creditsAllocatedThisPeriod: number;
+        topOffCreditsAvailable: number;
+        topOffCreditsTotal: number;
+        allocationSource: string;
+        sourceDetails: {};
+        periodStart: null;
+        periodEnd: null;
+        planTermEndTimestamp: null;
+        ownerType: string;
+        createdAt: string;
+        lastUpdatedAt: string;
+    } | {
+        totalCreditsAvailable: number;
+        allocationSource: string;
+        createdAt: string;
+        creditsAllocatedThisPeriod: number;
+        effectivePlanId: string;
+        email: string;
+        isUnlimited: boolean;
+        lastUpdatedAt: string;
+        ownerType: string;
+        periodStart: string;
+        periodEnd: string;
+        planTermEndTimestamp: string | null;
+        sourceDetails: Record<string, unknown>;
+        creditsAvailable?: number;
+        topOffCreditsAvailable?: number;
+        id: string;
+        userId?: undefined;
+        status?: undefined;
+        topOffCreditsTotal?: undefined;
+    }>;
+};
+
+interface OrganizationAccess {
+    hasUnlimitedAccess: boolean;
+    subscriptionId: string | null;
+    organizationId: string | null;
+    organizationName: string | null;
+    subscriptionEndDate: Date | null;
+    accessType: 'organization' | 'individual' | 'institution_subscriptions';
+}
+interface InstitutionSubscription {
+    id: string;
+    institutionId: string;
+    name: string;
+    plan: string;
+    endDate: Date;
+}
+interface Organization {
+    id: string;
+    name: string;
+    members: string[];
+    masterSubscriptionStatus: string;
+    masterSubscriptionId: string;
+    masterSubscriptionEndDate: Date;
+}
+declare const useOrganizationAccess: () => {
+    data: OrganizationAccess;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<OrganizationAccess, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<OrganizationAccess>;
+} | {
+    data: OrganizationAccess;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<OrganizationAccess, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<OrganizationAccess>;
+} | {
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<OrganizationAccess, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<OrganizationAccess>;
+} | {
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<OrganizationAccess, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<OrganizationAccess>;
+} | {
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<OrganizationAccess, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<OrganizationAccess>;
+} | {
+    data: OrganizationAccess;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<OrganizationAccess, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<OrganizationAccess>;
+};
+
+declare function useSpeakableTranscript(): {
+    mutation: _tanstack_react_query.UseMutationResult<string | null, Error, {
+        model: "gemini" | "assemblyai";
+        audioUrl: string;
+        language: string;
+        prompt?: string;
+    }, unknown>;
+};
+
+declare const useUpdateStudentVocab: (page: PageActivityWithId | null) => {
+    studentVocabMarkVoiceSuccess: undefined;
+    studentVocabMarkVoiceFail: undefined;
+} | {
+    studentVocabMarkVoiceSuccess: () => Promise<void>;
+    studentVocabMarkVoiceFail: () => Promise<void>;
+};
+
+declare const useBaseOpenAI: ({ onTranscriptSuccess, onTranscriptError, onCompletionSuccess, onCompletionError, aiEnabled, submitAudioResponse, uploadAudioAndGetTranscript, onGetAudioUrlAndTranscript, }: {
+    onTranscriptSuccess: (transcript: string) => void;
+    onTranscriptError: ({ type, message }: {
+        type: string;
+        message: string;
+    }) => void;
+    onCompletionSuccess: (completion: any) => void;
+    onCompletionError: ({ type, message }: {
+        type: string;
+        message: string;
+    }) => void;
+    aiEnabled: boolean;
+    submitAudioResponse: (audio: string) => Promise<{
+        url: string;
+        fileName: string;
+    }>;
+    uploadAudioAndGetTranscript: (audio: string, language: string, pagePrompt: string | null) => Promise<{
+        transcript: string;
+        audioUrl: string;
+    }>;
+    onGetAudioUrlAndTranscript?: (args: {
+        transcript?: string;
+        audioUrl?: string;
+    }) => void;
+}) => {
+    submitAudioResponse: (audio: string) => Promise<{
+        url: string;
+        fileName: string;
+    }>;
+    uploadAudioAndGetTranscript: (audio: string, language: string, pagePrompt: string | null) => Promise<{
+        transcript: string;
+        audioUrl: string;
+    }>;
+    getTranscript: (audioUrl: string, language: string, prompt?: string) => Promise<any>;
+    getFreeResponseCompletion: (messages: string[], isFreeResponse: boolean, feedbackLanguage: string, gradingStandard?: string) => Promise<any>;
+    getFeedback: ({ cardId, language, writtenResponse, audio, autoGrade, file, pagePrompt, }: {
+        cardId: string;
+        language: string;
+        writtenResponse: string | null;
+        audio: string | null;
+        autoGrade: boolean;
+        file: string | null;
+        pagePrompt: string | null;
+    }) => Promise<{
+        noFeedbackAvailable: boolean;
+        success: boolean;
+        reason: string;
+        accessType: "ai_enabled" | "teacher_preview" | "student_with_teacher_plan" | "none";
+    } | {
+        noFeedbackAvailable: boolean;
+        success: boolean;
+        reason: string;
+        accessType: string;
+        aiSuccess: boolean;
+    }>;
+};
+
+interface ActivityFeedbackAccess {
+    canAccessFeedback: boolean;
+    reason?: string;
+    isUnlimited: boolean;
+    accessType: 'ai_enabled' | 'teacher_preview' | 'student_with_teacher_plan' | 'none';
+}
+/**
+ * Hook to check feedback permissions for both students and teachers
+ *
+ * Permission Logic:
+ * 1. aiEnabled: true → Allow feedback access always (highest priority)
+ * 2. Teachers on /activity route → Always allowed (ADMIN role)
+ * 3. Students on /activity route → Need teacher with active plan (team/org)
+ *
+ * @param params - Parameters for permission checking
+ * @returns Feedback permissions information
+ */
+declare const useActivityFeedbackAccess: ({ aiEnabled, isActivityRoute, }: {
+    aiEnabled?: boolean;
+    isActivityRoute?: boolean;
+}) => {
+    data: ActivityFeedbackAccess;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<ActivityFeedbackAccess, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<ActivityFeedbackAccess>;
+} | {
+    data: ActivityFeedbackAccess;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<ActivityFeedbackAccess, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<ActivityFeedbackAccess>;
+} | {
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<ActivityFeedbackAccess, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<ActivityFeedbackAccess>;
+} | {
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<ActivityFeedbackAccess, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<ActivityFeedbackAccess>;
+} | {
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<ActivityFeedbackAccess, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<ActivityFeedbackAccess>;
+} | {
+    data: ActivityFeedbackAccess;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<ActivityFeedbackAccess, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<ActivityFeedbackAccess>;
+};
+
 declare const createFsClientNative: ({ db, httpsCallable, logEvent }: FsClientParams) => {
     assignmentRepo: {
         getAssignment: (params: {
@@ -708,4 +3277,4 @@ declare const createFsClientNative: ({ db, httpsCallable, logEvent }: FsClientPa
     };
 };
 
-export { createFsClientNative as createFsClient };
+export { ActivityPageType, type Assignment, type AssignmentAnalyticsType$1 as AssignmentAnalyticsType, type AssignmentWithId, BASE_MULTIPLE_CHOICE_FIELD_VALUES, BASE_REPEAT_FIELD_VALUES, BASE_RESPOND_FIELD_VALUES, type CreditContract, FeedbackTypesCard, FsCtx, type InstitutionSubscription, LENIENCY_OPTIONS, LeniencyCard, MULTIPLE_CHOICE_PAGE_ACTIVITY_TYPES, type Organization, type OrganizationAccess, type PageActivity, type PageActivityWithId, type PageScore, REPEAT_PAGE_ACTIVITY_TYPES, RESPOND_AUDIO_PAGE_ACTIVITY_TYPES, RESPOND_PAGE_ACTIVITY_TYPES, RESPOND_WRITE_PAGE_ACTIVITY_TYPES, type RefsCardsFiresotre, type RefsSetsFirestore, SPEAKABLE_NOTIFICATIONS, STUDENT_LEVELS_OPTIONS, type Score, type ScoreWithId, type Set, type SetWithId, type SpeakableNotificationType, SpeakableNotificationTypes, SpeakableProvider, VerificationCardStatus, assignmentQueryKeys, cardsQueryKeys, checkIsMCPage, checkIsMediaPage, checkIsRepeatPage, checkIsRespondAudioPage, checkIsRespondPage, checkIsRespondWrittenPage, checkIsShortAnswerPage, checkTypePageActivity, cleanString, createAssignmentRepo, createCardRepo, createFsClientNative as createFsClient, createSetRepo, creditQueryKeys, debounce, getCardFromCache, getLabelPage, getPagePrompt, getPhraseLength, getRespondCardTool, getSetFromCache, getTotalCompletedCards, getTranscript, getWordHash, purify, refsCardsFiresotre, refsSetsFirestore, scoreQueryKeys, setsQueryKeys, updateCardInCache, updateSetInCache, useActivity, useActivityFeedbackAccess, useAssignment, useBaseOpenAI, useCards, useClearScore, useClearScoreV2, useCreateCard, useCreateCards, useCreateNotification, useGetCard, useOrganizationAccess, useScore, useSet, useSpeakableApi, useSpeakableTranscript, useSubmitAssignmentScore, useSubmitPracticeScore, useUpdateCardScore, useUpdateScore, useUpdateStudentVocab, useUserCredits };