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

package/dist/ai/dev.d.ts

@@ -0,0 +1,16 @@
+import './flows/question-gen/generate-true-false-question';
+import './flows/question-gen/generate-mcq-question';
+import './flows/question-gen/generate-mrq-question';
+import './flows/question-gen/generate-short-answer-question';
+import './flows/question-gen/generate-numeric-question';
+import './flows/question-gen/generate-fitb-question';
+import './flows/question-gen/generate-sequence-question';
+import './flows/question-gen/generate-matching-question';
+import './flows/generate-quiz-plan';
+import './flows/generate-questions-from-quiz-plan';
+import './flows/generate-quiz-review';
+import './flows/generate-practice-suggestion';
+import './flows/generate-motivational-quote';
+import './flows/plan-knowledge-cards';
+import './flows/generate-single-knowledge-card';
+//# sourceMappingURL=dev.d.ts.map

package/dist/ai/dev.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/ai/dev.ts"],"names":[],"mappings":"AAMA,OAAO,mDAAmD,CAAC;AAC3D,OAAO,4CAA4C,CAAC;AACpD,OAAO,4CAA4C,CAAC;AACpD,OAAO,qDAAqD,CAAC;AAC7D,OAAO,gDAAgD,CAAC;AACxD,OAAO,6CAA6C,CAAC;AACrD,OAAO,iDAAiD,CAAC;AACzD,OAAO,iDAAiD,CAAC;AACzD,OAAO,4BAA4B,CAAC;AACpC,OAAO,2CAA2C,CAAC;AACnD,OAAO,8BAA8B,CAAC;AACtC,OAAO,sCAAsC,CAAC;AAC9C,OAAO,qCAAqC,CAAC;AAC7C,OAAO,8BAA8B,CAAC;AACtC,OAAO,wCAAwC,CAAC"}

package/dist/ai/flows/ask-tutor-chat-types.d.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+export declare const AskTutorChatInputSchema: z.ZodObject<{
+    language: z.ZodDefault<z.ZodString>;
+    currentQuestion: z.ZodString;
+    chatHistory: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodEnum<["user", "assistant"]>;
+        content: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        content: string;
+        role: "user" | "assistant";
+    }, {
+        id: string;
+        content: string;
+        role: "user" | "assistant";
+    }>, "many">;
+    knowledgeContext: z.ZodOptional<z.ZodArray<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;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    language: string;
+    currentQuestion: string;
+    chatHistory: {
+        id: string;
+        content: string;
+        role: "user" | "assistant";
+    }[];
+    knowledgeContext?: {
+        concept: string;
+        definition: string;
+        example: string;
+    }[] | undefined;
+}, {
+    currentQuestion: string;
+    chatHistory: {
+        id: string;
+        content: string;
+        role: "user" | "assistant";
+    }[];
+    language?: string | undefined;
+    knowledgeContext?: {
+        concept: string;
+        definition: string;
+        example: string;
+    }[] | undefined;
+}>;
+export type AskTutorChatClientInput = z.infer<typeof AskTutorChatInputSchema>;
+export declare const AskTutorChatOutputSchema: z.ZodObject<{
+    response: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    response: string;
+}, {
+    response: string;
+}>;
+export type AskTutorChatOutput = z.infer<typeof AskTutorChatOutputSchema>;
+//# sourceMappingURL=ask-tutor-chat-types.d.ts.map

package/dist/ai/flows/ask-tutor-chat-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ask-tutor-chat-types.d.ts","sourceRoot":"","sources":["../../../src/ai/flows/ask-tutor-chat-types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgBxB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKlC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAG9E,eAAO,MAAM,wBAAwB;;;;;;EAEnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/ai/flows/ask-tutor-chat.d.ts

@@ -0,0 +1,3 @@
+import { type AskTutorChatClientInput, type AskTutorChatOutput } from './ask-tutor-chat-types';
+export declare function askTutorChat(clientInput: AskTutorChatClientInput, apiKey: string): Promise<AskTutorChatOutput>;
+//# sourceMappingURL=ask-tutor-chat.d.ts.map

package/dist/ai/flows/ask-tutor-chat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ask-tutor-chat.d.ts","sourceRoot":"","sources":["../../../src/ai/flows/ask-tutor-chat.ts"],"names":[],"mappings":"AASA,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,kBAAkB,EAExB,MAAM,wBAAwB,CAAC;AAEhC,wBAAsB,YAAY,CAChC,WAAW,EAAE,uBAAuB,EACpC,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,kBAAkB,CAAC,CAyD7B"}

