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

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

@@ -0,0 +1,272 @@
+import { z } from 'zod';
+import type { ImageContextItem } from '../../types/misc';
+import type { QuestionTypeStrings } from '../../types/questions';
+export declare const TopicWithMetadataSchema: z.ZodObject<{
+    topic: z.ZodString;
+    ratio: z.ZodNumber;
+    originalLoId: z.ZodOptional<z.ZodString>;
+    originalSubject: z.ZodOptional<z.ZodString>;
+    originalCategory: z.ZodOptional<z.ZodString>;
+    originalTopic: z.ZodOptional<z.ZodString>;
+    commonMisconceptions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    topic: string;
+    ratio: number;
+    originalLoId?: string | undefined;
+    originalSubject?: string | undefined;
+    originalCategory?: string | undefined;
+    originalTopic?: string | undefined;
+    commonMisconceptions?: string[] | undefined;
+}, {
+    topic: string;
+    ratio: number;
+    originalLoId?: string | undefined;
+    originalSubject?: string | undefined;
+    originalCategory?: string | undefined;
+    originalTopic?: string | undefined;
+    commonMisconceptions?: string[] | undefined;
+}>;
+export type TopicWithMetadata = z.infer<typeof TopicWithMetadataSchema>;
+declare const BloomLevelStringsEnum: z.ZodEnum<["remembering", "understanding", "applying", "analyzing", "evaluating", "creating"]>;
+export type BloomLevelStringsForAI = z.infer<typeof BloomLevelStringsEnum>;
+export declare const GenerateQuizPlanClientInputSchema: z.ZodObject<{
+    language: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    totalQuestions: z.ZodNumber;
+    numCodingQuestions: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    topics: z.ZodArray<z.ZodObject<{
+        topic: z.ZodString;
+        ratio: z.ZodNumber;
+        originalLoId: z.ZodOptional<z.ZodString>;
+        originalSubject: z.ZodOptional<z.ZodString>;
+        originalCategory: z.ZodOptional<z.ZodString>;
+        originalTopic: z.ZodOptional<z.ZodString>;
+        commonMisconceptions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        topic: string;
+        ratio: number;
+        originalLoId?: string | undefined;
+        originalSubject?: string | undefined;
+        originalCategory?: string | undefined;
+        originalTopic?: string | undefined;
+        commonMisconceptions?: string[] | undefined;
+    }, {
+        topic: string;
+        ratio: number;
+        originalLoId?: string | undefined;
+        originalSubject?: string | undefined;
+        originalCategory?: string | undefined;
+        originalTopic?: string | undefined;
+        commonMisconceptions?: string[] | undefined;
+    }>, "many">;
+    bloomLevels: z.ZodArray<z.ZodObject<{
+        level: z.ZodEnum<["remembering", "understanding", "applying", "analyzing", "evaluating", "creating"]>;
+        ratio: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        ratio: number;
+        level: "remembering" | "understanding" | "applying" | "analyzing" | "evaluating" | "creating";
+    }, {
+        ratio: number;
+        level: "remembering" | "understanding" | "applying" | "analyzing" | "evaluating" | "creating";
+    }>, "many">;
+    selectedContextIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    selectedQuestionTypes: z.ZodArray<z.ZodEnum<[QuestionTypeStrings, ...QuestionTypeStrings[]]>, "many">;
+    imageContexts: z.ZodOptional<z.ZodArray<z.ZodType<ImageContextItem, z.ZodTypeDef, ImageContextItem>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    language: string;
+    totalQuestions: number;
+    topics: {
+        topic: string;
+        ratio: number;
+        originalLoId?: string | undefined;
+        originalSubject?: string | undefined;
+        originalCategory?: string | undefined;
+        originalTopic?: string | undefined;
+        commonMisconceptions?: string[] | undefined;
+    }[];
+    numCodingQuestions: number;
+    bloomLevels: {
+        ratio: number;
+        level: "remembering" | "understanding" | "applying" | "analyzing" | "evaluating" | "creating";
+    }[];
+    selectedQuestionTypes: QuestionTypeStrings[];
+    selectedContextIds?: string[] | undefined;
+    imageContexts?: ImageContextItem[] | undefined;
+}, {
+    totalQuestions: number;
+    topics: {
+        topic: string;
+        ratio: number;
+        originalLoId?: string | undefined;
+        originalSubject?: string | undefined;
+        originalCategory?: string | undefined;
+        originalTopic?: string | undefined;
+        commonMisconceptions?: string[] | undefined;
+    }[];
+    bloomLevels: {
+        ratio: number;
+        level: "remembering" | "understanding" | "applying" | "analyzing" | "evaluating" | "creating";
+    }[];
+    selectedQuestionTypes: QuestionTypeStrings[];
+    language?: string | undefined;
+    numCodingQuestions?: number | undefined;
+    selectedContextIds?: string[] | undefined;
+    imageContexts?: ImageContextItem[] | undefined;
+}>;
+export type GenerateQuizPlanClientInput = z.infer<typeof GenerateQuizPlanClientInputSchema>;
+export declare const PlannedQuestionSchema: z.ZodObject<{
+    plannedTopic: z.ZodString;
+    plannedQuestionType: z.ZodEnum<[QuestionTypeStrings, ...QuestionTypeStrings[]]>;
+    plannedBloomLevel: z.ZodEnum<["remembering", "understanding", "applying", "analyzing", "evaluating", "creating"]>;
+    plannedContextId: z.ZodOptional<z.ZodString>;
+    imageId: z.ZodOptional<z.ZodNullable<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>;
+}, "strip", z.ZodTypeAny, {
+    plannedTopic: string;
+    plannedQuestionType: 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;
+}, {
+    plannedTopic: string;
+    plannedQuestionType: 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;
+}>;
+export type PlannedQuestion = z.infer<typeof PlannedQuestionSchema>;
+export declare const GenerateQuizPlanOutputSchema: z.ZodObject<{
+    quizPlan: z.ZodArray<z.ZodObject<{
+        plannedTopic: z.ZodString;
+        plannedQuestionType: z.ZodEnum<[QuestionTypeStrings, ...QuestionTypeStrings[]]>;
+        plannedBloomLevel: z.ZodEnum<["remembering", "understanding", "applying", "analyzing", "evaluating", "creating"]>;
+        plannedContextId: z.ZodOptional<z.ZodString>;
+        imageId: z.ZodOptional<z.ZodNullable<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>;
+    }, "strip", z.ZodTypeAny, {
+        plannedTopic: string;
+        plannedQuestionType: 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;
+    }, {
+        plannedTopic: string;
+        plannedQuestionType: 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">;
+    diversityMetrics: z.ZodOptional<z.ZodObject<{
+        questionTypeDistribution: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        bloomLevelDistribution: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        maxConsecutiveSameType: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        questionTypeDistribution?: Record<string, number> | undefined;
+        bloomLevelDistribution?: Record<string, number> | undefined;
+        maxConsecutiveSameType?: number | undefined;
+    }, {
+        questionTypeDistribution?: Record<string, number> | undefined;
+        bloomLevelDistribution?: Record<string, number> | undefined;
+        maxConsecutiveSameType?: number | undefined;
+    }>>;
+    planningStrategy: z.ZodOptional<z.ZodObject<{
+        overallApproach: z.ZodOptional<z.ZodString>;
+        keyDecisions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        overallApproach?: string | undefined;
+        keyDecisions?: string[] | undefined;
+    }, {
+        overallApproach?: string | undefined;
+        keyDecisions?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    quizPlan: {
+        plannedTopic: string;
+        plannedQuestionType: 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;
+    }[];
+    diversityMetrics?: {
+        questionTypeDistribution?: Record<string, number> | undefined;
+        bloomLevelDistribution?: Record<string, number> | undefined;
+        maxConsecutiveSameType?: number | undefined;
+    } | undefined;
+    planningStrategy?: {
+        overallApproach?: string | undefined;
+        keyDecisions?: string[] | undefined;
+    } | undefined;
+}, {
+    quizPlan: {
+        plannedTopic: string;
+        plannedQuestionType: 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;
+    }[];
+    diversityMetrics?: {
+        questionTypeDistribution?: Record<string, number> | undefined;
+        bloomLevelDistribution?: Record<string, number> | undefined;
+        maxConsecutiveSameType?: number | undefined;
+    } | undefined;
+    planningStrategy?: {
+        overallApproach?: string | undefined;
+        keyDecisions?: string[] | undefined;
+    } | undefined;
+}>;
+export type GenerateQuizPlanOutput = z.infer<typeof GenerateQuizPlanOutputSchema>;
+export {};
+//# sourceMappingURL=generate-quiz-plan-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generate-quiz-plan-types.d.ts","sourceRoot":"","sources":["../../../src/ai/flows/generate-quiz-plan-types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAGjE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;EAQlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAGxE,QAAA,MAAM,qBAAqB,gGAA8F,CAAC;AAC1H,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAW3E,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAY5C,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAG5F,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAahC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAGpE,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC"}

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

@@ -0,0 +1,12 @@
+import { type GenerateQuizPlanClientInput, type GenerateQuizPlanOutput } from './generate-quiz-plan-types';
+interface PlanGenerationLog {
+    timestamp: string;
+    phase: string;
+    data: any;
+    duration?: number;
+}
+export declare function generateQuizPlan(clientInput: GenerateQuizPlanClientInput, apiKey: string, imageContexts?: any[]): Promise<GenerateQuizPlanOutput & {
+    logs: PlanGenerationLog[];
+}>;
+export {};
+//# sourceMappingURL=generate-quiz-plan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generate-quiz-plan.d.ts","sourceRoot":"","sources":["../../../src/ai/flows/generate-quiz-plan.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,KAAK,2BAA2B,EAChC,KAAK,sBAAsB,EAE5B,MAAM,4BAA4B,CAAC;AAMpC,UAAU,iBAAiB;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,GAAG,CAAC;IACV,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAiMD,wBAAsB,gBAAgB,CACpC,WAAW,EAAE,2BAA2B,EACxC,MAAM,EAAE,MAAM,EACd,aAAa,GAAE,GAAG,EAAO,GACxB,OAAO,CAAC,sBAAsB,GAAG;IAAE,IAAI,EAAE,iBAAiB,EAAE,CAAA;CAAE,CAAC,CA6RjE"}

package/dist/ai/flows/generate-quiz-review.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"generate-quiz-review.d.ts","sourceRoot":"","sources":["../../../src/ai/flows/generate-quiz-review.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,KAAK,6BAA6B,EAClC,KAAK,wBAAwB,EAE9B,MAAM,gBAAgB,CAAC;AAOxB,wBAAsB,kBAAkB,CACtC,WAAW,EAAE,6BAA6B,EAC1C,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,wBAAwB,CAAC,CA8DnC"}

package/dist/ai/flows/generate-single-knowledge-card-types.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import type { KnowledgeCard } from '../../types/misc';
+export declare const GenerateSingleKnowledgeCardInputSchema: z.ZodObject<{
+    language: z.ZodString;
+    concept: z.ZodString;
+    overallSubject: z.ZodString;
+    fullContext: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    concept: string;
+    language: string;
+    overallSubject: string;
+    fullContext?: string | undefined;
+}, {
+    concept: string;
+    language: string;
+    overallSubject: string;
+    fullContext?: string | undefined;
+}>;
+export type GenerateSingleKnowledgeCardClientInput = z.infer<typeof GenerateSingleKnowledgeCardInputSchema>;
+export declare const GenerateSingleKnowledgeCardOutputSchema: z.ZodObject<{
+    concept: z.ZodString;
+    definition: z.ZodString;
+    example: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    concept: string;
+    definition: string;
+    example: string;
+}, {
+    concept: string;
+    definition: string;
+    example: string;
+}>;
+export type GenerateSingleKnowledgeCardOutput = Omit<KnowledgeCard, 'id'>;
+//# sourceMappingURL=generate-single-knowledge-card-types.d.ts.map

package/dist/ai/flows/generate-single-knowledge-card-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-single-knowledge-card-types.d.ts","sourceRoot":"","sources":["../../../src/ai/flows/generate-single-knowledge-card-types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;EAKjD,CAAC;AACH,MAAM,MAAM,sCAAsC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sCAAsC,CAAC,CAAC;AAE5G,eAAO,MAAM,uCAAuC;;;;;;;;;;;;EAIlD,CAAC;AACH,MAAM,MAAM,iCAAiC,GAAG,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC"}

package/dist/ai/flows/generate-single-knowledge-card.d.ts

@@ -0,0 +1,3 @@
+import { type GenerateSingleKnowledgeCardClientInput, type GenerateSingleKnowledgeCardOutput } from './generate-single-knowledge-card-types';
+export declare function generateSingleKnowledgeCard(clientInput: GenerateSingleKnowledgeCardClientInput, apiKey: string): Promise<GenerateSingleKnowledgeCardOutput>;
+//# sourceMappingURL=generate-single-knowledge-card.d.ts.map

package/dist/ai/flows/generate-single-knowledge-card.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-single-knowledge-card.d.ts","sourceRoot":"","sources":["../../../src/ai/flows/generate-single-knowledge-card.ts"],"names":[],"mappings":"AASA,OAAO,EACL,KAAK,sCAAsC,EAC3C,KAAK,iCAAiC,EAEvC,MAAM,wCAAwC,CAAC;AAwChD,wBAAsB,2BAA2B,CAC/C,WAAW,EAAE,sCAAsC,EACnD,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,iCAAiC,CAAC,CA0C5C"}

package/dist/ai/flows/motivational-quote-types.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const GenerateMotivationalQuoteInputSchema: z.ZodObject<{
+    language: z.ZodString;
+    userName: z.ZodOptional<z.ZodString>;
+    currentStreak: z.ZodOptional<z.ZodNumber>;
+    weakestTopic: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    language: string;
+    userName?: string | undefined;
+    currentStreak?: number | undefined;
+    weakestTopic?: string | undefined;
+}, {
+    language: string;
+    userName?: string | undefined;
+    currentStreak?: number | undefined;
+    weakestTopic?: string | undefined;
+}>;
+export type GenerateMotivationalQuoteClientInput = z.infer<typeof GenerateMotivationalQuoteInputSchema>;
+export declare const GenerateMotivationalQuoteOutputSchema: z.ZodObject<{
+    text: z.ZodString;
+    author: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    author: string;
+}, {
+    text: string;
+    author: string;
+}>;
+export type GenerateMotivationalQuoteOutput = z.infer<typeof GenerateMotivationalQuoteOutputSchema>;
+//# sourceMappingURL=motivational-quote-types.d.ts.map

package/dist/ai/flows/motivational-quote-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"motivational-quote-types.d.ts","sourceRoot":"","sources":["../../../src/ai/flows/motivational-quote-types.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;EAK/C,CAAC;AACH,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAC;AAExG,eAAO,MAAM,qCAAqC;;;;;;;;;EAGhD,CAAC;AACH,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAC"}

package/dist/ai/flows/plan-knowledge-cards-types.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export declare const PlanKnowledgeCardsInputSchema: z.ZodObject<{
+    language: z.ZodString;
+    learningObjectivesContent: z.ZodString;
+    overallSubject: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    language: string;
+    learningObjectivesContent: string;
+    overallSubject: string;
+}, {
+    language: string;
+    learningObjectivesContent: string;
+    overallSubject: string;
+}>;
+export type PlanKnowledgeCardsClientInput = z.infer<typeof PlanKnowledgeCardsInputSchema>;
+export declare const PlanKnowledgeCardsOutputSchema: z.ZodObject<{
+    concepts: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    concepts: string[];
+}, {
+    concepts: string[];
+}>;
+export type PlanKnowledgeCardsOutput = z.infer<typeof PlanKnowledgeCardsOutputSchema>;
+//# sourceMappingURL=plan-knowledge-cards-types.d.ts.map

package/dist/ai/flows/plan-knowledge-cards-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-knowledge-cards-types.d.ts","sourceRoot":"","sources":["../../../src/ai/flows/plan-knowledge-cards-types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,6BAA6B;;;;;;;;;;;;EAIxC,CAAC;AACH,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAE1F,eAAO,MAAM,8BAA8B;;;;;;EAEzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC"}

package/dist/ai/flows/plan-knowledge-cards.d.ts

@@ -0,0 +1,3 @@
+import { type PlanKnowledgeCardsClientInput, type PlanKnowledgeCardsOutput } from './plan-knowledge-cards-types';
+export declare function planKnowledgeCards(clientInput: PlanKnowledgeCardsClientInput, apiKey: string): Promise<PlanKnowledgeCardsOutput>;
+//# sourceMappingURL=plan-knowledge-cards.d.ts.map

package/dist/ai/flows/plan-knowledge-cards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-knowledge-cards.d.ts","sourceRoot":"","sources":["../../../src/ai/flows/plan-knowledge-cards.ts"],"names":[],"mappings":"AASA,OAAO,EACL,KAAK,6BAA6B,EAClC,KAAK,wBAAwB,EAE9B,MAAM,8BAA8B,CAAC;AAGtC,wBAAsB,kBAAkB,CACtC,WAAW,EAAE,6BAA6B,EAC1C,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,wBAAwB,CAAC,CAsDnC"}

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

@@ -0,0 +1,133 @@
+import { z } from 'zod';
+import type { CodingQuestion } from '../../..';
+export declare const GenerateCodingQuestionClientInputSchema: 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>;
+} & {
+    codingLanguage: z.ZodEnum<["cpp", "javascript", "python", "swift", "csharp"]>;
+}, "strip", z.ZodTypeAny, {
+    language: string;
+    difficulty: "easy" | "medium" | "hard";
+    codingLanguage: "cpp" | "javascript" | "python" | "swift" | "csharp";
+    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";
+    codingLanguage: "cpp" | "javascript" | "python" | "swift" | "csharp";
+    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;
+}>;
+export type GenerateCodingQuestionClientInput = z.infer<typeof GenerateCodingQuestionClientInputSchema>;
+export declare const AICodingQuestionOutputSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    functionSignature: z.ZodOptional<z.ZodString>;
+    solutionCode: z.ZodString;
+    testCases: z.ZodArray<z.ZodObject<{
+        input: z.ZodArray<z.ZodAny, "many">;
+        expectedOutput: z.ZodEffects<z.ZodAny, any, any>;
+        isPublic: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        input: any[];
+        isPublic: boolean;
+        expectedOutput?: any;
+    }, {
+        input: any[];
+        isPublic: boolean;
+        expectedOutput?: any;
+    }>, "many">;
+    verifiedCodingLanguage: z.ZodOptional<z.ZodEnum<["cpp", "javascript", "python", "swift", "csharp"]>>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    solutionCode: string;
+    testCases: {
+        input: any[];
+        isPublic: boolean;
+        expectedOutput?: any;
+    }[];
+    functionSignature?: string | undefined;
+    verifiedCodingLanguage?: "cpp" | "javascript" | "python" | "swift" | "csharp" | undefined;
+}, {
+    prompt: string;
+    solutionCode: string;
+    testCases: {
+        input: any[];
+        isPublic: boolean;
+        expectedOutput?: any;
+    }[];
+    functionSignature?: string | undefined;
+    verifiedCodingLanguage?: "cpp" | "javascript" | "python" | "swift" | "csharp" | undefined;
+}>;
+export type AICodingQuestionOutput = z.infer<typeof AICodingQuestionOutputSchema>;
+export type GenerateCodingQuestionOutput = {
+    question?: CodingQuestion;
+    error?: string;
+};
+//# sourceMappingURL=generate-coding-question-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generate-coding-question-types.d.ts","sourceRoot":"","sources":["../../../../src/ai/flows/question-gen/generate-coding-question-types.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,cAAc,EAA2B,MAAM,UAAU,CAAC;AAGxE,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAElD,CAAC;AACH,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uCAAuC,CAAC,CAAC;AAExG,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAavC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF,MAAM,MAAM,4BAA4B,GAAG;IACvC,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"generate-coding-question.d.ts","sourceRoot":"","sources":["../../../../src/ai/flows/question-gen/generate-coding-question.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,KAAK,iCAAiC,EACtC,KAAK,4BAA4B,EAElC,MAAM,kCAAkC,CAAC;AAgE1C,wBAAsB,sBAAsB,CAC1C,WAAW,EAAE,iCAAiC,EAC9C,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,4BAA4B,CAAC,CA6GvC"}