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

package/dist/ai/flows/question-gen/generate-fitb-question-types.d.ts

@@ -0,0 +1,142 @@
+import { z } from 'zod';
+import type { FillInTheBlanksQuestion } from '../../..';
+export declare const GenerateFillInTheBlanksQuestionClientInputSchema: z.ZodObject<{
+    language: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    difficulty: z.ZodEnum<["easy", "medium", "hard"]>;
+    quizContext: z.ZodOptional<z.ZodObject<{
+        plannedTopic: z.ZodOptional<z.ZodString>;
+        plannedQuestionType: z.ZodOptional<z.ZodString>;
+        plannedBloomLevel: z.ZodOptional<z.ZodString>;
+        plannedContextId: z.ZodOptional<z.ZodString>;
+        targetMisconception: z.ZodOptional<z.ZodString>;
+        difficultyReason: z.ZodOptional<z.ZodString>;
+        topicSpecificity: z.ZodOptional<z.ZodEnum<["broad", "focused", "specific"]>>;
+        originalLoId: z.ZodOptional<z.ZodString>;
+        originalSubject: z.ZodOptional<z.ZodString>;
+        originalCategory: z.ZodOptional<z.ZodString>;
+        originalTopic: z.ZodOptional<z.ZodString>;
+        loDescription: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        plannedTopic?: string | undefined;
+        plannedQuestionType?: string | undefined;
+        plannedBloomLevel?: string | undefined;
+        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;
+        loDescription?: string | undefined;
+    }, {
+        plannedTopic?: string | undefined;
+        plannedQuestionType?: string | undefined;
+        plannedBloomLevel?: string | undefined;
+        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;
+        loDescription?: string | undefined;
+    }>>;
+    imageUrl: z.ZodOptional<z.ZodString>;
+} & {
+    numberOfBlanks: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    isCaseSensitive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    language: string;
+    difficulty: "easy" | "medium" | "hard";
+    isCaseSensitive: boolean;
+    numberOfBlanks: number;
+    quizContext?: {
+        plannedTopic?: string | undefined;
+        plannedQuestionType?: string | undefined;
+        plannedBloomLevel?: string | undefined;
+        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;
+        loDescription?: string | undefined;
+    } | undefined;
+    imageUrl?: string | undefined;
+}, {
+    difficulty: "easy" | "medium" | "hard";
+    language?: string | undefined;
+    quizContext?: {
+        plannedTopic?: string | undefined;
+        plannedQuestionType?: string | undefined;
+        plannedBloomLevel?: string | undefined;
+        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;
+        loDescription?: string | undefined;
+    } | undefined;
+    imageUrl?: string | undefined;
+    isCaseSensitive?: boolean | undefined;
+    numberOfBlanks?: number | undefined;
+}>;
+export type GenerateFillInTheBlanksQuestionClientInput = z.infer<typeof GenerateFillInTheBlanksQuestionClientInputSchema>;
+export declare const AIFillInTheBlanksOutputFieldsSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    segments: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["text", "blank"]>;
+        content: z.ZodOptional<z.ZodString>;
+        acceptedAnswers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        type: "text" | "blank";
+        acceptedAnswers?: string[] | undefined;
+        content?: string | undefined;
+    }, {
+        type: "text" | "blank";
+        acceptedAnswers?: string[] | undefined;
+        content?: string | undefined;
+    }>, "many">;
+    explanation: z.ZodOptional<z.ZodString>;
+    points: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    difficulty: z.ZodOptional<z.ZodEnum<["easy", "medium", "hard"]>>;
+    topic: z.ZodOptional<z.ZodString>;
+    verifiedCategory: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    points: number;
+    segments: {
+        type: "text" | "blank";
+        acceptedAnswers?: string[] | undefined;
+        content?: string | undefined;
+    }[];
+    topic?: string | undefined;
+    difficulty?: "easy" | "medium" | "hard" | undefined;
+    explanation?: string | undefined;
+    verifiedCategory?: string | undefined;
+}, {
+    prompt: string;
+    segments: {
+        type: "text" | "blank";
+        acceptedAnswers?: string[] | undefined;
+        content?: string | undefined;
+    }[];
+    topic?: string | undefined;
+    difficulty?: "easy" | "medium" | "hard" | undefined;
+    points?: number | undefined;
+    explanation?: string | undefined;
+    verifiedCategory?: string | undefined;
+}>;
+export type AIFillInTheBlanksOutputFields = z.infer<typeof AIFillInTheBlanksOutputFieldsSchema>;
+export type GenerateFillInTheBlanksQuestionOutput = {
+    question?: FillInTheBlanksQuestion;
+    error?: string;
+};
+//# sourceMappingURL=generate-fitb-question-types.d.ts.map

