academe-kit 0.9.6 → 0.9.8

package/dist/index.d.ts

@@ -1372,6 +1372,68 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/certificates/{userId}/download-all": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Download all certificates of a user as a single PDF
+         * @description Downloads all certificates of the given user merged into a single PDF file.
+         *     Each certificate occupies one page in the resulting file.
+         *     PDFs are downloaded from S3 in parallel and merged using pdf-lib.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description ID of the user whose certificates will be downloaded */
+                    userId: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Merged PDF file containing all user certificates */
+                200: {
+                    headers: {
+                        /** @description attachment; filename="Meus-Certificados.pdf" */
+                        "Content-Disposition"?: string;
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/pdf": string;
+                    };
+                };
+                401: components["responses"]["Unauthorized"];
+                /** @description No certificates found for the user */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @example error */
+                            status?: string;
+                            /** @example No certificates found for this user */
+                            message?: string;
+                        };
+                    };
+                };
+                500: components["responses"]["ServerError"];
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/certificates": {
         parameters: {
             query?: never;
@@ -1381,13 +1443,24 @@ interface paths {
         };
         /**
          * List all certificates
-         * @description Retrieve a list of all certificates in the system.
+         * @description Retrieve a paginated list of all certificates in the system.
          *     Each certificate includes course information (id, title, description) when available.
          *     Course data is extracted from the related Quiz through QuizAttempt.
          */
         get: {
             parameters: {
-                query?: never;
+                query?: {
+                    /** @description Filter certificates by user ID */
+                    userId?: string;
+                    /** @description Search term */
+                    search?: components["parameters"]["search"];
+                    /** @description Page number */
+                    page?: components["parameters"]["page"];
+                    /** @description Items per page */
+                    limit?: components["parameters"]["limit"];
+                    /** @description Whether to include course data in the response (default true). Pass false to skip course lookup. */
+                    includeCourse?: boolean;
+                };
                 header?: never;
                 path?: never;
                 cookie?: never;
@@ -1404,6 +1477,16 @@ interface paths {
                             /** @example success */
                             status?: string;
                             data?: components["schemas"]["Certificate"][];
+                            meta?: {
+                                /** @example 10 */
+                                total?: number;
+                                /** @example 1 */
+                                page?: number;
+                                /** @example 10 */
+                                limit?: number;
+                                /** @example 1 */
+                                totalPages?: number;
+                            };
                         };
                     };
                 };
@@ -1439,8 +1522,6 @@ interface paths {
                             /** @example success */
                             status?: string;
                             data?: components["schemas"]["Certificate"];
-                            /** @example Certificate created successfully */
-                            message?: string;
                         };
                     };
                 };
@@ -1518,18 +1599,11 @@ interface paths {
             requestBody?: never;
             responses: {
                 /** @description Certificate deleted successfully */
-                200: {
+                204: {
                     headers: {
                         [name: string]: unknown;
                     };
-                    content: {
-                        "application/json": {
-                            /** @example success */
-                            status?: string;
-                            /** @example Certificate deleted successfully */
-                            message?: string;
-                        };
-                    };
+                    content?: never;
                 };
                 400: components["responses"]["BadRequest"];
                 401: components["responses"]["Unauthorized"];
@@ -1569,8 +1643,6 @@ interface paths {
                             /** @example success */
                             status?: string;
                             data?: components["schemas"]["Certificate"];
-                            /** @example Certificate updated successfully */
-                            message?: string;
                         };
                     };
                 };
@@ -1582,6 +1654,123 @@ interface paths {
         };
         trace?: never;
     };
