npm - @thanh01.pmt/interactive-quiz-kit - Versions diffs - 1.0.28 → 1.0.30 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (493) hide show

package/dist/ai/flows/question-gen/generate-numeric-question-types.d.ts ADDED Viewed

@@ -0,0 +1,131 @@
+import { z } from 'zod';
+import type { NumericQuestion } from '../../..';
+export declare const GenerateNumericQuestionClientInputSchema: 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>;
+} & {
+    allowDecimals: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    minRange: z.ZodOptional<z.ZodNumber>;
+    maxRange: z.ZodOptional<z.ZodNumber>;
+    tolerance: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    language: string;
+    difficulty: "easy" | "medium" | "hard";
+    tolerance: number;
+    allowDecimals: boolean;
+    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;
+    minRange?: number | undefined;
+    maxRange?: number | undefined;
+}, {
+    difficulty: "easy" | "medium" | "hard";
+    language?: string | undefined;
+    tolerance?: number | 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;
+    allowDecimals?: boolean | undefined;
+    minRange?: number | undefined;
+    maxRange?: number | undefined;
+}>;
+export type GenerateNumericQuestionClientInput = z.infer<typeof GenerateNumericQuestionClientInputSchema>;
+export declare const AINumericOutputFieldsSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    answer: z.ZodNumber;
+    tolerance: z.ZodOptional<z.ZodNumber>;
+    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;
+    answer: number;
+    topic?: string | undefined;
+    difficulty?: "easy" | "medium" | "hard" | undefined;
+    explanation?: string | undefined;
+    tolerance?: number | undefined;
+    verifiedCategory?: string | undefined;
+}, {
+    prompt: string;
+    answer: number;
+    topic?: string | undefined;
+    difficulty?: "easy" | "medium" | "hard" | undefined;
+    points?: number | undefined;
+    explanation?: string | undefined;
+    tolerance?: number | undefined;
+    verifiedCategory?: string | undefined;
+}>;
+export type AINumericOutputFields = z.infer<typeof AINumericOutputFieldsSchema>;
+export type GenerateNumericQuestionOutput = {
+    question?: NumericQuestion;
+    error?: string;
+};
+//# sourceMappingURL=generate-numeric-question-types.d.ts.map

package/dist/ai/flows/question-gen/generate-numeric-question-types.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"generate-numeric-question-types.d.ts","sourceRoot":"","sources":["../../../../src/ai/flows/question-gen/generate-numeric-question-types.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAOhD,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMnD,CAAC;AACH,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wCAAwC,CAAC,CAAC;AAM1G,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUtC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAMhF,MAAM,MAAM,6BAA6B,GAAG;IACxC,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC"}

package/dist/ai/flows/question-gen/generate-numeric-question.d.ts ADDED Viewed

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

package/dist/ai/flows/question-gen/generate-numeric-question.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"generate-numeric-question.d.ts","sourceRoot":"","sources":["../../../../src/ai/flows/question-gen/generate-numeric-question.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,KAAK,kCAAkC,EACvC,KAAK,6BAA6B,EAEnC,MAAM,mCAAmC,CAAC;AA8E3C,wBAAsB,uBAAuB,CAC3C,WAAW,EAAE,kCAAkC,EAC/C,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,6BAA6B,CAAC,CAmHxC"}

package/dist/ai/flows/question-gen/generate-sequence-question-types.d.ts ADDED Viewed

@@ -0,0 +1,119 @@
+import { z } from 'zod';
+import type { SequenceQuestion } from '../../..';
+export declare const GenerateSequenceQuestionClientInputSchema: 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>;
+} & {
+    numberOfItems: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    language: string;
+    difficulty: "easy" | "medium" | "hard";
+    numberOfItems: 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;
+    numberOfItems?: number | undefined;
+}>;
+export type GenerateSequenceQuestionClientInput = z.infer<typeof GenerateSequenceQuestionClientInputSchema>;
+export declare const AISequenceOutputFieldsSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    itemsInCorrectOrder: 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, {
+    prompt: string;
+    points: number;
+    itemsInCorrectOrder: string[];
+    topic?: string | undefined;
+    difficulty?: "easy" | "medium" | "hard" | undefined;
+    explanation?: string | undefined;
+    verifiedCategory?: string | undefined;
+}, {
+    prompt: string;
+    itemsInCorrectOrder: string[];
+    topic?: string | undefined;
+    difficulty?: "easy" | "medium" | "hard" | undefined;
+    points?: number | undefined;
+    explanation?: string | undefined;
+    verifiedCategory?: string | undefined;
+}>;
+export type AISequenceOutputFields = z.infer<typeof AISequenceOutputFieldsSchema>;
+export type GenerateSequenceQuestionOutput = {
+    question?: SequenceQuestion;
+    error?: string;
+};
+//# sourceMappingURL=generate-sequence-question-types.d.ts.map