package/dist/ai/flows/question-gen/generate-fitb-question-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-fitb-question-types.d.ts","sourceRoot":"","sources":["../../../../src/ai/flows/question-gen/generate-fitb-question-types.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAOxD,eAAO,MAAM,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG3D,CAAC;AACH,MAAM,MAAM,0CAA0C,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gDAAgD,CAAC,CAAC;AAK1H,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa9C,CAAC;AACH,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAC;AAKhG,MAAM,MAAM,qCAAqC,GAAG;IAChD,QAAQ,CAAC,EAAE,uBAAuB,CAAC;IACnC,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC"}

package/dist/ai/flows/question-gen/generate-fitb-question.d.ts

@@ -0,0 +1,3 @@
+import { type GenerateFillInTheBlanksQuestionClientInput, type GenerateFillInTheBlanksQuestionOutput } from './generate-fitb-question-types';
+export declare function generateFillInTheBlanksQuestion(clientInput: GenerateFillInTheBlanksQuestionClientInput, apiKey: string): Promise<GenerateFillInTheBlanksQuestionOutput>;
+//# sourceMappingURL=generate-fitb-question.d.ts.map

package/dist/ai/flows/question-gen/generate-fitb-question.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-fitb-question.d.ts","sourceRoot":"","sources":["../../../../src/ai/flows/question-gen/generate-fitb-question.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,KAAK,0CAA0C,EAC/C,KAAK,qCAAqC,EAE3C,MAAM,gCAAgC,CAAC;AA2ExC,wBAAsB,+BAA+B,CACnD,WAAW,EAAE,0CAA0C,EACvD,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,qCAAqC,CAAC,CA+HhD"}

package/dist/ai/flows/question-gen/generate-matching-question-types.d.ts

