academe-kit 0.11.6 → 0.11.7

package/dist/index.d.ts

@@ -9899,6 +9899,67 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/quiz-questions/bulk": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Bulk create quiz questions
+         * @description Cria várias perguntas (com respostas) de uma vez para um quiz.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        quizId: string;
+                        questions: {
+                            text: string;
+                            type: "multiple_choice" | "true_false" | "open";
+                            points?: number;
+                            options?: {
+                                text: string;
+                                is_correct: boolean;
+                            }[];
+                        }[];
+                    };
+                };
+            };
+            responses: {
+                /** @description Questions created */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @example success */
+                            status?: string;
+                            data?: components["schemas"]["QuizQuestion"][];
+                        };
+                    };
+                };
+                400: components["responses"]["BadRequest"];
+                401: components["responses"]["Unauthorized"];
+                500: components["responses"]["ServerError"];
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/quiz-questions/{id}": {
         parameters: {
             query?: never;
@@ -10111,6 +10172,145 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/quiz/with-context": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List quizzes with course/module/category context
+         * @description Retrieve a paginated list of quizzes, each enriched with the course, module and category it belongs to. `context` is null for standalone quizzes.
+         */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description Filter by quiz title */
+                    title?: string;
+                    /** @description Filter by active status */
+                    isActive?: boolean;
+                    /** @description Filter by creator user ID */
+                    createdBy?: string;
+                    /** @description Search in title */
+                    search?: string;
+                    /** @description Page number */
+                    page?: number;
+                    /** @description Items per page */
+                    limit?: number;
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description List of quizzes with context */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @example success */
+                            status?: string;
+                            data?: (components["schemas"]["Quiz"] & {
+                                context?: {
+                                    course?: {
+                                        id?: string;
+                                        title?: string;
+                                    } | null;
+                                    module?: {
+                                        id?: string;
+                                        title?: string;
+                                    } | null;
+                                    category?: {
+                                        id?: string;
+                                        name?: string;
+                                        color?: string | null;
+                                    } | null;
+                                } | null;
+                            })[];
+                            meta?: components["schemas"]["PaginationMeta"];
+                        };
+                    };
+                };
+                401: components["responses"]["Unauthorized"];
+                500: components["responses"]["ServerError"];
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/quiz/generate-questions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Generate quiz questions with AI
+         * @description Gera perguntas a partir de um texto base via IA. Não persiste — apenas devolve.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        text: string;
+                        numQuestions: number;
+                        difficulty?: "facil" | "normal" | "dificil";
+                        existingQuestions?: string[];
+                        model?: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Generated questions */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @example success */
+                            status?: string;
+                            data?: {
+                                question_text: string;
+                                question_type: "multiple_choice" | "true_false";
+                                points: number;
+                                options: {
+                                    text: string;
+                                    is_correct: boolean;
+                                }[];
+                            }[];
+                        };
+                    };
+                };
+                400: components["responses"]["BadRequest"];
+                401: components["responses"]["Unauthorized"];
+                500: components["responses"]["ServerError"];
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/quiz/{id}": {
         parameters: {
             query?: never;
@@ -22867,6 +23067,9 @@ type GetQuizzesParams = {
     page?: number;
     limit?: number;
 };
+type GetQuizzesWithContextParams = paths['/quiz/with-context']['get']['parameters']['query'];
+type GenerateQuizQuestionsBody = paths['/quiz/generate-questions']['post']['requestBody']['content']['application/json'];
+type BulkCreateQuizQuestionsBody = paths['/quiz-questions/bulk']['post']['requestBody']['content']['application/json'];
 type GetQuizQuestionsParams = paths['/quiz-questions']['get']['parameters']['query'];
 type GetQuizQuestionAnswersParams = paths['/quiz-question-answers']['get']['parameters']['query'];
 type GetQuizAttemptsParams = paths['/quiz-attempts']['get']['parameters']['query'];
@@ -22912,6 +23115,125 @@ declare function createQuizService(apiClient: AcademeApiClient): {
             query: GetQuizzesParams | undefined;
         };
     }, `${string}/${string}`>>;
