@speakableio/core 0.1.2 → 0.1.3

package/dist/index.d.ts

@@ -2,11 +2,20 @@ 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 { Firestore } from 'firebase/firestore';
-import { FirebaseFirestoreTypes } from '@react-native-firebase/firestore';
+import { FirebaseFunctionsTypes } from '@react-native-firebase/functions';
+import { Functions } from 'firebase/functions';
+import { Firestore, Timestamp as Timestamp$2, FieldValue } from 'firebase/firestore';
+import { FirebaseFirestoreTypes, Timestamp as Timestamp$1 } from '@react-native-firebase/firestore';
+import * as _firebase_functions from '@firebase/functions';
+
+type FirebaseInstance = (FirebaseFirestoreTypes.Module | Firestore) & {
+    functions: FirebaseFunctions;
+};
+type CustomTimestamp = Timestamp$1 | Timestamp$2;
+type FirebaseFunctions = Functions | FirebaseFunctionsTypes.Module;
 
 interface Assignment {
-    title: string;
+    name: string;
     description: string;
     scheduledTime?: string | null;
     dueTime?: {
@@ -27,10 +36,7 @@ interface Assignment {
     };
     teacherName: string;
     courseWorkId: string | null;
-    dueDateTimestamp: {
-        seconds: number;
-        nanoseconds: number;
-    };
+    dueDateTimestamp: CustomTimestamp;
     scheduledTimeTimestamp: number;
     active: boolean;
     voice: string | null;
@@ -43,12 +49,102 @@ interface Assignment {
     courseId: string;
     isAssessment: boolean;
     isAvailable: boolean;
+    ltiDeeplink?: string;
 }
 interface AssignmentWithId extends Assignment {
     id: string;
     isAvailable: boolean;
     scores?: unknown;
 }
+interface Score {
+    userId: string;
+    owners: string[];
+    progress: number;
+    score: number;
+    cards?: {
+        [cardId: string]: CardScore;
+    };
+    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?: CardScore[];
+    attempts?: number;
+    assignmentId?: string;
+    setId?: string;
+}
+interface ScoreWithId extends Score {
+    id: string;
+}
+interface CardScore {
+    voiceSuccess?: number;
+    voiceAttempts?: number;
+    voiceFail?: number;
+    completed?: boolean;
+    attempts?: number;
+    correct?: number;
+    success?: boolean;
+    aiSuccess?: boolean;
+    grading_method?: 'simple' | 'rubric' | 'manual' | 'standards_based';
+    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;
+    errors?: any;
+    improvedResponse?: string;
+    audio?: string;
+    actfl?: {
+        justification: string;
+        level: string;
+    };
+    wida?: {
+        justification: string;
+        level: string;
+    };
+    earned_points?: number;
+    fileName?: string;
+    max_points?: number;
+    passing_score?: number;
+    rubric?: {
+        description: string;
+        justification: string;
+        maxPoints: number;
+        score: number;
+        score_title: string;
+        title: string;
+    }[];
+    scoring_type?: string;
+    history?: CardScore[];
+    media_area_opened?: boolean;
+    noFeedbackAvailable?: boolean;
+    proficiency_level?: {
+        standardId: string;
+        level: string;
+        justification: string;
+        key_indicators?: string[];
+    };
+    status?: string;
+}
 
 declare const enum AssignmentAnalyticsType {
     Macro = "macro",
@@ -59,25 +155,17 @@ declare const enum AssignmentAnalyticsType {
     All = "all"
 }
 
-interface GetAttachScoresParams {
-    assignments: AssignmentWithId[];
-    analyticType: AssignmentAnalyticsType;
-    studentId?: string;
-    currentUserId: string;
-}
-interface GetAssignmentScoresParams {
-    assignmentId: string;
-    currentUserId: string;
-    analyticType?: AssignmentAnalyticsType;
-    studentId?: string;
-}
-
 declare const createAssignmentRepo: () => {
-    getAssignment: (params: GetAssignmentScoresParams) => Promise<AssignmentWithId | {
+    getAssignment: (params: {
+        assignmentId: string;
+        currentUserId: string;
+        analyticType?: AssignmentAnalyticsType;
+        studentId?: string;
+    }) => Promise<AssignmentWithId | {
         scores: any;
         id: string;
         isAvailable: boolean;
-        title: string;
+        name: string;
         description: string;
         scheduledTime?: string | null;
         dueTime?: {
@@ -98,10 +186,7 @@ declare const createAssignmentRepo: () => {
         };
         teacherName: string;
         courseWorkId: string | null;
-        dueDateTimestamp: {
-            seconds: number;
-            nanoseconds: number;
-        };
+        dueDateTimestamp: CustomTimestamp;
         scheduledTimeTimestamp: number;
         active: boolean;
         voice: string | null;
@@ -113,12 +198,18 @@ declare const createAssignmentRepo: () => {
         maxPoints: number;
         courseId: string;
         isAssessment: boolean;
+        ltiDeeplink?: string;
     } | null>;
-    attachScoresAssignment: (args_0: GetAttachScoresParams) => Promise<{
+    attachScoresAssignment: (args_0: {
+        assignments: AssignmentWithId[];
+        analyticType: AssignmentAnalyticsType;
+        studentId?: string;
+        currentUserId: string;
+    }) => Promise<{
         scores: any;
         id: string;
         isAvailable: boolean;
-        title: string;
+        name: string;
         description: string;
         scheduledTime?: string | null;
         dueTime?: {
@@ -139,10 +230,7 @@ declare const createAssignmentRepo: () => {
         };
         teacherName: string;
         courseWorkId: string | null;
-        dueDateTimestamp: {
-            seconds: number;
-            nanoseconds: number;
-        };
+        dueDateTimestamp: CustomTimestamp;
         scheduledTimeTimestamp: number;
         active: boolean;
         voice: string | null;
@@ -154,8 +242,14 @@ declare const createAssignmentRepo: () => {
         maxPoints: number;
         courseId: string;
         isAssessment: boolean;
+        ltiDeeplink?: string;
     }[]>;
-    getAssignmentScores: (args_0: GetAssignmentScoresParams) => Promise<{
+    getAssignmentScores: (args_0: {
+        assignmentId: string;
+        currentUserId: string;
+        analyticType?: AssignmentAnalyticsType;
+        studentId?: string;
+    }) => Promise<{
         scores: unknown;
         id: string;
     } | undefined>;
@@ -176,7 +270,7 @@ declare function useAssignment({ assignmentId, enabled, analyticType, userId, }:
     scores: any;
     id: string;
     isAvailable: boolean;
-    title: string;
+    name: string;
     description: string;
     scheduledTime?: string | null;
     dueTime?: {
@@ -197,10 +291,7 @@ declare function useAssignment({ assignmentId, enabled, analyticType, userId, }:
     };
     teacherName: string;
     courseWorkId: string | null;
-    dueDateTimestamp: {
-        seconds: number;
-        nanoseconds: number;
-    };
+    dueDateTimestamp: CustomTimestamp;
     scheduledTimeTimestamp: number;
     active: boolean;
     voice: string | null;
@@ -212,18 +303,456 @@ declare function useAssignment({ assignmentId, enabled, analyticType, userId, }:
     maxPoints: number;
     courseId: string;
     isAssessment: boolean;
+    ltiDeeplink?: string;
 } | null, Error>;
 
-type FirebaseInstance = FirebaseFirestoreTypes.Module | Firestore;
+declare const enum FeedbackTypesCard {
+    SuggestedResponse = "suggested_response",
+    Wida = "wida",
+    GrammarInsights = "grammar_insights",
+    Actfl = "actfl",
+    ProficiencyLevel = "proficiency_level"
+}
+declare const 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 const enum VerificationCardStatus {
+    VERIFIED = "VERIFIED",
+    WARNING = "WARNING",
+    NOT_RECOMMENDED = "NOT_RECOMMENDED",
+    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 CardActivityWithId extends CardActivity {
+    id: string;
+}
+interface CardActivity {
+    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: CardActivityType;
+    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;
+}
+declare const enum CardActivityType {
+    READ_REPEAT = "READ_REPEAT",
+    VIDEO = "VIDEO",
+    TEXT = "TEXT",
+    READ_RESPOND = "READ_RESPOND",
+    FREE_RESPONSE = "FREE_RESPONSE",
+    REPEAT = "REPEAT",
+    RESPOND = "RESPOND",
+    RESPOND_WRITE = "RESPOND_WRITE",
+    TEXT_TO_SPEECH = "TEXT_TO_SPEECH",
+    MULTIPLE_CHOICE = "MULTIPLE_CHOICE",
+    PODCAST = "PODCAST",
+    MEDIA_PAGE = "MEDIA_PAGE",
+    WRITE = "WRITE",
+    SHORT_ANSWER = "SHORT_ANSWER",
+    SHORT_STORY = "SHORT_STORY",
+    SPEAK = "SPEAK",
+    CONVERSATION = "CONVERSATION",
+    CONVERSATION_WRITE = "CONVERSATION_WRITE",
+    DIALOGUE = "DIALOGUE",
+    INSTRUCTION = "INSTRUCTION",
+    LISTEN = "LISTEN",
+    READ = "READ",
+    ANSWER = "ANSWER"
+}
+declare const RESPOND_CARD_ACTIVITY_TYPES: CardActivityType[];
+declare const MULTIPLE_CHOICE_CARD_ACTIVITY_TYPES: CardActivityType[];
+declare const REPEAT_CARD_ACTIVITY_TYPES: CardActivityType[];
+declare const RESPOND_WRITE_CARD_ACTIVITY_TYPES: CardActivityType[];
+declare const RESPOND_AUDIO_CARD_ACTIVITY_TYPES: CardActivityType[];
+declare const ALLOWED_CARD_ACTIVITY_TYPES_FOR_SUMMARY: CardActivityType[];
+
+declare const cardsQueryKeys: {
+    all: string[];
+    one: (params: {
+        cardId: string;
+    }) => string[];
+};
+declare function useCards({ cardIds, enabled, asObject, }: {
+    cardIds: string[];
+    enabled: boolean;
+    asObject?: boolean;
+}): {
+    cards: CardActivityWithId[];
+    cardsObject: Record<string, CardActivityWithId> | null;
+    cardsQueries: _tanstack_react_query.UseQueryResult<CardActivityWithId | null, Error>[];
+};
+declare function useCreateCard(): {
+    mutationCreateCard: _tanstack_react_query.UseMutationResult<{
+        id: string;
+    } & Partial<CardActivity>, Error, {
+        data: Partial<CardActivity>;
+    }, 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: CardActivityType;
+        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;
+    }[], Error, {
+        cards: CardActivity[];
+    }, unknown>;
+};
+declare function getCardFromCache({ cardId, queryClient, }: {
+    cardId: string;
+    queryClient: QueryClient;
+}): CardActivityWithId | undefined;
+declare function updateCardInCache({ cardId, card, queryClient, }: {
+    cardId: string;
+    card: CardActivityWithId | null;
+    queryClient: QueryClient;
+}): void;
+
+declare const createCardRepo: () => {
+    createCard: (args_0: {
+        data: Partial<CardActivity>;
+    }) => Promise<{
+        id: string;
+    } & Partial<CardActivity>>;
+    createCards: (args_0: {
+        cards: CardActivity[];
+    }) => 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: CardActivityType;
+        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;
+    }[]>;
+    getCard: (params: {
+        cardId: string;
+    }) => Promise<CardActivityWithId | null>;
+};
+
+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 CardActivityType]?: 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<_firebase_functions.HttpsCallableResult<unknown> | {
+        success: boolean;
+        message: string;
+    } | null | undefined>;
+};
 
 type FsClient = ReturnType<typeof createFsClient>;
-declare function createFsClient(db: FirebaseInstance, platform: 'web' | 'native'): Promise<{
+declare function createFsClient({ db, platform, functions, }: {
+    db: FirebaseInstance;
+    platform: 'web' | 'native';
+    functions: FirebaseFunctions;
+}): Promise<{
     assignmentRepo: {
-        getAssignment: (params: GetAssignmentScoresParams) => Promise<AssignmentWithId | {
+        getAssignment: (params: {
+            assignmentId: string;
+            currentUserId: string;
+            analyticType?: AssignmentAnalyticsType;
+            studentId?: string;
+        }) => Promise<AssignmentWithId | {
             scores: any;
             id: string;
             isAvailable: boolean;
-            title: string;
+            name: string;
             description: string;
             scheduledTime?: string | null;
             dueTime?: {
@@ -244,10 +773,7 @@ declare function createFsClient(db: FirebaseInstance, platform: 'web' | 'native'
             };
             teacherName: string;
             courseWorkId: string | null;
-            dueDateTimestamp: {
-                seconds: number;
-                nanoseconds: number;
-            };
+            dueDateTimestamp: CustomTimestamp;
             scheduledTimeTimestamp: number;
             active: boolean;
             voice: string | null;
@@ -259,12 +785,18 @@ declare function createFsClient(db: FirebaseInstance, platform: 'web' | 'native'
             maxPoints: number;
             courseId: string;
             isAssessment: boolean;
+            ltiDeeplink?: string;
         } | null>;
-        attachScoresAssignment: (args_0: GetAttachScoresParams) => Promise<{
+        attachScoresAssignment: (args_0: {
+            assignments: AssignmentWithId[];
+            analyticType: AssignmentAnalyticsType;
+            studentId?: string;
+            currentUserId: string;
+        }) => Promise<{
             scores: any;
             id: string;
             isAvailable: boolean;
-            title: string;
+            name: string;
             description: string;
             scheduledTime?: string | null;
             dueTime?: {
@@ -285,10 +817,7 @@ declare function createFsClient(db: FirebaseInstance, platform: 'web' | 'native'
             };
             teacherName: string;
             courseWorkId: string | null;
-            dueDateTimestamp: {
-                seconds: number;
-                nanoseconds: number;
-            };
+            dueDateTimestamp: CustomTimestamp;
             scheduledTimeTimestamp: number;
             active: boolean;
             voice: string | null;
@@ -300,26 +829,258 @@ declare function createFsClient(db: FirebaseInstance, platform: 'web' | 'native'
             maxPoints: number;
             courseId: string;
             isAssessment: boolean;
+            ltiDeeplink?: string;
         }[]>;
-        getAssignmentScores: (args_0: GetAssignmentScoresParams) => Promise<{
+        getAssignmentScores: (args_0: {
+            assignmentId: string;
+            currentUserId: string;
+            analyticType?: AssignmentAnalyticsType;
+            studentId?: string;
+        }) => Promise<{
             scores: unknown;
             id: string;
         } | undefined>;
         getAllAssignments: () => Promise<AssignmentWithId[]>;
     };
+    cardRepo: {
+        createCard: (args_0: {
+            data: Partial<CardActivity>;
+        }) => Promise<{
+            id: string;
+        } & Partial<CardActivity>>;
+        createCards: (args_0: {
+            cards: CardActivity[];
+        }) => 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: CardActivityType;
+            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;
+        }[]>;
+        getCard: (params: {
+            cardId: string;
+        }) => Promise<CardActivityWithId | null>;
+    };
 }>;
 
+interface Timestamp {
+    seconds: number;
+    nanoseconds: number;
+}
+interface FirebaseCustomClaims {
+    iss: string;
+    aud: string;
+    auth_time: number;
+    user_id: string;
+    sub: string;
+    iat: number;
+    exp: number;
+    email: string;
+    email_verified: boolean;
+    lti_service_key: string;
+    firebase: {
+        identities: string[];
+        sign_in_provider: string;
+    };
+}
+interface UserProfile {
+    recentAssignments: string[];
+    onboardingComplete: boolean;
+    isGoogleUser: boolean;
+    connectedGoogleClassroom: boolean;
+    nativeLanguage: string;
+    subjects: string[];
+    healthScore: number;
+    gradeLevel: string;
+    language: string;
+    roles: string[];
+    districtID: string;
+    messageCount: number;
+    totalActiveTime: number;
+    healthScoreComponents: {
+        lastAccess: number;
+        assignmentsLast30Days: number;
+        totalAssignments: number;
+        daysActive: number;
+    };
+    onboardingSteps: string[];
+    totalAssignmentsActivated: number;
+    emailOptOut: boolean;
+    healthScoreLastUpdated: Timestamp;
+    adminStatus: string;
+    googleClassroomUserId: string;
+    recentRubrics: string[];
+    image: {
+        url: string;
+        path: string;
+    };
+    onboardingState: string;
+    emailVerified: boolean;
+    totalStudentAssignmentsSubmitted: number;
+    speakableio: boolean;
+    schoolId: string;
+    defaultGradingSettings: {
+        rubricId: string;
+        scoring_type: 'pass_fail';
+        passing_score: number;
+        feedback_types: ('wida' | 'grammar_insights' | 'actfl' | 'suggested_response')[];
+        grading_criteria: string;
+        autoGrade: boolean;
+        grading_method: 'rubric';
+    };
+    studentDeviceType: string;
+    email: string;
+    districtName: string;
+    webSessions: number;
+    lastAccess: Timestamp;
+    savedSets: string[];
+    reviewed_student_submission: boolean;
+    resetTime: string;
+    assistantId: string;
+    additionalLanguages: string[];
+    displayName: string;
+    owners: string[];
+    additionalNativeLanguages: string[];
+    dateMade: Timestamp;
+    schoolName: string;
+    loaded: boolean;
+    loading: boolean;
+    isTeacher: boolean;
+}
+interface UserAuth {
+    uid: string;
+    email: string;
+    displayName: string | null;
+    custom_claims: FirebaseCustomClaims;
+    createdAt: string;
+    lastLogin: string;
+    loaded: boolean;
+    loading: boolean;
+}
+interface Lti {
+    data: {
+        services: {
+            serviceKey: string;
+        };
+    };
+}
+interface User {
+    profile: UserProfile;
+    auth: UserAuth;
+    lti: Lti;
+    authLoaded: boolean;
+    profileLoaded: boolean;
+    roles: string[];
+    loadingRoles: boolean;
+    drawerOpen: boolean;
+    mobileOpen: boolean;
+}
+
+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;
+    firebaseFunctions: FirebaseFunctions;
+    localStorage: {
+        setItem: (key: string, value: string) => void;
+        getItem: (key: string) => string | null;
+    };
 }
 declare const FsCtx: React.Context<FsContext | null>;
-declare function SpeakableProvider({ db, platform, children, queryClient, }: {
+declare function SpeakableProvider({ db, platform, children, queryClient, user, permissions, firebaseFunctions, localStorage, }: {
     db: FirebaseInstance;
+    firebaseFunctions: FirebaseFunctions;
     platform: 'web' | 'native';
     children: React.ReactNode;
     queryClient: QueryClient;
+    user: User;
+    permissions: Permissions;
+    localStorage: {
+        setItem: (key: string, value: string) => void;
+        getItem: (key: string) => string | null;
+    };
 }): react_jsx_runtime.JSX.Element | null;
 declare function useSpeakableApi(): FsContext;
 
-export { type Assignment, type AssignmentWithId, type FsClient, FsCtx, SpeakableProvider, assignmentQueryKeys, createAssignmentRepo, createFsClient, useAssignment, useSpeakableApi };
+export { ALLOWED_CARD_ACTIVITY_TYPES_FOR_SUMMARY, type Assignment, type AssignmentWithId, BASE_MULTIPLE_CHOICE_FIELD_VALUES, BASE_REPEAT_FIELD_VALUES, BASE_RESPOND_FIELD_VALUES, type CardActivity, CardActivityType, type CardActivityWithId, type CardScore, FeedbackTypesCard, type FsClient, FsCtx, LENIENCY_OPTIONS, LeniencyCard, MULTIPLE_CHOICE_CARD_ACTIVITY_TYPES, REPEAT_CARD_ACTIVITY_TYPES, RESPOND_AUDIO_CARD_ACTIVITY_TYPES, RESPOND_CARD_ACTIVITY_TYPES, RESPOND_WRITE_CARD_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, createAssignmentRepo, createCardRepo, createFsClient, createSetRepo, getCardFromCache, getSetFromCache, refsCardsFiresotre, refsSetsFirestore, setsQueryKeys, updateCardInCache, updateSetInCache, useAssignment, useCards, useCreateCard, useCreateCards, useCreateNotification, useSet, useSpeakableApi };