@@ -0,0 +1,137 @@
+import { z } from 'zod';
+import type { MatchingQuestion } from '../../..';
+export declare const GenerateMatchingQuestionClientInputSchema: z.ZodObject<{
+    language: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    difficulty: z.ZodEnum<["easy", "medium", "hard"]>;
+    quizContext: z.ZodOptional<z.ZodObject<{
+        plannedTopic: z.ZodOptional<z.ZodString>;
+        plannedQuestionType: z.ZodOptional<z.ZodString>;
+        plannedBloomLevel: z.ZodOptional<z.ZodString>;
+        plannedContextId: z.ZodOptional<z.ZodString>;
+        targetMisconception: z.ZodOptional<z.ZodString>;
+        difficultyReason: z.ZodOptional<z.ZodString>;
+        topicSpecificity: z.ZodOptional<z.ZodEnum<["broad", "focused", "specific"]>>;
+        originalLoId: z.ZodOptional<z.ZodString>;
+        originalSubject: z.ZodOptional<z.ZodString>;
+        originalCategory: z.ZodOptional<z.ZodString>;
+        originalTopic: z.ZodOptional<z.ZodString>;
+        loDescription: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        plannedTopic?: string | undefined;
+        plannedQuestionType?: string | undefined;
+        plannedBloomLevel?: string | undefined;
+        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;
+        loDescription?: string | undefined;
+    }, {
+        plannedTopic?: string | undefined;
+        plannedQuestionType?: string | undefined;
+        plannedBloomLevel?: string | undefined;
+        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;
+        loDescription?: string | undefined;
+    }>>;
+    imageUrl: z.ZodOptional<z.ZodString>;
+} & {
+    numberOfPairs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    shuffleOptions: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    language: string;
+    difficulty: "easy" | "medium" | "hard";
+    shuffleOptions: boolean;
+    numberOfPairs: number;
+    quizContext?: {
+        plannedTopic?: string | undefined;
+        plannedQuestionType?: string | undefined;
+        plannedBloomLevel?: string | undefined;
+        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;
+        loDescription?: string | undefined;
+    } | undefined;
+    imageUrl?: string | undefined;
+}, {
+    difficulty: "easy" | "medium" | "hard";
+    language?: string | undefined;
+    shuffleOptions?: boolean | undefined;
+    quizContext?: {
+        plannedTopic?: string | undefined;
+        plannedQuestionType?: string | undefined;
+        plannedBloomLevel?: string | undefined;
+        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;
+        loDescription?: string | undefined;
+    } | undefined;
+    imageUrl?: string | undefined;
+    numberOfPairs?: number | undefined;
+}>;
+export type GenerateMatchingQuestionClientInput = z.infer<typeof GenerateMatchingQuestionClientInputSchema>;
+export declare const AIMatchingOutputFieldsSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    correctPairs: z.ZodArray<z.ZodObject<{
+        promptText: z.ZodString;
+        optionText: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        promptText: string;
+        optionText: string;
+    }, {
+        promptText: string;
+        optionText: string;
+    }>, "many">;
+    explanation: z.ZodOptional<z.ZodString>;
+    points: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    difficulty: z.ZodOptional<z.ZodEnum<["easy", "medium", "hard"]>>;
+    topic: z.ZodOptional<z.ZodString>;
+    verifiedCategory: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    points: number;
+    correctPairs: {
+        promptText: string;
+        optionText: string;
+    }[];
+    topic?: string | undefined;
+    difficulty?: "easy" | "medium" | "hard" | undefined;
+    explanation?: string | undefined;
+    verifiedCategory?: string | undefined;
+}, {
+    prompt: string;
+    correctPairs: {
+        promptText: string;
+        optionText: string;
+    }[];
+    topic?: string | undefined;
+    difficulty?: "easy" | "medium" | "hard" | undefined;
+    points?: number | undefined;
+    explanation?: string | undefined;
+    verifiedCategory?: string | undefined;
+}>;
+export type AIMatchingOutputFields = z.infer<typeof AIMatchingOutputFieldsSchema>;
+export type GenerateMatchingQuestionOutput = {
+    question?: MatchingQuestion;
+    error?: string;
+};
+//# sourceMappingURL=generate-matching-question-types.d.ts.map

package/dist/ai/flows/question-gen/generate-matching-question-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-matching-question-types.d.ts","sourceRoot":"","sources":["../../../../src/ai/flows/question-gen/generate-matching-question-types.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAOjD,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGpD,CAAC;AACH,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yCAAyC,CAAC,CAAC;AAM5G,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAMlF,MAAM,MAAM,8BAA8B,GAAG;IACzC,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC"}

package/dist/ai/flows/question-gen/generate-matching-question.d.ts

@@ -0,0 +1,3 @@
+import { type GenerateMatchingQuestionClientInput, type GenerateMatchingQuestionOutput } from './generate-matching-question-types';
+export declare function generateMatchingQuestion(clientInput: GenerateMatchingQuestionClientInput, apiKey: string): Promise<GenerateMatchingQuestionOutput>;
+//# sourceMappingURL=generate-matching-question.d.ts.map

package/dist/ai/flows/question-gen/generate-matching-question.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-matching-question.d.ts","sourceRoot":"","sources":["../../../../src/ai/flows/question-gen/generate-matching-question.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,KAAK,mCAAmC,EACxC,KAAK,8BAA8B,EAEpC,MAAM,oCAAoC,CAAC;AA2E5C,wBAAsB,wBAAwB,CAC5C,WAAW,EAAE,mCAAmC,EAChD,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,8BAA8B,CAAC,CAsHzC"}