package/dist/ai/flows/assess-and-map-document-types.d.ts

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+export declare const AssessAndMapDocumentInputSchema: z.ZodObject<{
+    language: z.ZodDefault<z.ZodString>;
+    documentContent: z.ZodString;
+    learningObjectives: z.ZodArray<z.ZodObject<{
+        loId: z.ZodString;
+        subject: z.ZodString;
+        category: z.ZodString;
+        topic: z.ZodString;
+        loDescription: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        subject: string;
+        category: string;
+        topic: string;
+        loDescription: string;
+        loId: string;
+    }, {
+        subject: string;
+        category: string;
+        topic: string;
+        loDescription: string;
+        loId: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    language: string;
+    documentContent: string;
+    learningObjectives: {
+        subject: string;
+        category: string;
+        topic: string;
+        loDescription: string;
+        loId: string;
+    }[];
+}, {
+    documentContent: string;
+    learningObjectives: {
+        subject: string;
+        category: string;
+        topic: string;
+        loDescription: string;
+        loId: string;
+    }[];
+    language?: string | undefined;
+}>;
+export type AssessAndMapDocumentClientInput = z.infer<typeof AssessAndMapDocumentInputSchema>;
+export declare const AssessAndMapDocumentOutputSchema: z.ZodObject<{
+    relevanceScore: z.ZodNumber;
+    isFreestyleRecommended: z.ZodBoolean;
+    mappedLOs: z.ZodArray<z.ZodObject<{
+        loId: z.ZodString;
+        confidence: z.ZodNumber;
+        reasoning: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        reasoning: string;
+        loId: string;
+        confidence: number;
+    }, {
+        reasoning: string;
+        loId: string;
+        confidence: number;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    relevanceScore: number;
+    isFreestyleRecommended: boolean;
+    mappedLOs: {
+        reasoning: string;
+        loId: string;
+        confidence: number;
+    }[];
+}, {
+    relevanceScore: number;
+    isFreestyleRecommended: boolean;
+    mappedLOs: {
+        reasoning: string;
+        loId: string;
+        confidence: number;
+    }[];
+}>;
+export type AssessAndMapDocumentOutput = z.infer<typeof AssessAndMapDocumentOutputSchema>;
+//# sourceMappingURL=assess-and-map-document-types.d.ts.map

package/dist/ai/flows/assess-and-map-document-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assess-and-map-document-types.d.ts","sourceRoot":"","sources":["../../../src/ai/flows/assess-and-map-document-types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI1C,CAAC;AACH,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAW9F,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI3C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC"}

package/dist/ai/flows/assess-and-map-document.d.ts

@@ -0,0 +1,3 @@
+import { type AssessAndMapDocumentClientInput, type AssessAndMapDocumentOutput } from './assess-and-map-document-types';
+export declare function assessAndMapDocument(clientInput: AssessAndMapDocumentClientInput, apiKey: string): Promise<AssessAndMapDocumentOutput>;
+//# sourceMappingURL=assess-and-map-document.d.ts.map

package/dist/ai/flows/assess-and-map-document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assess-and-map-document.d.ts","sourceRoot":"","sources":["../../../src/ai/flows/assess-and-map-document.ts"],"names":[],"mappings":"AASA,OAAO,EACL,KAAK,+BAA+B,EACpC,KAAK,0BAA0B,EAEhC,MAAM,iCAAiC,CAAC;AAGzC,wBAAsB,oBAAoB,CACxC,WAAW,EAAE,+BAA+B,EAC5C,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,0BAA0B,CAAC,CAuErC"}

package/dist/ai/flows/evaluate-user-code-types.d.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import type { SupportedCodingLanguage, TestCase } from '../..';
+export declare const EvaluateUserCodeClientInputSchema: z.ZodObject<{
+    language: z.ZodType<SupportedCodingLanguage, z.ZodTypeDef, SupportedCodingLanguage>;
+    problemPrompt: z.ZodString;
+    userCode: z.ZodString;
+    testCase: z.ZodType<TestCase, z.ZodTypeDef, TestCase>;
+}, "strip", z.ZodTypeAny, {
+    language: SupportedCodingLanguage;
+    problemPrompt: string;
+    userCode: string;
+    testCase: TestCase;
+}, {
+    language: SupportedCodingLanguage;
+    problemPrompt: string;
+    userCode: string;
+    testCase: TestCase;
+}>;
+export type EvaluateUserCodeClientInput = z.infer<typeof EvaluateUserCodeClientInputSchema>;
+declare const AIEvaluationOutputSchema: z.ZodObject<{
+    passed: z.ZodBoolean;
+    actualOutput: z.ZodAny;
+    reasoning: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    passed: boolean;
+    reasoning: string;
+    actualOutput?: any;
+}, {
+    passed: boolean;
+    reasoning: string;
+    actualOutput?: any;
+}>;
+export type AIEvaluationOutput = z.infer<typeof AIEvaluationOutputSchema>;
+export declare const EvaluateUserCodeOutputSchema: z.ZodObject<{
+    passed: z.ZodBoolean;
+    actualOutput: z.ZodAny;
+    reasoning: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    passed: boolean;
+    reasoning: string;
+    actualOutput?: any;
+}, {
+    passed: boolean;
+    reasoning: string;
+    actualOutput?: any;
+}>;
+export type EvaluateUserCodeOutput = z.infer<typeof EvaluateUserCodeOutputSchema>;
+export {};
+//# sourceMappingURL=evaluate-user-code-types.d.ts.map

package/dist/ai/flows/evaluate-user-code-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate-user-code-types.d.ts","sourceRoot":"","sources":["../../../src/ai/flows/evaluate-user-code-types.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,uBAAuB,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAM/D,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;EAK5C,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAE5F,QAAA,MAAM,wBAAwB;;;;;;;;;;;;EAI5B,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,eAAO,MAAM,4BAA4B;;;;;;;;;;;;EAA2B,CAAC;AACrE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC"}

package/dist/ai/flows/evaluate-user-code.d.ts

@@ -0,0 +1,3 @@
+import { type EvaluateUserCodeClientInput, type EvaluateUserCodeOutput } from './evaluate-user-code-types';
+export declare function evaluateUserCode(clientInput: EvaluateUserCodeClientInput, apiKey: string): Promise<EvaluateUserCodeOutput>;
+//# sourceMappingURL=evaluate-user-code.d.ts.map

package/dist/ai/flows/evaluate-user-code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate-user-code.d.ts","sourceRoot":"","sources":["../../../src/ai/flows/evaluate-user-code.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,KAAK,2BAA2B,EAChC,KAAK,sBAAsB,EAE5B,MAAM,4BAA4B,CAAC;AAMpC,wBAAsB,gBAAgB,CACpC,WAAW,EAAE,2BAA2B,EACxC,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,sBAAsB,CAAC,CA+DjC"}

package/dist/ai/flows/generate-learning-analysis-types.d.ts

@@ -0,0 +1,200 @@
+import { z } from 'zod';
+import type { LearningAnalysis } from '../..';
+export declare const GenerateLearningAnalysisInputSchema: z.ZodObject<{
+    language: z.ZodDefault<z.ZodString>;
+    userName: z.ZodOptional<z.ZodString>;
+    weeklyGoal: z.ZodOptional<z.ZodNumber>;
+    unlockedAchievements: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        icon: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        description: string;
+        icon: string;
+    }, {
+        id: string;
+        name: string;
+        description: string;
+        icon: string;
+    }>, "many">;
+    stats: z.ZodAny;
+    history: z.ZodArray<z.ZodAny, "many">;
+    startDate: z.ZodString;
+    endDate: z.ZodString;
+    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, {
+    history: any[];
+    language: string;
+    allAvailableTopics: {
+        subject: string;
+        category: string;
+        topic: string;
+        loId: string;
+    }[];
+    unlockedAchievements: {
+        id: string;
+        name: string;
+        description: string;
+        icon: string;
+    }[];
+    startDate: string;
+    endDate: string;
+    weeklyGoal?: number | undefined;
+    userName?: string | undefined;
+    stats?: any;
+}, {
+    history: any[];
+    allAvailableTopics: {
+        subject: string;
+        category: string;
+        topic: string;
+        loId: string;
+    }[];
+    unlockedAchievements: {
+        id: string;
+        name: string;
+        description: string;
+        icon: string;
+    }[];
+    startDate: string;
+    endDate: string;
+    language?: string | undefined;
+    weeklyGoal?: number | undefined;
+    userName?: string | undefined;
+    stats?: any;
+}>;
+export type GenerateLearningAnalysisClientInput = z.infer<typeof GenerateLearningAnalysisInputSchema>;
+export declare const LearningAnalysisOutputSchema: z.ZodObject<{
+    analysisReport: z.ZodOptional<z.ZodObject<{
+        generatedAt: z.ZodNumber;
+        startDate: z.ZodString;
+        endDate: z.ZodString;
+        effortAndConsistencyRemarks: z.ZodString;
+        strengths: z.ZodArray<z.ZodString, "many">;
+        areasForImprovement: z.ZodArray<z.ZodString, "many">;
+        gamificationRemarks: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        startDate: string;
+        endDate: string;
+        generatedAt: number;
+        effortAndConsistencyRemarks: string;
+        strengths: string[];
+        areasForImprovement: string[];
+        gamificationRemarks: string;
+    }, {
+        startDate: string;
+        endDate: string;
+        generatedAt: number;
+        effortAndConsistencyRemarks: string;
+        strengths: string[];
+        areasForImprovement: string[];
+        gamificationRemarks: string;
+    }>>;
+    weeklyRoadmap: z.ZodOptional<z.ZodObject<{
+        generatedAt: z.ZodNumber;
+        items: z.ZodArray<z.ZodObject<{
+            day: z.ZodString;
+            topicName: z.ZodString;
+            reason: z.ZodString;
+            suggestedDifficulty: z.ZodEnum<["Very Easy", "Easy", "Medium", "Hard", "Expert"]>;
+            loId: z.ZodString;
+            isCompleted: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            loId: string;
+            topicName: string;
+            reason: string;
+            suggestedDifficulty: "Very Easy" | "Easy" | "Medium" | "Hard" | "Expert";
+            day: string;
+            isCompleted: boolean;
+        }, {
+            loId: string;
+            topicName: string;
+            reason: string;
+            suggestedDifficulty: "Very Easy" | "Easy" | "Medium" | "Hard" | "Expert";
+            day: string;
+            isCompleted: boolean;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        items: {
+            loId: string;
+            topicName: string;
+            reason: string;
+            suggestedDifficulty: "Very Easy" | "Easy" | "Medium" | "Hard" | "Expert";
+            day: string;
+            isCompleted: boolean;
+        }[];
+        generatedAt: number;
+    }, {
+        items: {
+            loId: string;
+            topicName: string;
+            reason: string;
+            suggestedDifficulty: "Very Easy" | "Easy" | "Medium" | "Hard" | "Expert";
+            day: string;
+            isCompleted: boolean;
+        }[];
+        generatedAt: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    analysisReport?: {
+        startDate: string;
+        endDate: string;
+        generatedAt: number;
+        effortAndConsistencyRemarks: string;
+        strengths: string[];
+        areasForImprovement: string[];
+        gamificationRemarks: string;
+    } | undefined;
+    weeklyRoadmap?: {
+        items: {
+            loId: string;
+            topicName: string;
+            reason: string;
+            suggestedDifficulty: "Very Easy" | "Easy" | "Medium" | "Hard" | "Expert";
+            day: string;
+            isCompleted: boolean;
+        }[];
+        generatedAt: number;
+    } | undefined;
+}, {
+    analysisReport?: {
+        startDate: string;
+        endDate: string;
+        generatedAt: number;
+        effortAndConsistencyRemarks: string;
+        strengths: string[];
+        areasForImprovement: string[];
+        gamificationRemarks: string;
+    } | undefined;
+    weeklyRoadmap?: {
+        items: {
+            loId: string;
+            topicName: string;
+            reason: string;
+            suggestedDifficulty: "Very Easy" | "Easy" | "Medium" | "Hard" | "Expert";
+            day: string;
+            isCompleted: boolean;
+        }[];
+        generatedAt: number;
+    } | undefined;
+}>;
+export type GenerateLearningAnalysisOutput = LearningAnalysis;
+//# sourceMappingURL=generate-learning-analysis-types.d.ts.map

package/dist/ai/flows/generate-learning-analysis-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-learning-analysis-types.d.ts","sourceRoot":"","sources":["../../../src/ai/flows/generate-learning-analysis-types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAC;AAI9C,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoB9C,CAAC;AACH,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAC;AA2BtG,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGvC,CAAC;AAGH,MAAM,MAAM,8BAA8B,GAAG,gBAAgB,CAAC"}

package/dist/ai/flows/generate-learning-analysis.d.ts

@@ -0,0 +1,4 @@
+import type { LearningAnalysis } from '../..';
+import { type GenerateLearningAnalysisClientInput } from './generate-learning-analysis-types';
+export declare function generateLearningAnalysis(clientInput: GenerateLearningAnalysisClientInput, apiKey: string): Promise<LearningAnalysis>;
+//# sourceMappingURL=generate-learning-analysis.d.ts.map

package/dist/ai/flows/generate-learning-analysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-learning-analysis.d.ts","sourceRoot":"","sources":["../../../src/ai/flows/generate-learning-analysis.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,gBAAgB,EAAmB,MAAM,OAAO,CAAC;AAC/D,OAAO,EACL,KAAK,mCAAmC,EAEzC,MAAM,oCAAoC,CAAC;AAO5C,wBAAsB,wBAAwB,CAC5C,WAAW,EAAE,mCAAmC,EAChD,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,gBAAgB,CAAC,CAsH3B"}

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

@@ -0,0 +1,3 @@
+import { type GenerateMotivationalQuoteClientInput, type GenerateMotivationalQuoteOutput } from './motivational-quote-types';
+export declare function generateMotivationalQuote(clientInput: GenerateMotivationalQuoteClientInput, apiKey: string): Promise<GenerateMotivationalQuoteOutput | null>;
+//# sourceMappingURL=generate-motivational-quote.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generate-motivational-quote.d.ts","sourceRoot":"","sources":["../../../src/ai/flows/generate-motivational-quote.ts"],"names":[],"mappings":"AASA,OAAO,EACL,KAAK,oCAAoC,EACzC,KAAK,+BAA+B,EAErC,MAAM,4BAA4B,CAAC;AAGpC,wBAAsB,yBAAyB,CAC7C,WAAW,EAAE,oCAAoC,EACjD,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,+BAA+B,GAAG,IAAI,CAAC,CA4DjD"}

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

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+export declare const GeneratePracticeQuizClientInputSchema: z.ZodObject<{
+    learningObjectives: z.ZodArray<z.ZodObject<{
+        loId: z.ZodString;
+        loDescription: z.ZodString;
+        subject: z.ZodString;
+        category: z.ZodString;
+        topic: z.ZodString;
+        keywords: z.ZodArray<z.ZodString, "many">;
+        grade: z.ZodString;
+        stemElements: z.ZodArray<z.ZodString, "many">;
+        bloomLevelsGuideline: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        subject: string;
+        category: string;
+        topic: string;
+        loDescription: string;
+        loId: string;
+        grade: string;
+        keywords: string[];
+        stemElements: string[];
+        bloomLevelsGuideline: string[];
+    }, {
+        subject: string;
+        category: string;
+        topic: string;
+        loDescription: string;
+        loId: string;
+        grade: string;
+        keywords: string[];
+        stemElements: string[];
+        bloomLevelsGuideline: string[];
+    }>, "many">;
+    quizDifficulty: z.ZodEnum<["Very Easy", "Easy", "Medium", "Hard", "Expert"]>;
+    language: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    language: string;
+    learningObjectives: {
+        subject: string;
+        category: string;
+        topic: string;
+        loDescription: string;
+        loId: string;
+        grade: string;
+        keywords: string[];
+        stemElements: string[];
+        bloomLevelsGuideline: string[];
+    }[];
+    quizDifficulty: "Very Easy" | "Easy" | "Medium" | "Hard" | "Expert";
+}, {
+    learningObjectives: {
+        subject: string;
+        category: string;
+        topic: string;
+        loDescription: string;
+        loId: string;
+        grade: string;
+        keywords: string[];
+        stemElements: string[];
+        bloomLevelsGuideline: string[];
+    }[];
+    quizDifficulty: "Very Easy" | "Easy" | "Medium" | "Hard" | "Expert";
+    language?: string | undefined;
+}>;
+export type GeneratePracticeQuizClientInput = z.infer<typeof GeneratePracticeQuizClientInputSchema>;
+declare const GeneratePracticeQuizOutputSchema: z.ZodObject<{
+    generatedQuestions: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+}, "strip", z.ZodTypeAny, {
+    generatedQuestions?: any[] | undefined;
+}, {
+    generatedQuestions?: any[] | undefined;
+}>;
+export type GeneratePracticeQuizOutput = z.infer<typeof GeneratePracticeQuizOutputSchema>;
+export declare function generatePracticeQuiz(clientInput: GeneratePracticeQuizClientInput, apiKey: string): Promise<GeneratePracticeQuizOutput>;
+export {};
+//# sourceMappingURL=generate-practice-quiz.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generate-practice-quiz.d.ts","sourceRoot":"","sources":["../../../src/ai/flows/generate-practice-quiz.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA+BxB,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIhD,CAAC;AACH,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAC;AAUpG,QAAA,MAAM,gCAAgC;;;;;;EAEpC,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAO1F,wBAAsB,oBAAoB,CACxC,WAAW,EAAE,+BAA+B,EAC5C,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,0BAA0B,CAAC,CAoIrC"}