package/dist/ai/flows/question-gen/generate-sequence-question-types.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"generate-sequence-question-types.d.ts","sourceRoot":"","sources":["../../../../src/ai/flows/question-gen/generate-sequence-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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEpD,CAAC;AACH,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yCAAyC,CAAC,CAAC;AAM5G,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;EAUvC,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-sequence-question.d.ts ADDED Viewed

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

package/dist/ai/flows/question-gen/generate-sequence-question.d.ts.map ADDED Viewed

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

package/dist/ai/flows/question-gen/generate-short-answer-question-types.d.ts ADDED Viewed

@@ -0,0 +1,119 @@
+import { z } from 'zod';
+import type { ShortAnswerQuestion } from '../../..';
+export declare const GenerateShortAnswerQuestionClientInputSchema: 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>;
+} & {
+    isCaseSensitive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    language: string;
+    difficulty: "easy" | "medium" | "hard";
+    isCaseSensitive: boolean;
+    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;
+}>;
+export type GenerateShortAnswerQuestionClientInput = z.infer<typeof GenerateShortAnswerQuestionClientInputSchema>;
+export declare const AIShortAnswerOutputFieldsSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    acceptedAnswers: 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, {
+    prompt: string;
+    points: number;
+    acceptedAnswers: string[];
+    topic?: string | undefined;
+    difficulty?: "easy" | "medium" | "hard" | undefined;
+    explanation?: string | undefined;
+    verifiedCategory?: string | undefined;
+}, {
+    prompt: string;
+    acceptedAnswers: string[];
+    topic?: string | undefined;
+    difficulty?: "easy" | "medium" | "hard" | undefined;
+    points?: number | undefined;
+    explanation?: string | undefined;
+    verifiedCategory?: string | undefined;
+}>;
+export type AIShortAnswerOutputFields = z.infer<typeof AIShortAnswerOutputFieldsSchema>;
+export type GenerateShortAnswerQuestionOutput = {
+    question?: ShortAnswerQuestion;
+    error?: string;
+};
+//# sourceMappingURL=generate-short-answer-question-types.d.ts.map

package/dist/ai/flows/question-gen/generate-short-answer-question-types.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"generate-short-answer-question-types.d.ts","sourceRoot":"","sources":["../../../../src/ai/flows/question-gen/generate-short-answer-question-types.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAOpD,eAAO,MAAM,4CAA4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEvD,CAAC;AACH,MAAM,MAAM,sCAAsC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4CAA4C,CAAC,CAAC;AAMlH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;EAS1C,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAMxF,MAAM,MAAM,iCAAiC,GAAG;IAC5C,QAAQ,CAAC,EAAE,mBAAmB,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC"}

package/dist/ai/flows/question-gen/generate-short-answer-question.d.ts ADDED Viewed

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

package/dist/ai/flows/question-gen/generate-short-answer-question.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"generate-short-answer-question.d.ts","sourceRoot":"","sources":["../../../../src/ai/flows/question-gen/generate-short-answer-question.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,KAAK,sCAAsC,EAC3C,KAAK,iCAAiC,EAEvC,MAAM,wCAAwC,CAAC;AAsEhD,wBAAsB,2BAA2B,CAC/C,WAAW,EAAE,sCAAsC,EACnD,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,iCAAiC,CAAC,CAoG5C"}

package/dist/ai/flows/question-gen/generate-true-false-question-types.d.ts ADDED Viewed

@@ -0,0 +1,115 @@
+import { z } from 'zod';
+import type { TrueFalseQuestion } from '../../..';
+export declare const GenerateTrueFalseQuestionClientInputSchema: 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>;
+}, "strip", z.ZodTypeAny, {
+    language: string;
+    difficulty: "easy" | "medium" | "hard";
+    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;
+}>;
+export type GenerateTrueFalseQuestionClientInput = z.infer<typeof GenerateTrueFalseQuestionClientInputSchema>;
+export declare const AITrueFalseOutputFieldsSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    correctAnswer: z.ZodBoolean;
+    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, {
+    correctAnswer: boolean;
+    prompt: string;
+    points: number;
+    topic?: string | undefined;
+    difficulty?: "easy" | "medium" | "hard" | undefined;
+    explanation?: string | undefined;
+    verifiedCategory?: string | undefined;
+}, {
+    correctAnswer: boolean;
+    prompt: string;
+    topic?: string | undefined;
+    difficulty?: "easy" | "medium" | "hard" | undefined;
+    points?: number | undefined;
+    explanation?: string | undefined;
+    verifiedCategory?: string | undefined;
+}>;
+export type AITrueFalseOutputFields = z.infer<typeof AITrueFalseOutputFieldsSchema>;
+export type GenerateTrueFalseQuestionOutput = {
+    question?: TrueFalseQuestion;
+    error?: string;
+};
+//# sourceMappingURL=generate-true-false-question-types.d.ts.map

package/dist/ai/flows/question-gen/generate-true-false-question-types.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"generate-true-false-question-types.d.ts","sourceRoot":"","sources":["../../../../src/ai/flows/question-gen/generate-true-false-question-types.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAQlD,eAAO,MAAM,0CAA0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAqD,CAAC;AAC7G,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0CAA0C,CAAC,CAAC;AAM9G,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;EAQxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAMpF,MAAM,MAAM,+BAA+B,GAAG;IAC1C,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC"}

package/dist/ai/flows/question-gen/generate-true-false-question.d.ts ADDED Viewed

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

package/dist/ai/flows/question-gen/generate-true-false-question.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"generate-true-false-question.d.ts","sourceRoot":"","sources":["../../../../src/ai/flows/question-gen/generate-true-false-question.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,KAAK,oCAAoC,EACzC,KAAK,+BAA+B,EAErC,MAAM,sCAAsC,CAAC;AA4E9C,wBAAsB,yBAAyB,CAC7C,WAAW,EAAE,oCAAoC,EACjD,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,+BAA+B,CAAC,CAuG1C"}