package/dist/ai/flows/question-gen/generate-mcq-question-types.d.ts

@@ -0,0 +1,137 @@
+import { z } from 'zod';
+import type { MultipleChoiceQuestion } from '../../..';
+export declare const GenerateMCQQuestionClientInputSchema: z.ZodObject<{
+    language: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    difficulty: z.ZodEnum<["easy", "medium", "hard"]>;
+    quizContext: z.ZodOptional<z.ZodObject<{
+        plannedTopic: z.ZodOptional<z.ZodString>;
+        plannedQuestionType: z.ZodOptional<z.ZodString>;
+        plannedBloomLevel: z.ZodOptional<z.ZodString>;
+        plannedContextId: z.ZodOptional<z.ZodString>;
+        targetMisconception: z.ZodOptional<z.ZodString>;
+        difficultyReason: z.ZodOptional<z.ZodString>;
+        topicSpecificity: z.ZodOptional<z.ZodEnum<["broad", "focused", "specific"]>>;
+        originalLoId: z.ZodOptional<z.ZodString>;
+        originalSubject: z.ZodOptional<z.ZodString>;
+        originalCategory: z.ZodOptional<z.ZodString>;
+        originalTopic: z.ZodOptional<z.ZodString>;
+        loDescription: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        plannedTopic?: string | undefined;
+        plannedQuestionType?: string | undefined;
+        plannedBloomLevel?: string | undefined;
+        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;
+        loDescription?: string | undefined;
+    }, {
+        plannedTopic?: string | undefined;
+        plannedQuestionType?: string | undefined;
+        plannedBloomLevel?: string | undefined;
+        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;
+        loDescription?: string | undefined;
+    }>>;
+    imageUrl: z.ZodOptional<z.ZodString>;
+} & {
+    numberOfOptions: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    language: string;
+    difficulty: "easy" | "medium" | "hard";
+    numberOfOptions: number;
+    quizContext?: {
+        plannedTopic?: string | undefined;
+        plannedQuestionType?: string | undefined;
+        plannedBloomLevel?: string | undefined;
+        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;
+        loDescription?: string | undefined;
+    } | undefined;
+    imageUrl?: string | undefined;
+}, {
+    difficulty: "easy" | "medium" | "hard";
+    language?: string | undefined;
+    quizContext?: {
+        plannedTopic?: string | undefined;
+        plannedQuestionType?: string | undefined;
+        plannedBloomLevel?: string | undefined;
+        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;
+        loDescription?: string | undefined;
+    } | undefined;
+    imageUrl?: string | undefined;
+    numberOfOptions?: number | undefined;
+}>;
+export type GenerateMCQQuestionClientInput = z.infer<typeof GenerateMCQQuestionClientInputSchema>;
+export declare const AIMCQOutputFieldsSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    options: z.ZodArray<z.ZodObject<{
+        tempId: z.ZodString;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        text: string;
+        tempId: string;
+    }, {
+        text: string;
+        tempId: string;
+    }>, "many">;
+    correctTempOptionId: z.ZodString;
+    explanation: z.ZodOptional<z.ZodString>;
+    points: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    difficulty: z.ZodOptional<z.ZodEnum<["easy", "medium", "hard"]>>;
+    topic: z.ZodOptional<z.ZodString>;
+    verifiedCategory: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    options: {
+        text: string;
+        tempId: string;
+    }[];
+    prompt: string;
+    points: number;
+    correctTempOptionId: string;
+    topic?: string | undefined;
+    difficulty?: "easy" | "medium" | "hard" | undefined;
+    explanation?: string | undefined;
+    verifiedCategory?: string | undefined;
+}, {
+    options: {
+        text: string;
+        tempId: string;
+    }[];
+    prompt: string;
+    correctTempOptionId: string;
+    topic?: string | undefined;
+    difficulty?: "easy" | "medium" | "hard" | undefined;
+    points?: number | undefined;
+    explanation?: string | undefined;
+    verifiedCategory?: string | undefined;
+}>;
+export type AIMCQOutputFields = z.infer<typeof AIMCQOutputFieldsSchema>;
+export type GenerateMCQQuestionOutput = {
+    question?: MultipleChoiceQuestion;
+    error?: string;
+};
+//# sourceMappingURL=generate-mcq-question-types.d.ts.map