+    /**
+     * List quizzes enriched with their course/module/category context.
+     * Tailored for the backoffice listing.
+     */
+    getAllWithContext(params?: GetQuizzesWithContextParams): Promise<openapi_fetch.FetchResponse<{
+        parameters: {
+            query?: {
+                title?: string;
+                isActive?: boolean;
+                createdBy?: string;
+                search?: string;
+                page?: number;
+                limit?: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: (components["schemas"]["Quiz"] & {
+                            context?: {
+                                course?: {
+                                    id?: string;
+                                    title?: string;
+                                } | null;
+                                module?: {
+                                    id?: string;
+                                    title?: string;
+                                } | null;
+                                category?: {
+                                    id?: string;
+                                    name?: string;
+                                    color?: string | null;
+                                } | null;
+                            } | null;
+                        })[];
+                        meta?: components["schemas"]["PaginationMeta"];
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            query: {
+                title?: string;
+                isActive?: boolean;
+                createdBy?: string;
+                search?: string;
+                page?: number;
+                limit?: number;
+            } | undefined;
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Generate quiz questions from a base text using AI.
+     * The OpenRouter key lives only on the server — this just calls the
+     * authenticated backend endpoint.
+     */
+    generateQuestions(body: GenerateQuizQuestionsBody): Promise<openapi_fetch.FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    text: string;
+                    numQuestions: number;
+                    difficulty?: "facil" | "normal" | "dificil";
+                    existingQuestions?: string[];
+                    model?: string;
+                };
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: {
+                            question_text: string;
+                            question_type: "multiple_choice" | "true_false";
+                            points: number;
+                            options: {
+                                text: string;
+                                is_correct: boolean;
+                            }[];
+                        }[];
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        body: {
+            text: string;
+            numQuestions: number;
+            difficulty?: "facil" | "normal" | "dificil";
+            existingQuestions?: string[];
+            model?: string;
+        };
+    }, `${string}/${string}`>>;
     /**
      * Get quiz by ID
      */
@@ -23202,6 +23524,62 @@ declare function createQuizService(apiClient: AcademeApiClient): {
             points?: number;
         };
     }, `${string}/${string}`>>;
+    /**
+     * Bulk create quiz questions (with their answers) for a quiz.
+     */
+    bulkCreateQuestions(body: BulkCreateQuizQuestionsBody): Promise<openapi_fetch.FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    quizId: string;
+                    questions: {
+                        text: string;
+                        type: "multiple_choice" | "true_false" | "open";
+                        points?: number;
+                        options?: {
+                            text: string;
+                            is_correct: boolean;
+                        }[];
+                    }[];
+                };
+            };
+        };
+        responses: {
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["QuizQuestion"][];
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        body: {
+            quizId: string;
+            questions: {
+                text: string;
+                type: "multiple_choice" | "true_false" | "open";
+                points?: number;
+                options?: {
+                    text: string;
+                    is_correct: boolean;
+                }[];
+            }[];
+        };
+    }, `${string}/${string}`>>;
     /**
      * Update quiz question
      */

package/dist/index.esm.js

@@ -5381,6 +5381,27 @@ function createQuizService(apiClient) {
                 },
             });
         },
+        /**
+         * List quizzes enriched with their course/module/category context.
+         * Tailored for the backoffice listing.
+         */
+        getAllWithContext(params) {
+            return apiClient.GET('/quiz/with-context', {
+                params: {
+                    query: params,
+                },
+            });
+        },
+        /**
+         * Generate quiz questions from a base text using AI.
+         * The OpenRouter key lives only on the server — this just calls the
+         * authenticated backend endpoint.
+         */
+        generateQuestions(body) {
+            return apiClient.POST('/quiz/generate-questions', {
+                body,
+            });
+        },
         /**
          * Get quiz by ID
          */
@@ -5443,6 +5464,14 @@ function createQuizService(apiClient) {
                 body: data,
             });
         },
+        /**
+         * Bulk create quiz questions (with their answers) for a quiz.
+         */
+        bulkCreateQuestions(body) {
+            return apiClient.POST('/quiz-questions/bulk', {
+                body,
+            });
+        },
         /**
          * Update quiz question
          */