@thanh01.pmt/interactive-quiz-kit 1.0.28 → 1.0.30

package/dist/ai/flows/generate-practice-suggestion.d.ts

@@ -0,0 +1,149 @@
+import { z } from 'zod';
+import type { PracticeSuggestion } from '../../types/misc';
+declare const GeneratePracticeSuggestionInputSchema: z.ZodObject<{
+    language: z.ZodString;
+    userName: z.ZodOptional<z.ZodString>;
+    performanceByTopic: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        averageScore: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        averageScore: number;
+    }, {
+        name: string;
+        averageScore: number;
+    }>, "many">>;
+    recentHistory: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        quizTitle: z.ZodString;
+        percentage: z.ZodNumber;
+        topics: z.ZodArray<z.ZodObject<{
+            subject: z.ZodString;
+            category: z.ZodString;
+            topic: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            subject: string;
+            category: string;
+            topic: string;
+        }, {
+            subject: string;
+            category: string;
+            topic: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        quizTitle: string;
+        percentage: number;
+        topics: {
+            subject: string;
+            category: string;
+            topic: string;
+        }[];
+    }, {
+        quizTitle: string;
+        percentage: number;
+        topics: {
+            subject: string;
+            category: string;
+            topic: string;
+        }[];
+    }>, "many">>;
+    allAvailableTopics: z.ZodArray<z.ZodObject<{
+        loId: z.ZodString;
+        subject: z.ZodString;
+        category: z.ZodString;
+        topic: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        subject: string;
+        category: string;
+        topic: string;
+        loId: string;
+    }, {
+        subject: string;
+        category: string;
+        topic: string;
+        loId: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    language: string;
+    allAvailableTopics: {
+        subject: string;
+        category: string;
+        topic: string;
+        loId: string;
+    }[];
+    performanceByTopic?: {
+        name: string;
+        averageScore: number;
+    }[] | undefined;
+    userName?: string | undefined;
+    recentHistory?: {
+        quizTitle: string;
+        percentage: number;
+        topics: {
+            subject: string;
+            category: string;
+            topic: string;
+        }[];
+    }[] | undefined;
+}, {
+    language: string;
+    allAvailableTopics: {
+        subject: string;
+        category: string;
+        topic: string;
+        loId: string;
+    }[];
+    performanceByTopic?: {
+        name: string;
+        averageScore: number;
+    }[] | undefined;
+    userName?: string | undefined;
+    recentHistory?: {
+        quizTitle: string;
+        percentage: number;
+        topics: {
+            subject: string;
+            category: string;
+            topic: string;
+        }[];
+    }[] | undefined;
+}>;
+export type GeneratePracticeSuggestionClientInput = z.infer<typeof GeneratePracticeSuggestionInputSchema>;
+declare const PracticeSuggestionOutputSchema: z.ZodObject<{
+    suggestionText: z.ZodString;
+    suggestedTopics: z.ZodArray<z.ZodObject<{
+        loId: z.ZodString;
+        topicName: z.ZodString;
+        reason: z.ZodEnum<["review", "explore"]>;
+        suggestedDifficulty: z.ZodEnum<["Very Easy", "Easy", "Medium", "Hard", "Expert"]>;
+    }, "strip", z.ZodTypeAny, {
+        loId: string;
+        topicName: string;
+        reason: "review" | "explore";
+        suggestedDifficulty: "Very Easy" | "Easy" | "Medium" | "Hard" | "Expert";
+    }, {
+        loId: string;
+        topicName: string;
+        reason: "review" | "explore";
+        suggestedDifficulty: "Very Easy" | "Easy" | "Medium" | "Hard" | "Expert";
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    suggestionText: string;
+    suggestedTopics: {
+        loId: string;
+        topicName: string;
+        reason: "review" | "explore";
+        suggestedDifficulty: "Very Easy" | "Easy" | "Medium" | "Hard" | "Expert";
+    }[];
+}, {
+    suggestionText: string;
+    suggestedTopics: {
+        loId: string;
+        topicName: string;
+        reason: "review" | "explore";
+        suggestedDifficulty: "Very Easy" | "Easy" | "Medium" | "Hard" | "Expert";
+    }[];
+}>;
+export type GeneratePracticeSuggestionOutput = z.infer<typeof PracticeSuggestionOutputSchema>;
+export declare function generatePracticeSuggestion(clientInput: GeneratePracticeSuggestionClientInput, apiKey: string): Promise<PracticeSuggestion>;
+export {};
+//# sourceMappingURL=generate-practice-suggestion.d.ts.map

package/dist/ai/flows/generate-practice-suggestion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-practice-suggestion.d.ts","sourceRoot":"","sources":["../../../src/ai/flows/generate-practice-suggestion.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,kBAAkB,EAAsB,MAAM,kBAAkB,CAAC;AAO/E,QAAA,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBzC,CAAC;AACH,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAC;AAE1G,QAAA,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQlC,CAAC;AACH,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAO9F,wBAAsB,0BAA0B,CAC9C,WAAW,EAAE,qCAAqC,EAClD,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,kBAAkB,CAAC,CAiE7B"}

package/dist/ai/flows/generate-questions-from-quiz-plan-types.d.ts

@@ -0,0 +1,122 @@
+import { z } from 'zod';
+import type { ImageContextItem } from '../../types/misc';
+export declare const GenerateQuestionsFromQuizPlanClientInputSchema: z.ZodObject<{
+    quizPlan: z.ZodArray<z.ZodType<{
+        plannedTopic: string;
+        plannedQuestionType: import("../..").QuestionTypeStrings;
+        plannedBloomLevel: "remembering" | "understanding" | "applying" | "analyzing" | "evaluating" | "creating";
+        plannedContextId?: string | undefined;
+        targetMisconception?: string | undefined;
+        difficultyReason?: string | undefined;
+        topicSpecificity?: "broad" | "focused" | "specific" | undefined;
+        originalLoId?: string | undefined;
+        originalSubject?: string | undefined;
+        originalCategory?: string | undefined;
+        originalTopic?: string | undefined;
+        imageId?: string | null | undefined;
+    }, z.ZodTypeDef, {
+        plannedTopic: string;
+        plannedQuestionType: import("../..").QuestionTypeStrings;
+        plannedBloomLevel: "remembering" | "understanding" | "applying" | "analyzing" | "evaluating" | "creating";
+        plannedContextId?: string | undefined;
+        targetMisconception?: string | undefined;
+        difficultyReason?: string | undefined;
+        topicSpecificity?: "broad" | "focused" | "specific" | undefined;
+        originalLoId?: string | undefined;
+        originalSubject?: string | undefined;
+        originalCategory?: string | undefined;
+        originalTopic?: string | undefined;
+        imageId?: string | null | undefined;
+    }>, "many">;
+    language: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    imageContexts: z.ZodOptional<z.ZodArray<z.ZodType<ImageContextItem, z.ZodTypeDef, ImageContextItem>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    language: string;
+    quizPlan: {
+        plannedTopic: string;
+        plannedQuestionType: import("../..").QuestionTypeStrings;
+        plannedBloomLevel: "remembering" | "understanding" | "applying" | "analyzing" | "evaluating" | "creating";
+        plannedContextId?: string | undefined;
+        targetMisconception?: string | undefined;
+        difficultyReason?: string | undefined;
+        topicSpecificity?: "broad" | "focused" | "specific" | undefined;
+        originalLoId?: string | undefined;
+        originalSubject?: string | undefined;
+        originalCategory?: string | undefined;
+        originalTopic?: string | undefined;
+        imageId?: string | null | undefined;
+    }[];
+    imageContexts?: ImageContextItem[] | undefined;
+}, {
+    quizPlan: {
+        plannedTopic: string;
+        plannedQuestionType: import("../..").QuestionTypeStrings;
+        plannedBloomLevel: "remembering" | "understanding" | "applying" | "analyzing" | "evaluating" | "creating";
+        plannedContextId?: string | undefined;
+        targetMisconception?: string | undefined;
+        difficultyReason?: string | undefined;
+        topicSpecificity?: "broad" | "focused" | "specific" | undefined;
+        originalLoId?: string | undefined;
+        originalSubject?: string | undefined;
+        originalCategory?: string | undefined;
+        originalTopic?: string | undefined;
+        imageId?: string | null | undefined;
+    }[];
+    language?: string | undefined;
+    imageContexts?: ImageContextItem[] | undefined;
+}>;
+export type GenerateQuestionsFromQuizPlanClientInput = z.infer<typeof GenerateQuestionsFromQuizPlanClientInputSchema>;
+export declare const GenerationErrorSchema: z.ZodObject<{
+    plannedQuestionIndex: z.ZodNumber;
+    plannedTopic: z.ZodString;
+    plannedQuestionType: z.ZodString;
+    error: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    error: string;
+    plannedTopic: string;
+    plannedQuestionType: string;
+    plannedQuestionIndex: number;
+}, {
+    error: string;
+    plannedTopic: string;
+    plannedQuestionType: string;
+    plannedQuestionIndex: number;
+}>;
+export type GenerationError = z.infer<typeof GenerationErrorSchema>;
+export declare const GenerateQuestionsFromQuizPlanOutputSchema: z.ZodObject<{
+    generatedQuestions: z.ZodArray<z.ZodAny, "many">;
+    errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        plannedQuestionIndex: z.ZodNumber;
+        plannedTopic: z.ZodString;
+        plannedQuestionType: z.ZodString;
+        error: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        error: string;
+        plannedTopic: string;
+        plannedQuestionType: string;
+        plannedQuestionIndex: number;
+    }, {
+        error: string;
+        plannedTopic: string;
+        plannedQuestionType: string;
+        plannedQuestionIndex: number;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    generatedQuestions: any[];
+    errors?: {
+        error: string;
+        plannedTopic: string;
+        plannedQuestionType: string;
+        plannedQuestionIndex: number;
+    }[] | undefined;
+}, {
+    generatedQuestions: any[];
+    errors?: {
+        error: string;
+        plannedTopic: string;
+        plannedQuestionType: string;
+        plannedQuestionIndex: number;
+    }[] | undefined;
+}>;
+export type GenerateQuestionsFromQuizPlanOutput = z.infer<typeof GenerateQuestionsFromQuizPlanOutputSchema>;
+//# sourceMappingURL=generate-questions-from-quiz-plan-types.d.ts.map

package/dist/ai/flows/generate-questions-from-quiz-plan-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-questions-from-quiz-plan-types.d.ts","sourceRoot":"","sources":["../../../src/ai/flows/generate-questions-from-quiz-plan-types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAMzD,eAAO,MAAM,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIzD,CAAC;AACH,MAAM,MAAM,wCAAwC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8CAA8C,CAAC,CAAC;AAEtH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;EAKhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGpD,CAAC;AACH,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yCAAyC,CAAC,CAAC"}

package/dist/ai/flows/generate-questions-from-quiz-plan.d.ts

@@ -0,0 +1,3 @@
+import { type GenerateQuestionsFromQuizPlanClientInput, type GenerateQuestionsFromQuizPlanOutput } from './generate-questions-from-quiz-plan-types';
+export declare function generateQuestionsFromQuizPlan(clientInput: GenerateQuestionsFromQuizPlanClientInput, apiKey: string): Promise<GenerateQuestionsFromQuizPlanOutput>;
+//# sourceMappingURL=generate-questions-from-quiz-plan.d.ts.map

package/dist/ai/flows/generate-questions-from-quiz-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-questions-from-quiz-plan.d.ts","sourceRoot":"","sources":["../../../src/ai/flows/generate-questions-from-quiz-plan.ts"],"names":[],"mappings":"AAuBA,OAAO,EACL,KAAK,wCAAwC,EAC7C,KAAK,mCAAmC,EACzC,MAAM,2CAA2C,CAAC;AAqCnD,wBAAsB,6BAA6B,CACjD,WAAW,EAAE,wCAAwC,EACrD,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,mCAAmC,CAAC,CA8G9C"}

package/dist/ai/flows/generate-quiz-from-text-types.d.ts

@@ -0,0 +1,358 @@
+import { z } from 'zod';
+export declare const GenerateQuizFromTextInputSchema: z.ZodObject<{
+    language: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    documentContent: z.ZodString;
+    numQuestions: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    questionTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<["multiple_choice", "true_false", "short_answer"]>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    language: string;
+    documentContent: string;
+    numQuestions: number;
+    questionTypes?: ("multiple_choice" | "true_false" | "short_answer")[] | undefined;
+}, {
+    documentContent: string;
+    language?: string | undefined;
+    numQuestions?: number | undefined;
+    questionTypes?: ("multiple_choice" | "true_false" | "short_answer")[] | undefined;
+}>;
+export type GenerateQuizFromTextClientInput = z.infer<typeof GenerateQuizFromTextInputSchema>;
+export declare const GenerateQuizFromTextOutputSchema: z.ZodObject<{
+    generatedQuestions: z.ZodArray<z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+        id: z.ZodString;
+        prompt: z.ZodString;
+        points: z.ZodOptional<z.ZodNumber>;
+        explanation: z.ZodOptional<z.ZodString>;
+        difficulty: z.ZodOptional<z.ZodEnum<["easy", "medium", "hard"]>>;
+        topic: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+        learningObjective: z.ZodOptional<z.ZodString>;
+        bloomLevel: z.ZodOptional<z.ZodString>;
+        contextCode: z.ZodOptional<z.ZodString>;
+        gradeBand: z.ZodOptional<z.ZodString>;
+        course: z.ZodOptional<z.ZodString>;
+        glossary: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    } & {
+        questionType: z.ZodLiteral<"multiple_choice">;
+        options: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            text: string;
+            id: string;
+        }, {
+            text: string;
+            id: string;
+        }>, "many">;
+        correctAnswerId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        options: {
+            text: string;
+            id: string;
+        }[];
+        correctAnswerId: string;
+        questionType: "multiple_choice";
+        prompt: string;
+        subject?: string | undefined;
+        learningObjective?: string | undefined;
+        category?: string | undefined;
+        topic?: string | undefined;
+        difficulty?: "easy" | "medium" | "hard" | undefined;
+        bloomLevel?: string | undefined;
+        points?: number | undefined;
+        explanation?: string | undefined;
+        contextCode?: string | undefined;
+        gradeBand?: string | undefined;
+        course?: string | undefined;
+        glossary?: string[] | undefined;
+    }, {
+        id: string;
+        options: {
+            text: string;
+            id: string;
+        }[];
+        correctAnswerId: string;
+        questionType: "multiple_choice";
+        prompt: string;
+        subject?: string | undefined;
+        learningObjective?: string | undefined;
+        category?: string | undefined;
+        topic?: string | undefined;
+        difficulty?: "easy" | "medium" | "hard" | undefined;
+        bloomLevel?: string | undefined;
+        points?: number | undefined;
+        explanation?: string | undefined;
+        contextCode?: string | undefined;
+        gradeBand?: string | undefined;
+        course?: string | undefined;
+        glossary?: string[] | undefined;
+    }>, {
+        id: string;
+        options: {
+            text: string;
+            id: string;
+        }[];
+        correctAnswerId: string;
+        questionType: "multiple_choice";
+        prompt: string;
+        subject?: string | undefined;
+        learningObjective?: string | undefined;
+        category?: string | undefined;
+        topic?: string | undefined;
+        difficulty?: "easy" | "medium" | "hard" | undefined;
+        bloomLevel?: string | undefined;
+        points?: number | undefined;
+        explanation?: string | undefined;
+        contextCode?: string | undefined;
+        gradeBand?: string | undefined;
+        course?: string | undefined;
+        glossary?: string[] | undefined;
+    }, {
+        id: string;
+        options: {
+            text: string;
+            id: string;
+        }[];
+        correctAnswerId: string;
+        questionType: "multiple_choice";
+        prompt: string;
+        subject?: string | undefined;
+        learningObjective?: string | undefined;
+        category?: string | undefined;
+        topic?: string | undefined;
+        difficulty?: "easy" | "medium" | "hard" | undefined;
+        bloomLevel?: string | undefined;
+        points?: number | undefined;
+        explanation?: string | undefined;
+        contextCode?: string | undefined;
+        gradeBand?: string | undefined;
+        course?: string | undefined;
+        glossary?: string[] | undefined;
+    }>, z.ZodObject<{
+        id: z.ZodString;
+        prompt: z.ZodString;
+        points: z.ZodOptional<z.ZodNumber>;
+        explanation: z.ZodOptional<z.ZodString>;
+        difficulty: z.ZodOptional<z.ZodEnum<["easy", "medium", "hard"]>>;
+        topic: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+        learningObjective: z.ZodOptional<z.ZodString>;
+        bloomLevel: z.ZodOptional<z.ZodString>;
+        contextCode: z.ZodOptional<z.ZodString>;
+        gradeBand: z.ZodOptional<z.ZodString>;
+        course: z.ZodOptional<z.ZodString>;
+        glossary: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    } & {
+        questionType: z.ZodLiteral<"true_false">;
+        correctAnswer: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        correctAnswer: boolean;
+        questionType: "true_false";
+        prompt: string;
+        subject?: string | undefined;
+        learningObjective?: string | undefined;
+        category?: string | undefined;
+        topic?: string | undefined;
+        difficulty?: "easy" | "medium" | "hard" | undefined;
+        bloomLevel?: string | undefined;
+        points?: number | undefined;
+        explanation?: string | undefined;
+        contextCode?: string | undefined;
+        gradeBand?: string | undefined;
+        course?: string | undefined;
+        glossary?: string[] | undefined;
+    }, {
+        id: string;
+        correctAnswer: boolean;
+        questionType: "true_false";
+        prompt: string;
+        subject?: string | undefined;
+        learningObjective?: string | undefined;
+        category?: string | undefined;
+        topic?: string | undefined;
+        difficulty?: "easy" | "medium" | "hard" | undefined;
+        bloomLevel?: string | undefined;
+        points?: number | undefined;
+        explanation?: string | undefined;
+        contextCode?: string | undefined;
+        gradeBand?: string | undefined;
+        course?: string | undefined;
+        glossary?: string[] | undefined;
+    }>, z.ZodObject<{
+        id: z.ZodString;
+        prompt: z.ZodString;
+        points: z.ZodOptional<z.ZodNumber>;
+        explanation: z.ZodOptional<z.ZodString>;
+        difficulty: z.ZodOptional<z.ZodEnum<["easy", "medium", "hard"]>>;
+        topic: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+        learningObjective: z.ZodOptional<z.ZodString>;
+        bloomLevel: z.ZodOptional<z.ZodString>;
+        contextCode: z.ZodOptional<z.ZodString>;
+        gradeBand: z.ZodOptional<z.ZodString>;
+        course: z.ZodOptional<z.ZodString>;
+        glossary: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    } & {
+        questionType: z.ZodLiteral<"short_answer">;
+        acceptedAnswers: z.ZodArray<z.ZodString, "many">;
+        isCaseSensitive: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        questionType: "short_answer";
+        prompt: string;
+        acceptedAnswers: string[];
+        subject?: string | undefined;
+        learningObjective?: string | undefined;
+        category?: string | undefined;
+        topic?: string | undefined;
+        difficulty?: "easy" | "medium" | "hard" | undefined;
+        bloomLevel?: string | undefined;
+        points?: number | undefined;
+        explanation?: string | undefined;
+        contextCode?: string | undefined;
+        gradeBand?: string | undefined;
+        course?: string | undefined;
+        glossary?: string[] | undefined;
+        isCaseSensitive?: boolean | undefined;
+    }, {
+        id: string;
+        questionType: "short_answer";
+        prompt: string;
+        acceptedAnswers: string[];
+        subject?: string | undefined;
+        learningObjective?: string | undefined;
+        category?: string | undefined;
+        topic?: string | undefined;
+        difficulty?: "easy" | "medium" | "hard" | undefined;
+        bloomLevel?: string | undefined;
+        points?: number | undefined;
+        explanation?: string | undefined;
+        contextCode?: string | undefined;
+        gradeBand?: string | undefined;
+        course?: string | undefined;
+        glossary?: string[] | undefined;
+        isCaseSensitive?: boolean | undefined;
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    generatedQuestions: ({
+        id: string;
+        correctAnswer: boolean;
+        questionType: "true_false";
+        prompt: string;
+        subject?: string | undefined;
+        learningObjective?: string | undefined;
+        category?: string | undefined;
+        topic?: string | undefined;
+        difficulty?: "easy" | "medium" | "hard" | undefined;
+        bloomLevel?: string | undefined;
+        points?: number | undefined;
+        explanation?: string | undefined;
+        contextCode?: string | undefined;
+        gradeBand?: string | undefined;
+        course?: string | undefined;
+        glossary?: string[] | undefined;
+    } | {
+        id: string;
+        options: {
+            text: string;
+            id: string;
+        }[];
+        correctAnswerId: string;
+        questionType: "multiple_choice";
+        prompt: string;
+        subject?: string | undefined;
+        learningObjective?: string | undefined;
+        category?: string | undefined;
+        topic?: string | undefined;
+        difficulty?: "easy" | "medium" | "hard" | undefined;
+        bloomLevel?: string | undefined;
+        points?: number | undefined;
+        explanation?: string | undefined;
+        contextCode?: string | undefined;
+        gradeBand?: string | undefined;
+        course?: string | undefined;
+        glossary?: string[] | undefined;
+    } | {
+        id: string;
+        questionType: "short_answer";
+        prompt: string;
+        acceptedAnswers: string[];
+        subject?: string | undefined;
+        learningObjective?: string | undefined;
+        category?: string | undefined;
+        topic?: string | undefined;
+        difficulty?: "easy" | "medium" | "hard" | undefined;
+        bloomLevel?: string | undefined;
+        points?: number | undefined;
+        explanation?: string | undefined;
+        contextCode?: string | undefined;
+        gradeBand?: string | undefined;
+        course?: string | undefined;
+        glossary?: string[] | undefined;
+        isCaseSensitive?: boolean | undefined;
+    })[];
+}, {
+    generatedQuestions: ({
+        id: string;
+        correctAnswer: boolean;
+        questionType: "true_false";
+        prompt: string;
+        subject?: string | undefined;
+        learningObjective?: string | undefined;
+        category?: string | undefined;
+        topic?: string | undefined;
+        difficulty?: "easy" | "medium" | "hard" | undefined;
+        bloomLevel?: string | undefined;
+        points?: number | undefined;
+        explanation?: string | undefined;
+        contextCode?: string | undefined;
+        gradeBand?: string | undefined;
+        course?: string | undefined;
+        glossary?: string[] | undefined;
+    } | {
+        id: string;
+        options: {
+            text: string;
+            id: string;
+        }[];
+        correctAnswerId: string;
+        questionType: "multiple_choice";
+        prompt: string;
+        subject?: string | undefined;
+        learningObjective?: string | undefined;
+        category?: string | undefined;
+        topic?: string | undefined;
+        difficulty?: "easy" | "medium" | "hard" | undefined;
+        bloomLevel?: string | undefined;
+        points?: number | undefined;
+        explanation?: string | undefined;
+        contextCode?: string | undefined;
+        gradeBand?: string | undefined;
+        course?: string | undefined;
+        glossary?: string[] | undefined;
+    } | {
+        id: string;
+        questionType: "short_answer";
+        prompt: string;
+        acceptedAnswers: string[];
+        subject?: string | undefined;
+        learningObjective?: string | undefined;
+        category?: string | undefined;
+        topic?: string | undefined;
+        difficulty?: "easy" | "medium" | "hard" | undefined;
+        bloomLevel?: string | undefined;
+        points?: number | undefined;
+        explanation?: string | undefined;
+        contextCode?: string | undefined;
+        gradeBand?: string | undefined;
+        course?: string | undefined;
+        glossary?: string[] | undefined;
+        isCaseSensitive?: boolean | undefined;
+    })[];
+}>;
+export type GenerateQuizFromTextOutput = z.infer<typeof GenerateQuizFromTextOutputSchema>;
+//# sourceMappingURL=generate-quiz-from-text-types.d.ts.map

package/dist/ai/flows/generate-quiz-from-text-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-quiz-from-text-types.d.ts","sourceRoot":"","sources":["../../../src/ai/flows/generate-quiz-from-text-types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;EAK1C,CAAC;AACH,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAY9F,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC"}

package/dist/ai/flows/generate-quiz-from-text.d.ts

@@ -0,0 +1,3 @@
+import { type GenerateQuizFromTextClientInput, type GenerateQuizFromTextOutput } from './generate-quiz-from-text-types';
+export declare function generateQuizFromText(clientInput: GenerateQuizFromTextClientInput, apiKey: string): Promise<GenerateQuizFromTextOutput>;
+//# sourceMappingURL=generate-quiz-from-text.d.ts.map

package/dist/ai/flows/generate-quiz-from-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-quiz-from-text.d.ts","sourceRoot":"","sources":["../../../src/ai/flows/generate-quiz-from-text.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,KAAK,+BAA+B,EACpC,KAAK,0BAA0B,EAEhC,MAAM,iCAAiC,CAAC;AAOzC,wBAAsB,oBAAoB,CACxC,WAAW,EAAE,+BAA+B,EAC5C,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,0BAA0B,CAAC,CAkIrC"}