package/dist/ai/flows/question-gen/generate-mcq-question-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-mcq-question-types.d.ts","sourceRoot":"","sources":["../../../../src/ai/flows/question-gen/generate-mcq-question-types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAOvD,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE/C,CAAC;AACH,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAC;AAMlG,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAclC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAMxE,MAAM,MAAM,yBAAyB,GAAG;IACpC,QAAQ,CAAC,EAAE,sBAAsB,CAAC;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC"}

package/dist/ai/flows/question-gen/generate-mcq-question.d.ts

@@ -0,0 +1,3 @@
+import { type GenerateMCQQuestionClientInput, type GenerateMCQQuestionOutput } from './generate-mcq-question-types';
+export declare function generateMCQQuestion(clientInput: GenerateMCQQuestionClientInput, apiKey: string): Promise<GenerateMCQQuestionOutput>;
+//# sourceMappingURL=generate-mcq-question.d.ts.map

package/dist/ai/flows/question-gen/generate-mcq-question.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-mcq-question.d.ts","sourceRoot":"","sources":["../../../../src/ai/flows/question-gen/generate-mcq-question.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,KAAK,8BAA8B,EACnC,KAAK,yBAAyB,EAE/B,MAAM,+BAA+B,CAAC;AA+EvC,wBAAsB,mBAAmB,CACvC,WAAW,EAAE,8BAA8B,EAC3C,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,yBAAyB,CAAC,CAuHpC"}

package/dist/ai/flows/question-gen/generate-mrq-question-types.d.ts