+    "/certificates/{id}/download": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Download certificate PDF
+         * @description Download the PDF of a specific certificate.
+         *     Acts as a proxy to download from S3, avoiding CORS issues.
+         *     Only the certificate owner can download their certificate.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Resource ID */
+                    id: components["parameters"]["id"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Certificate PDF file */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/pdf": string;
+                    };
+                };
+                401: components["responses"]["Unauthorized"];
+                403: components["responses"]["Forbidden"];
+                404: components["responses"]["NotFound"];
+                500: components["responses"]["ServerError"];
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/certificates/generate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Generate a certificate PDF server-side
+         * @description Generates a certificate PDF on the server and creates the certificate record.
+         *     This eliminates CORS issues by downloading the template image on the server.
+         *
+         *     If the user is currently on a journey "course" step whose `courseModuleId`
+         *     matches the quiz's course module, that step is auto-completed as part of
+         *     this call (best-effort; failures here are silent and do not affect the cert).
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["GenerateCertificateDto"];
+                };
+            };
+            responses: {
+                /** @description Certificate generated and created successfully */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @example success */
+                            status?: string;
+                            data?: {
+                                certificate?: components["schemas"]["Certificate"];
+                                /** @example https://s3.amazonaws.com/bucket/certificate.pdf */
+                                pdfUrl?: string;
+                                /**
+                                 * @description True when this generation also concluded the user's current journey "course" step
+                                 * @example true
+                                 */
+                                stepCompleted?: boolean;
+                                /**
+                                 * Format: uuid
+                                 * @description ID of the challenge_step that was auto-completed, or null when no step was matched
+                                 */
+                                challengeStepId?: string | null;
+                            };
+                        };
+                    };
+                };
+                400: components["responses"]["BadRequest"];
+                401: components["responses"]["Unauthorized"];
+                500: components["responses"]["ServerError"];
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/challenge-groups": {
         parameters: {
             query?: never;
@@ -1920,6 +2109,12 @@ interface paths {
                     templatesOnly?: boolean;
                     /** @description Search by title */
                     search?: string;
+                    /**
+                     * @description Comma-separated list of extra relations to load. Currently supported:
+                     *     `steps` — embeds each challenge's `steps` (with their catalog `step`).
+                     *     Opt-in to avoid penalizing list views that don't need them.
+                     */
+                    include?: "steps";
                     /** @description Page number */
                     page?: components["parameters"]["page"];
                     /** @description Items per page */
@@ -1974,6 +2169,11 @@ interface paths {
                         maxGroupMembers?: number;
                         /** @default false */
                         isInviteOnly?: boolean;
+                        /**
+                         * Format: uuid
+                         * @description Curso ao qual o desafio está associado (agrupa a jornada no dashboard)
+                         */
+                        courseId: string;
                         /** Format: uuid */
                         institutionId?: string | null;
                         /** Format: uuid */
@@ -2116,6 +2316,8 @@ interface paths {
                         maxGroupMembers?: number;
                         isInviteOnly?: boolean;
                         /** Format: uuid */
+                        courseId?: string;
+                        /** Format: uuid */
                         serieId?: string;
                         index?: number;
                         /** @enum {string} */
@@ -2222,9 +2424,10 @@ interface paths {
         /**
          * Add a step to the challenge
          * @description Polymorphic validation:
-         *     - When step.type=course, courseId is required
          *     - When step.type=tutorial, tutorialVideoUrl is required
-         *     - Other types must not have these specialized fields
+         *     - The course of a step is determined by the parent challenge's courseId.
+         *       Optionally, courseModuleId pinpoints a specific module within that course.
+         *     - tutorial fields are optional on any step type.
          */
         post: {
             parameters: {
@@ -2248,8 +2451,6 @@ interface paths {
                         description?: string;
                         index: number;
                         /** Format: uuid */
-                        courseId?: string;
-                        /** Format: uuid */
                         courseModuleId?: string;
                         tutorialTitle?: string;
                         tutorialDescription?: string;
@@ -9377,6 +9578,8 @@ interface paths {
                     page?: number;
                     /** @description Items per page */
                     limit?: number;
+                    /** @description When true, returns questions in random order with shuffled answer alternatives. Each request reshuffles independently. */
+                    randomize?: boolean;
                 };
                 header?: never;
                 path?: never;
@@ -10430,6 +10633,76 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/reports/encourage-dashboard/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Payload completo da nova tela /new-dashboard
+         * @description Retorna o dashboard agregado por instituição: overview, KPIs,
+         *     licenças (apenas tipo aluno), jornada (cursos deduplicados),
+         *     submissões, desempenho por turma, top 10 alunos (por certificados,
+         *     desempate por nota) e top 10 professores (por avaliações).
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description ID da instituição */
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Payload completo do encourage dashboard */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @example success */
+                            status?: string;
+                            data?: components["schemas"]["EncourageDashboardResponse"];
+                        };
+                    };
+                };
+                /** @description institutionId inválido */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Não autenticado */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Erro interno */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/roles": {
         parameters: {
             query?: never;
@@ -11447,7 +11720,7 @@ interface paths {
         /**
          * Create new submission attempt
          * @description Creates a submission with status=submitted. Validations:
-         *     - Cannot submit to a global template (clone first)
+         *     - institutionId is sent by the client (user's institution_registration), not derived from the challenge
          *     - For group challenges: groupId is required and user must be a member
          *     - For individual challenges: groupId must be omitted
          *     - Cannot create when there is already an active submission (submitted/ai_evaluated)
@@ -11467,6 +11740,11 @@ interface paths {
                     "application/json": {
                         /** Format: uuid */
                         challengeId: string;
+                        /**
+                         * Format: uuid
+                         * @description Institution the user is submitting under (from institution_registration)
+                         */
+                        institutionId: string;
                         /**
                          * Format: uuid
                          * @description Required when challenge.isGroup=true
@@ -12093,7 +12371,7 @@ interface paths {
         patch?: never;
         trace?: never;
     };
-    "/user-challenge-progress/steps/{stepId}/start": {
+    "/user-challenge-progress/challenges/{id}/advance": {
         parameters: {
             query?: never;
             header?: never;
@@ -12103,24 +12381,107 @@ interface paths {
         get?: never;
         put?: never;
         /**
-         * Start a challenge step (idempotent)
-         * @description Creates a user_challenge_progress row. If one already exists for this user/step,
-         *     returns the existing row (idempotent).
+         * Advance one tick in the user's journey on a challenge
+         * @description Unified journey advancement, agnostic of step type. Each call performs ONE action:
+         *
+         *     1. Resolves the current step = first active step (by index) not yet completed by the user.
+         *     2. If no progress row exists for that step → creates one (action='started').
+         *     3. If progress row exists with completed_at IS NULL → sets completed_at (action='completed').
+         *     4. If all steps are completed → no-op (action='finished').
+         *
+         *     Web and mobile clients must use this endpoint regardless of the step type
+         *     (challenge, course, tutorial, publication, evaluation, certificate).
          */
         post: {
             parameters: {
                 query?: never;
                 header?: never;
                 path: {
-                    /** @description ID of the challenge_step to start */
-                    stepId: string;
+                    /** @description Resource ID */
+                    id: components["parameters"]["id"];
                 };
                 cookie?: never;
             };
             requestBody?: never;
             responses: {
-                /** @description Progress started */
-                201: {
+                /** @description Tick result */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @example success */
+                            status?: string;
+                            data?: {
+                                /** @enum {string} */
+                                action?: "started" | "completed" | "finished";
+                                /** Format: uuid */
+                                challengeId?: string;
+                                currentStep?: {
+                                    /** Format: uuid */
+                                    id?: string;
+                                    index?: number;
+                                    name?: string;
+                                    /** Format: date-time */
+                                    startedAt?: string | null;
+                                    /** Format: date-time */
+                                    completedAt?: string | null;
+                                } | null;
+                                /** @description Next step in the journey. When action='completed', this step is also auto-started on the same call (startedAt populated). */
+                                nextStep?: {
+                                    /** Format: uuid */
+                                    id?: string;
+                                    index?: number;
+                                    name?: string;
+                                    /** Format: date-time */
+                                    startedAt?: string | null;
+                                } | null;
+                            };
+                        };
+                    };
+                };
+                401: components["responses"]["Unauthorized"];
+                404: components["responses"]["NotFound"];
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/user-challenge-progress/steps/{stepId}/start": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * [Internal/Admin] Force-start a specific challenge step (idempotent)
+         * @description Creates a user_challenge_progress row for the given step. If one already exists,
+         *     returns the existing row (idempotent).
+         *
+         *     Client apps (web/mobile) should use POST /user-challenge-progress/challenges/{id}/advance
+         *     instead. This endpoint is retained for internal/admin tooling that needs to force a state.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description ID of the challenge_step to start */
+                    stepId: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Progress started */
+                201: {
                     headers: {
                         [name: string]: unknown;
                     };
@@ -12152,8 +12513,12 @@ interface paths {
         get?: never;
         put?: never;
         /**
-         * Mark step as completed
-         * @description Sets completed_at on the user's progress row. Idempotent (no-op if already completed)
+         * [Internal/Admin] Force-complete a specific challenge step
+         * @description Sets completed_at on the user's progress row for the given step. Idempotent
+         *     (no-op if already completed).
+         *
+         *     Client apps (web/mobile) should use POST /user-challenge-progress/challenges/{id}/advance
+         *     instead. This endpoint is retained for internal/admin tooling that needs to force a state.
          */
         post: {
             parameters: {
@@ -12463,6 +12828,103 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/users-course-log/me/courses/{courseId}/progress": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get authenticated user's progress in a course
+         * @description Returns completed/total active lessons (across every active module of the course)
+         *     and a percentage based on `users_course_log` completion events.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    courseId: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Course progress snapshot */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @example success */
+                            status?: string;
+                            data?: components["schemas"]["UsersCourseLogProgress"];
+                        };
+                    };
+                };
+                401: components["responses"]["Unauthorized"];
+                404: components["responses"]["NotFound"];
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/users-course-log/me/courses/{courseId}/modules/{moduleId}/progress": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get authenticated user's progress in a module
+         * @description Returns completed/total active lessons of the module and a percentage based on
+         *     `users_course_log` completion events. Used by the Journey "curso" step.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    courseId: string;
+                    moduleId: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Module progress snapshot */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @example success */
+                            status?: string;
+                            data?: components["schemas"]["UsersCourseLogProgress"];
+                        };
+                    };
+                };
+                401: components["responses"]["Unauthorized"];
+                404: components["responses"]["NotFound"];
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/users/me": {
         parameters: {
             query?: never;
@@ -12936,7 +13398,19 @@ interface paths {
         head?: never;
         /**
          * Update user
-         * @description Update user information
+         * @description Update user information.
+         *
+         *     **Profile and seat code behavior:**
+         *     - Send `groupId` to change the user's profile/group.
+         *     - When `groupId` changes, the system will:
+         *       1. Release the previous seat code used by the user (`isReserved = false`)
+         *       2. Allocate a seat code for the new group in the same institution registration
+         *       3. Create a new seat code automatically if none is available for that group
+         *
+         *     **Important:**
+         *     - The target group must exist.
+         *     - The institution must have a seat configured for the target group.
+         *     - If any institution registration cannot be migrated to the new group, the operation fails.
          */
         patch: {
             parameters: {
@@ -14606,6 +15080,11 @@ interface components {
             maxGroupMembers?: number;
             /** @example false */
             isInviteOnly?: boolean;
+            /**
+             * Format: uuid
+             * @description Curso ao qual o desafio está associado (agrupa a jornada no dashboard)
+             */
+            courseId?: string;
             /**
              * Format: uuid
              * @description Null para template global
@@ -14641,6 +15120,8 @@ interface components {
             createdAt?: string;
             /** Format: date-time */
             updatedAt?: string;
+            /** @description Populado quando `include=steps` é informado no GET /challenges, ou via GET /challenges/{id} */
+            steps?: components["schemas"]["ChallengeStep"][];
         };
         ChallengeMedia: {
             /** Format: uuid */
@@ -14669,10 +15150,8 @@ interface components {
             index?: number;
             /**
              * Format: uuid
-             * @description Obrigatório quando step type=course
+             * @description Opcional. Quando step type=course, aponta para o módulo específico do curso do challenge.
              */
-            courseId?: string | null;
-            /** Format: uuid */
             courseModuleId?: string | null;
             tutorialTitle?: string | null;
             tutorialDescription?: string | null;
@@ -14683,6 +15162,8 @@ interface components {
             createdAt?: string;
             /** Format: date-time */
             updatedAt?: string;
+            /** @description Catálogo do step (cor, ícone, tipo). Populado junto com o relation `steps.step`. */
+            step?: components["schemas"]["Step"];
         };
         /** @description Item do checklist descritivo de entrega */
         ChallengeDeliveryStep: {
@@ -14754,6 +15235,29 @@ interface components {
             /** Format: date-time */
             updatedAt?: string;
         };
+        /** @description Aggregated progress of a user on a course or module, derived from users_course_log completion events */
+        UsersCourseLogProgress: {
+            /**
+             * @description Number of active lessons completed by the user
+             * @example 3
+             */
+            completedLessons?: number;
+            /**
+             * @description Total number of active lessons in scope
+             * @example 5
+             */
+            totalLessons?: number;
+            /**
+             * @description Completion percentage rounded to nearest integer
+             * @example 60
+             */
+            percent?: number;
+            /**
+             * @description True when totalLessons > 0 and completedLessons >= totalLessons
+             * @example false
+             */
+            isCompleted?: boolean;
+        };
         Submission: {
             /** Format: uuid */
             id?: string;
@@ -15669,6 +16173,121 @@ interface components {
             totalStudents?: number;
             year?: number;
         };
+        EncourageActivePeriod: {
+            /** Format: uuid */
+            id?: string;
+            /** Format: date-time */
+            start?: string;
+            /** Format: date-time */
+            end?: string;
+            /** @example Bimestre */
+            label?: string;
+            /** @example 4 */
+            periodsPerYear?: number;
+        };
+        EncourageOverview: {
+            userFirstName?: string;
+            institutionName?: string;
+            activePeriod?: components["schemas"]["EncourageActivePeriod"];
+            /** Format: float */
+            globalProgressPct?: number;
+        };
+        EncourageKpis: {
+            totalStudents?: number;
+            /** Format: float */
+            totalStudentsDeltaPct?: number;
+            completedProjects?: number;
+            /** Format: float */
+            completedProjectsDeltaPct?: number;
+            /** Format: float */
+            engagementRatePct?: number;
+            /** Format: float */
+            engagementRateDeltaPct?: number;
+            neverLoggedIn?: number;
+            neverLoggedInDelta?: number;
+        };
+        /** @description Licenças do tipo aluno (seats.group_id → group.type = 'student') */
+        EncourageLicenses: {
+            used?: number;
+            total?: number;
+            /** Format: float */
+            pct?: number;
+            available?: number;
+        };
+        EncourageJourneyCourse: {
+            /** Format: uuid */
+            courseId?: string;
+            title?: string;
+            /** Format: date-time */
+            dueDate?: string;
+            /** Format: float */
+            progressPct?: number;
+            challengesCount?: number;
+            color?: string;
+        };
+        EncourageJourney: {
+            totalCourses?: number;
+            /** Format: float */
+            averageProgressPct?: number;
+            /** @enum {string} */
+            periodKind?: "semester" | "trimester" | "bimester";
+            courses?: components["schemas"]["EncourageJourneyCourse"][];
+        };
+        EncourageSubmissions: {
+            total?: number;
+            evaluated?: number;
+            awaitingTeacher?: number;
+            awaitingAi?: number;
+        };
+        EncourageClassPerformance: {
+            /** Format: uuid */
+            classroomId?: string;
+            /** @example 2º A — Médio */
+            name?: string;
+            /** @example Manhã */
+            meta?: string;
+            /** @description Total de alunos cadastrados na turma */
+            studentsCount?: number;
+            /** @description Alunos que submeteram pelo menos 1 challenge do período ativo */
+            submittedCount?: number;
+            /** Format: float */
+            progressPct?: number;
+            /** @enum {string} */
+            level?: "high" | "medium" | "low";
+        };
+        EncourageTopStudent: {
+            /** Format: uuid */
+            userId?: string;
+            rank?: number;
+            name?: string;
+            initials?: string;
+            avatarColor?: string;
+            certificates?: number;
+            /** Format: float */
+            averageScore?: number;
+        };
+        EncourageTopTeacher: {
+            /** Format: uuid */
+            userId?: string;
+            rank?: number;
+            name?: string;
+            initials?: string;
+            avatarColor?: string;
+            evaluationsCount?: number;
+            averageEvaluationSeconds?: number;
+            /** Format: float */
+            averageScore?: number;
+        };
+        EncourageDashboardResponse: {
+            overview?: components["schemas"]["EncourageOverview"];
+            kpis?: components["schemas"]["EncourageKpis"];
+            licenses?: components["schemas"]["EncourageLicenses"];
+            journey?: components["schemas"]["EncourageJourney"];
+            submissions?: components["schemas"]["EncourageSubmissions"];
+            classes?: components["schemas"]["EncourageClassPerformance"][];
+            topStudents?: components["schemas"]["EncourageTopStudent"][];
+            topTeachers?: components["schemas"]["EncourageTopTeacher"][];
+        };
         UserCreationRequest: {
             /**
              * Format: uuid
@@ -15861,6 +16480,27 @@ interface components {
             /** Format: uri */
             url?: string;
         };
+        GenerateCertificateDto: {
+            /** Format: uuid */
+            userId: string;
+            /** Format: uuid */
+            quizAttemptId?: string;
+            /** Format: uuid */
+            certificateTemplateId: string;
+            /** @example João Silva */
+            studentName: string;
+            /** @example Introdução ao JavaScript */
+            quizTitle: string;
+            /** @example 85 */
+            score?: number;
+            /** @example CERT-2024-000001 */
+            certificateNumber?: string;
+            /**
+             * Format: date-time
+             * @example 2024-01-01T00:00:00.000Z
+             */
+            issuedAt?: string;
+        };
         CreateGuardianDto: {
             /**
              * Format: email
@@ -21373,6 +22013,7 @@ declare function createQuizService(apiClient: AcademeApiClient): {
                 search?: string;
                 page?: number;
                 limit?: number;
+                randomize?: boolean;
             };
             header?: never;
             path?: never;
@@ -21403,6 +22044,7 @@ declare function createQuizService(apiClient: AcademeApiClient): {
                 search?: string;
                 page?: number;
                 limit?: number;
+                randomize?: boolean;
             } | undefined;
         };
     }, `${string}/${string}`>>;
@@ -22244,7 +22886,6 @@ declare function createCertificateService(apiClient: AcademeApiClient): {
                     "application/json": {
                         status?: string;
                         data?: components["schemas"]["Certificate"];
-                        message?: string;
                     };
                 };
             };
@@ -22291,7 +22932,6 @@ declare function createCertificateService(apiClient: AcademeApiClient): {
                     "application/json": {
                         status?: string;
                         data?: components["schemas"]["Certificate"];
-                        message?: string;
                     };
                 };
             };
@@ -22327,16 +22967,11 @@ declare function createCertificateService(apiClient: AcademeApiClient): {
         };
         requestBody?: never;
         responses: {
-            200: {
+            204: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content: {
-                    "application/json": {
-                        status?: string;
-                        message?: string;
-                    };
-                };
+                content?: never;
             };
             400: components["responses"]["BadRequest"];
             401: components["responses"]["Unauthorized"];
@@ -24160,7 +24795,6 @@ interface UpdateChallengeStepBody {
     name?: string;
     description?: string;
     index?: number;
-    courseId?: string;
     courseModuleId?: string;
     tutorialTitle?: string;
     tutorialDescription?: string;
@@ -24192,6 +24826,7 @@ declare function createChallengeService(apiClient: AcademeApiClient): {
                 isActive?: boolean;
                 templatesOnly?: boolean;
                 search?: string;
+                include?: "steps";
                 page?: components["parameters"]["page"];
                 limit?: components["parameters"]["limit"];
             };
@@ -24224,6 +24859,7 @@ declare function createChallengeService(apiClient: AcademeApiClient): {
                 isActive?: boolean;
                 templatesOnly?: boolean;
                 search?: string;
+                include?: "steps";
                 page?: components["parameters"]["page"];
                 limit?: components["parameters"]["limit"];
             } | undefined;
@@ -24288,6 +24924,7 @@ declare function createChallengeService(apiClient: AcademeApiClient): {
                     isGroup?: boolean;
                     maxGroupMembers?: number;
                     isInviteOnly?: boolean;
+                    courseId: string;
                     institutionId?: string | null;
                     serieId?: string;
                     index?: number;
@@ -24326,6 +24963,7 @@ declare function createChallengeService(apiClient: AcademeApiClient): {
             isGroup?: boolean;
             maxGroupMembers?: number;
             isInviteOnly?: boolean;
+            courseId: string;
             institutionId?: string | null;
             serieId?: string;
             index?: number;
@@ -24359,6 +24997,7 @@ declare function createChallengeService(apiClient: AcademeApiClient): {
                     isGroup?: boolean;
                     maxGroupMembers?: number;
                     isInviteOnly?: boolean;
+                    courseId?: string;
                     serieId?: string;
                     index?: number;
                     submissionType?: "images" | "videos" | "audio" | "files" | "links";
@@ -24399,6 +25038,7 @@ declare function createChallengeService(apiClient: AcademeApiClient): {
             isGroup?: boolean;
             maxGroupMembers?: number;
             isInviteOnly?: boolean;
+            courseId?: string;
             serieId?: string;
             index?: number;
             submissionType?: "images" | "videos" | "audio" | "files" | "links";
@@ -24504,7 +25144,6 @@ declare function createChallengeService(apiClient: AcademeApiClient): {
                     name: string;
                     description?: string;
                     index: number;
-                    courseId?: string;
                     courseModuleId?: string;
                     tutorialTitle?: string;
                     tutorialDescription?: string;
@@ -24539,7 +25178,6 @@ declare function createChallengeService(apiClient: AcademeApiClient): {
             name: string;
             description?: string;
             index: number;
-            courseId?: string;
             courseModuleId?: string;
             tutorialTitle?: string;
             tutorialDescription?: string;
@@ -25110,6 +25748,353 @@ declare function createStepService(apiClient: AcademeApiClient): {
 };
 type StepService = ReturnType<typeof createStepService>;
 
+type GetSubmissionsParams = paths["/submissions"]["get"]["parameters"]["query"];
+type CreateSubmissionBody = paths["/submissions"]["post"]["requestBody"]["content"]["application/json"] & {
+    /** Institution under which the user is submitting (from institution_registration) */
+    institutionId: string;
+};
+type AttachFilesBody = paths["/submissions/{id}/files"]["post"]["requestBody"]["content"]["application/json"];
+type AiEvaluationBody = paths["/submissions/{id}/ai-evaluation"]["post"]["requestBody"]["content"]["application/json"];
+type TeacherEvaluationBody = paths["/submissions/{id}/teacher-evaluation"]["patch"]["requestBody"]["content"]["application/json"];
+declare function createSubmissionService(apiClient: AcademeApiClient): {
+    /**
+     * List submissions with filters and pagination
+     */
+    getAll(params?: GetSubmissionsParams): Promise<openapi_fetch.FetchResponse<{
+        parameters: {
+            query?: {
+                challengeId?: string;
+                userId?: string;
+                groupId?: string;
+                institutionId?: string;
+                status?: "submitted" | "ai_evaluated" | "approved" | "rejected";
+                page?: components["parameters"]["page"];
+                limit?: components["parameters"]["limit"];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["Submission"][];
+                        meta?: components["schemas"]["PaginationMeta"];
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    }, {
+        params: {
+            query: {
+                challengeId?: string;
+                userId?: string;
+                groupId?: string;
+                institutionId?: string;
+                status?: "submitted" | "ai_evaluated" | "approved" | "rejected";
+                page?: components["parameters"]["page"];
+                limit?: components["parameters"]["limit"];
+            } | undefined;
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Get submission with files and per-criterion scores
+     */
+    getById(id: string): Promise<openapi_fetch.FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["Submission"] & {
+                            files?: components["schemas"]["SubmissionFile"][];
+                            criterionScores?: components["schemas"]["SubmissionCriterionScore"][];
+                        };
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Create a new submission attempt (status=submitted)
+     * - Cannot submit to a global template (clone first)
+     * - For group challenges: groupId is required and user must be a member
+     * - For individual challenges: groupId must be omitted
+     * - Cannot create when there is already an active submission
+     * - attempt_number is computed server-side
+     */
+    create(data: CreateSubmissionBody): Promise<openapi_fetch.FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    challengeId: string;
+                    institutionId: string;
+                    groupId?: string;
+                    description?: string;
+                };
+            };
+        };
+        responses: {
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["Submission"];
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+        };
+    }, {
+        body: never;
+    }, `${string}/${string}`>>;
+    /**
+     * Attach files or links to a submission (batch)
+     * Each item must have exactly ONE of fileId or url (XOR).
+     * - submissionType in [images, videos, audio, files] → items must have fileId
+     * - submissionType === 'links' → items must have url
+     */
+    attachFiles(submissionId: string, data: AttachFilesBody): Promise<openapi_fetch.FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["id"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    items: {
+                        fileId?: string | null;
+                        url?: string | null;
+                        index?: number;
+                    }[];
+                };
+            };
+        };
+        responses: {
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["SubmissionFile"][];
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+        body: {
+            items: {
+                fileId?: string | null;
+                url?: string | null;
+                index?: number;
+            }[];
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Remove a file or link from a submission
+     * Only allowed when submission is in status submitted or ai_evaluated
+     */
+    removeFile(submissionId: string, fileRowId: string): Promise<openapi_fetch.FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["id"];
+                fileRowId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+                fileRowId: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Register AI evaluation (called by the AI service callback).
+     * Moves status from submitted → ai_evaluated.
+     */
+    aiEvaluate(submissionId: string, data: AiEvaluationBody): Promise<openapi_fetch.FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["id"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    aiScore: number;
+                    aiFeedback?: string;
+                    aiExtractedContent?: Record<string, never>;
+                    criterionScores?: {
+                        challengeEvaluationCriterionId: string;
+                        score: number;
+                        comment?: string;
+                    }[];
+                };
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["Submission"];
+                    };
+                };
+            };
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+        body: {
+            aiScore: number;
+            aiFeedback?: string;
+            aiExtractedContent?: Record<string, never>;
+            criterionScores?: {
+                challengeEvaluationCriterionId: string;
+                score: number;
+                comment?: string;
+            }[];
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Teacher approves or rejects a submission.
+     * Only allowed when status is submitted or ai_evaluated.
+     */
+    teacherEvaluate(submissionId: string, data: TeacherEvaluationBody): Promise<openapi_fetch.FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["id"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    status: "approved" | "rejected";
+                    teacherScore?: number;
+                    teacherFeedback?: string;
+                };
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["Submission"];
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+        body: {
+            status: "approved" | "rejected";
+            teacherScore?: number;
+            teacherFeedback?: string;
+        };
+    }, `${string}/${string}`>>;
+};
+type SubmissionService = ReturnType<typeof createSubmissionService>;
+
 type AcademeApiClient = ReturnType<typeof openapi_fetch__default<paths>>;
 declare function createAcademeApiClient(baseUrl: string): AcademeApiClient;
 interface AcademeServices {
@@ -25133,6 +26118,7 @@ interface AcademeServices {
     storageFile: StorageFileService;
     challenge: ChallengeService;
     step: StepService;
+    submission: SubmissionService;
 }
 
 type AcademeKeycloakContextProps = {