@@ -0,0 +1,143 @@
+import { z } from 'zod';
+import type { MultipleResponseQuestion } from '../../..';
+export declare const GenerateMRQQuestionClientInputSchema: z.ZodObject<{
+    language: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    difficulty: z.ZodEnum<["easy", "medium", "hard"]>;
+    quizContext: z.ZodOptional<z.ZodObject<{
+        plannedTopic: z.ZodOptional<z.ZodString>;
+        plannedQuestionType: z.ZodOptional<z.ZodString>;
+        plannedBloomLevel: z.ZodOptional<z.ZodString>;
+        plannedContextId: z.ZodOptional<z.ZodString>;
+        targetMisconception: z.ZodOptional<z.ZodString>;
+        difficultyReason: z.ZodOptional<z.ZodString>;
+        topicSpecificity: z.ZodOptional<z.ZodEnum<["broad", "focused", "specific"]>>;
+        originalLoId: z.ZodOptional<z.ZodString>;
+        originalSubject: z.ZodOptional<z.ZodString>;
+        originalCategory: z.ZodOptional<z.ZodString>;
+        originalTopic: z.ZodOptional<z.ZodString>;
+        loDescription: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        plannedTopic?: string | undefined;
+        plannedQuestionType?: string | undefined;
+        plannedBloomLevel?: string | undefined;
+        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;
+        loDescription?: string | undefined;
+    }, {
+        plannedTopic?: string | undefined;
+        plannedQuestionType?: string | undefined;
+        plannedBloomLevel?: string | undefined;
+        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;
+        loDescription?: string | undefined;
+    }>>;
+    imageUrl: z.ZodOptional<z.ZodString>;
+} & {
+    numberOfOptions: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    minCorrectAnswers: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    maxCorrectAnswers: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    language: string;
+    difficulty: "easy" | "medium" | "hard";
+    numberOfOptions: number;
+    minCorrectAnswers: number;
+    maxCorrectAnswers: number;
+    quizContext?: {
+        plannedTopic?: string | undefined;
+        plannedQuestionType?: string | undefined;
+        plannedBloomLevel?: string | undefined;
+        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;
+        loDescription?: string | undefined;
+    } | undefined;
+    imageUrl?: string | undefined;
+}, {
+    difficulty: "easy" | "medium" | "hard";
+    language?: string | undefined;
+    quizContext?: {
+        plannedTopic?: string | undefined;
+        plannedQuestionType?: string | undefined;
+        plannedBloomLevel?: string | undefined;
+        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;
+        loDescription?: string | undefined;
+    } | undefined;
+    imageUrl?: string | undefined;
+    numberOfOptions?: number | undefined;
+    minCorrectAnswers?: number | undefined;
+    maxCorrectAnswers?: number | undefined;
+}>;
+export type GenerateMRQQuestionClientInput = z.infer<typeof GenerateMRQQuestionClientInputSchema>;
+export declare const AIMRQOutputFieldsSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    options: z.ZodArray<z.ZodObject<{
+        tempId: z.ZodString;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        text: string;
+        tempId: string;
+    }, {
+        text: string;
+        tempId: string;
+    }>, "many">;
+    correctTempOptionIds: z.ZodArray<z.ZodString, "many">;
+    explanation: z.ZodOptional<z.ZodString>;
+    points: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    difficulty: z.ZodOptional<z.ZodEnum<["easy", "medium", "hard"]>>;
+    topic: z.ZodOptional<z.ZodString>;
+    verifiedCategory: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    options: {
+        text: string;
+        tempId: string;
+    }[];
+    prompt: string;
+    points: number;
+    correctTempOptionIds: string[];
+    topic?: string | undefined;
+    difficulty?: "easy" | "medium" | "hard" | undefined;
+    explanation?: string | undefined;
+    verifiedCategory?: string | undefined;
+}, {
+    options: {
+        text: string;
+        tempId: string;
+    }[];
+    prompt: string;
+    correctTempOptionIds: string[];
+    topic?: string | undefined;
+    difficulty?: "easy" | "medium" | "hard" | undefined;
+    points?: number | undefined;
+    explanation?: string | undefined;
+    verifiedCategory?: string | undefined;
+}>;
+export type AIMRQOutputFields = z.infer<typeof AIMRQOutputFieldsSchema>;
+export type GenerateMRQQuestionOutput = {
+    question?: MultipleResponseQuestion;
+    error?: string;
+};
+//# sourceMappingURL=generate-mrq-question-types.d.ts.map

package/dist/ai/flows/question-gen/generate-mrq-question-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-mrq-question-types.d.ts","sourceRoot":"","sources":["../../../../src/ai/flows/question-gen/generate-mrq-question-types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAOzD,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI/C,CAAC;AACH,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAC;AAMlG,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAMxE,MAAM,MAAM,yBAAyB,GAAG;IACpC,QAAQ,CAAC,EAAE,wBAAwB,CAAC;IACpC,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC"}

package/dist/ai/flows/question-gen/generate-mrq-question.d.ts

@@ -0,0 +1,3 @@
+import { type GenerateMRQQuestionClientInput, type GenerateMRQQuestionOutput } from './generate-mrq-question-types';
+export declare function generateMRQQuestion(clientInput: GenerateMRQQuestionClientInput, apiKey: string): Promise<GenerateMRQQuestionOutput>;
+//# sourceMappingURL=generate-mrq-question.d.ts.map

package/dist/ai/flows/question-gen/generate-mrq-question.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-mrq-question.d.ts","sourceRoot":"","sources":["../../../../src/ai/flows/question-gen/generate-mrq-question.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,KAAK,8BAA8B,EACnC,KAAK,yBAAyB,EAE/B,MAAM,+BAA+B,CAAC;AAgFvC,wBAAsB,mBAAmB,CACvC,WAAW,EAAE,8BAA8B,EAC3C,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,yBAAyB,CAAC,CA0IpC"}