academe-kit 0.9.0 → 0.9.2

package/dist/index.d.ts

@@ -270,6 +270,221 @@ interface paths {
         };
         trace?: never;
     };
+    "/auth/forgot-password": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Request password reset email
+         * @description Sends a password reset email to the specified address if a user with that email exists.
+         *
+         *     **Security Note:**
+         *     For security reasons, this endpoint always returns a success response regardless of whether
+         *     the email exists in the system. This prevents email enumeration attacks.
+         *
+         *     **Flow:**
+         *     1. Client sends email address
+         *     2. Backend searches for user by email in Keycloak
+         *     3. If user exists, Keycloak sends password reset email with UPDATE_PASSWORD action
+         *     4. User receives email with link valid for 1 hour
+         *     5. Endpoint returns success (regardless of whether email was found)
+         *
+         *     **Email Template:**
+         *     The email sent uses the Keycloak realm's configured email template for password reset.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        /**
+                         * Format: email
+                         * @description User's email address
+                         * @example user@example.com
+                         */
+                        email: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Request processed successfully (always returned for security) */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @example success */
+                            status?: string;
+                            /** @example If this email is registered, you will receive password reset instructions. */
+                            message?: string;
+                        };
+                    };
+                };
+                /** @description Bad Request - Email not provided */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @example error */
+                            status?: string;
+                            /** @example Email is required */
+                            message?: string;
+                        };
+                    };
+                };
+                /** @description Internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @example error */
+                            status?: string;
+                            /** @example Internal server error */
+                            message?: string;
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/auth/google-exchange": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Exchange Google access token for Keycloak tokens
+         * @description Exchanges a Google access token for Keycloak tokens.
+         *
+         *     **Flow:**
+         *     1. Client sends Google access token
+         *     2. Backend fetches user email from Google Userinfo API
+         *     3. Backend verifies the email exists in the local database
+         *     4. If user exists, performs Keycloak token exchange
+         *     5. Returns Keycloak tokens (access_token, refresh_token, etc.)
+         *
+         *     **Error Cases:**
+         *     - 400: Invalid or expired Google token
+         *     - 404: User email not found in database
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Google OAuth2 access token
+                         * @example ya29.a0AfH6SM...
+                         */
+                        googleAccessToken: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Token exchange successful */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @example success */
+                            status?: string;
+                            data?: {
+                                /** @description Keycloak access token */
+                                access_token?: string;
+                                /** @description Keycloak refresh token */
+                                refresh_token?: string;
+                                /** @description Token expiration time in seconds */
+                                expires_in?: number;
+                                /** @description Refresh token expiration time in seconds */
+                                refresh_expires_in?: number;
+                                /** @example Bearer */
+                                token_type?: string;
+                                scope?: string;
+                            };
+                        };
+                    };
+                };
+                /** @description Bad Request - Invalid Google token or missing googleAccessToken */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @example error */
+                            status?: string;
+                            /** @example Token do Google inválido ou expirado */
+                            message?: string;
+                        };
+                    };
+                };
+                /** @description Not Found - User email not registered in database */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @example error */
+                            status?: string;
+                            /** @example Usuário não encontrado */
+                            message?: string;
+                        };
+                    };
+                };
+                /** @description Internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @example error */
+                            status?: string;
+                            /** @example Internal server error */
+                            message?: string;
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/auth/token": {
         parameters: {
             query?: never;
@@ -872,6 +1087,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;
@@ -881,13 +1158,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;
@@ -904,6 +1192,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;
+                            };
                         };
                     };
                 };
@@ -939,8 +1237,6 @@ interface paths {
                             /** @example success */
                             status?: string;
                             data?: components["schemas"]["Certificate"];
-                            /** @example Certificate created successfully */
-                            message?: string;
                         };
                     };
                 };
@@ -1018,18 +1314,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"];
@@ -1069,8 +1358,6 @@ interface paths {
                             /** @example success */
                             status?: string;
                             data?: components["schemas"]["Certificate"];
-                            /** @example Certificate updated successfully */
-                            message?: string;
                         };
                     };
                 };
@@ -1082,6 +1369,109 @@ 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.
+         */
+        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;
+                            };
+                        };
+                    };
+                };
+                400: components["responses"]["BadRequest"];
+                401: components["responses"]["Unauthorized"];
+                500: components["responses"]["ServerError"];
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/classrooms": {
         parameters: {
             query?: never;
@@ -9589,6 +9979,8 @@ interface paths {
             requestBody: {
                 content: {
                     "application/json": {
+                        /** @example sa@academe.com.br */
+                        email?: string;
                         /** @example John */
                         firstName?: string;
                         /** @example Doe */
@@ -9988,7 +10380,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: {
@@ -10252,7 +10656,59 @@ interface paths {
         patch?: never;
         trace?: never;
     };
-    "/users/{id}/sync": {
+    "/users/{id}/sync": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Sync user with Keycloak
+         * @description Synchronize user data with Keycloak identity provider
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Resource ID */
+                    id: components["parameters"]["id"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description User synchronized successfully */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @example success */
+                            status?: string;
+                            data?: components["schemas"]["User"];
+                            /** @example User synchronized with Keycloak successfully */
+                            message?: string;
+                        };
+                    };
+                };
+                400: components["responses"]["BadRequest"];
+                401: components["responses"]["Unauthorized"];
+                404: components["responses"]["NotFound"];
+                500: components["responses"]["ServerError"];
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/users/register-hotmart": {
         parameters: {
             query?: never;
             header?: never;
@@ -10262,22 +10718,123 @@ interface paths {
         get?: never;
         put?: never;
         /**
-         * Sync user with Keycloak
-         * @description Synchronize user data with Keycloak identity provider
+         * Hotmart webhook for user registration and lifecycle
+         * @description Public endpoint that receives webhook events from Hotmart.
+         *     Handles user creation and deactivation based on purchase events.
+         *
+         *     **Supported Events:**
+         *
+         *     | Event | Action |
+         *     |-------|--------|
+         *     | `PURCHASE_APPROVED` | Enqueues user creation with buyer data |
+         *     | `PURCHASE_CANCELED` | Deactivates (soft deletes) the user |
+         *     | `PURCHASE_REFUNDED` | Deactivates (soft deletes) the user |
+         *     | `PURCHASE_CHARGEBACK` | Deactivates (soft deletes) the user |
+         *
+         *     **User Creation Flow (PURCHASE_APPROVED):**
+         *     1. Extracts buyer information from the Hotmart payload
+         *     2. Determines institution based on offer code
+         *     3. Enqueues user creation request for async processing
+         *     4. User is created in Keycloak and database by the worker
+         *
+         *     **Offer-based Institution Assignment:**
+         *     - Offer code `d9to7y3w` → Institution `580268b1-458d-4f4c-901d-281eccf3b40d`
+         *
+         *     **User Deactivation Flow:**
+         *     1. Looks up the user by buyer email
+         *     2. Soft deletes the user (marks as inactive)
+         *     3. Disables the user in Keycloak
+         *
+         *     All events return HTTP 200 to acknowledge receipt.
+         *     Unrecognized events are logged and ignored.
          */
         post: {
             parameters: {
                 query?: never;
                 header?: never;
-                path: {
-                    /** @description Resource ID */
-                    id: components["parameters"]["id"];
-                };
+                path?: never;
                 cookie?: never;
             };
-            requestBody?: never;
+            requestBody: {
+                content: {
+                    "application/json": {
+                        /**
+                         * Format: uuid
+                         * @description Unique webhook event ID
+                         * @example d96fafd0-75ed-4ca7-8fa8-c6a57f48e384
+                         */
+                        id: string;
+                        /**
+                         * @description Hotmart event type
+                         * @example PURCHASE_APPROVED
+                         * @enum {string}
+                         */
+                        event: "PURCHASE_APPROVED" | "PURCHASE_CANCELED" | "PURCHASE_REFUNDED" | "PURCHASE_CHARGEBACK" | "PURCHASE_COMPLETE" | "PURCHASE_PROTEST" | "PURCHASE_DELAYED";
+                        /**
+                         * @description Event creation timestamp (Unix milliseconds)
+                         * @example 1773161133350
+                         */
+                        creation_date: number;
+                        /**
+                         * @description Webhook payload version
+                         * @example 2.0.0
+                         */
+                        version: string;
+                        data: {
+                            buyer: {
+                                /**
+                                 * Format: email
+                                 * @example buyer@example.com
+                                 */
+                                email: string;
+                                /** @example Teste */
+                                first_name: string;
+                                /** @example Comprador */
+                                last_name: string;
+                                /** @example Teste Comprador */
+                                name?: string;
+                                /** @example 69526128664 */
+                                document?: string;
+                                /** @example CPF */
+                                document_type?: string;
+                                /** @example 99999999900 */
+                                checkout_phone?: string;
+                            };
+                            purchase: {
+                                /** @example HP16015479281022 */
+                                transaction: string;
+                                /** @example APPROVED */
+                                status: string;
+                                offer?: {
+                                    /**
+                                     * @description Offer code used to determine institution assignment
+                                     * @example d9to7y3w
+                                     */
+                                    code?: string;
+                                };
+                            };
+                            product: {
+                                id?: number;
+                                name?: string;
+                                /** Format: uuid */
+                                ucode?: string;
+                            };
+                            subscription?: {
+                                subscriber?: {
+                                    code?: string;
+                                };
+                                plan?: {
+                                    name?: string;
+                                    id?: number;
+                                };
+                                status?: string;
+                            };
+                        };
+                    };
+                };
+            };
             responses: {
-                /** @description User synchronized successfully */
+                /** @description Webhook event processed successfully */
                 200: {
                     headers: {
                         [name: string]: unknown;
@@ -10286,15 +10843,21 @@ interface paths {
                         "application/json": {
                             /** @example success */
                             status?: string;
-                            data?: components["schemas"]["User"];
-                            /** @example User synchronized with Keycloak successfully */
-                            message?: string;
+                            /**
+                             * @description Action taken for the event
+                             * @example user_creation_enqueued
+                             * @enum {string}
+                             */
+                            action?: "user_creation_enqueued" | "user_deactivated" | "user_not_found" | "event_ignored";
+                            /**
+                             * Format: uuid
+                             * @description Request ID for tracking (only on user_creation_enqueued)
+                             * @example 550e8400-e29b-41d4-a716-446655440000
+                             */
+                            requestId?: string;
                         };
                     };
                 };
-                400: components["responses"]["BadRequest"];
-                401: components["responses"]["Unauthorized"];
-                404: components["responses"]["NotFound"];
                 500: components["responses"]["ServerError"];
             };
         };
@@ -11549,6 +12112,20 @@ interface components {
                 };
             };
         };
+        ForgotPasswordRequest: {
+            /**
+             * Format: email
+             * @description User's email address for password reset
+             * @example user@example.com
+             */
+            email: string;
+        };
+        ForgotPasswordResponse: {
+            /** @example success */
+            status?: string;
+            /** @example If this email is registered, you will receive password reset instructions. */
+            message?: string;
+        };
         CreateInstitutionClassroomDto: {
             /**
              * Format: uuid
@@ -11729,10 +12306,14 @@ interface components {
              * @description Product ID associated with this seat
              */
             productId?: string;
+            /** @description Total number of seat codes for this seat */
+            total?: number;
             /** @description Available quantity for this group in the institution */
             availableQuantity?: number;
             /** @description Number of users currently assigned to this group in the institution */
             usedQuantity?: number;
+            /** @description Number of reserved seat codes without active registration */
+            reservedQuantity?: number;
             /** Format: date-time */
             createdAt?: string;
             /** Format: date-time */
@@ -12221,6 +12802,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
@@ -13102,6 +13704,7 @@ declare function createUserService(apiClient: AcademeApiClient): {
         requestBody: {
             content: {
                 "application/json": {
+                    email?: string;
                     firstName?: string;
                     lastName?: string;
                     phone?: string;
@@ -13156,6 +13759,7 @@ declare function createUserService(apiClient: AcademeApiClient): {
         requestBody: {
             content: {
                 "application/json": {
+                    email?: string;
                     firstName?: string;
                     lastName?: string;
                     phone?: string;
@@ -13406,6 +14010,7 @@ type UpdateCurriculumGridDto = components["schemas"]["UpdateCurriculumGridDto"];
 type CreateCurriculumPeriodDto = components["schemas"]["CreateCurriculumPeriodDto"];
 type UpdateCurriculumPeriodDto = components["schemas"]["UpdateCurriculumPeriodDto"];
 type GetInstitutionUsersQuery = paths["/institutions/{institutionId}/users"]["get"]["parameters"]["query"];
+type GetInstitutionClassroomsQuery = paths["/institutions/{institutionId}/classrooms"]["get"]["parameters"]["query"];
 declare function createInstitutionService(apiClient: AcademeApiClient): {
     getAll(): Promise<openapi_fetch.FetchResponse<{
         parameters: {
@@ -13721,9 +14326,7 @@ declare function createInstitutionService(apiClient: AcademeApiClient): {
             productId?: string;
         };
     }, `${string}/${string}`>>;
-    getClassrooms(institutionId: string, options?: {
-        includeUserCount?: boolean;
-    }): Promise<openapi_fetch.FetchResponse<{
+    getClassrooms(institutionId: string, options?: GetInstitutionClassroomsQuery): Promise<openapi_fetch.FetchResponse<{
         parameters: {
             query?: {
                 includeUserCount?: boolean;
@@ -18516,11 +19119,16 @@ type QuizService = ReturnType<typeof createQuizService>;
 
 type CreateCertificateDto = components["schemas"]["CreateCertificateDto"];
 type UpdateCertificateDto = components["schemas"]["UpdateCertificateDto"];
+type GenerateCertificateDto = components["schemas"]["GenerateCertificateDto"];
 declare function createCertificateService(apiClient: AcademeApiClient): {
     /**
-     * List all certificates
+     * Get current user's certificates
      */
-    getMe(): Promise<openapi_fetch.FetchResponse<{
+    getMyCertificates(query?: {
+        search?: string;
+        page?: number;
+        limit?: number;
+    }): Promise<openapi_fetch.FetchResponse<{
         parameters: {
             query?: {
                 search?: components["parameters"]["search"];
@@ -18553,12 +19161,32 @@ declare function createCertificateService(apiClient: AcademeApiClient): {
             401: components["responses"]["Unauthorized"];
             500: components["responses"]["ServerError"];
         };
-    }, openapi_fetch.FetchOptions<{
+    }, {
+        params: {
+            query: {
+                search?: string;
+                page?: number;
+                limit?: number;
+            } | undefined;
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * List all certificates
+     */
+    getAll(query?: {
+        userId?: string;
+        search?: string;
+        page?: number;
+        limit?: number;
+        includeCourse?: boolean;
+    }): Promise<openapi_fetch.FetchResponse<{
         parameters: {
             query?: {
+                userId?: string;
                 search?: components["parameters"]["search"];
                 page?: components["parameters"]["page"];
                 limit?: components["parameters"]["limit"];
+                includeCourse?: boolean;
             };
             header?: never;
             path?: never;
@@ -18586,12 +19214,27 @@ declare function createCertificateService(apiClient: AcademeApiClient): {
             401: components["responses"]["Unauthorized"];
             500: components["responses"]["ServerError"];
         };
-    }> | undefined, `${string}/${string}`>>;
-    getAll(): Promise<openapi_fetch.FetchResponse<{
+    }, {
+        params: {
+            query: {
+                userId?: string;
+                search?: string;
+                page?: number;
+                limit?: number;
+                includeCourse?: boolean;
+            } | undefined;
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Get certificate by ID
+     */
+    getById(id: string): Promise<openapi_fetch.FetchResponse<{
         parameters: {
             query?: never;
             header?: never;
-            path?: never;
+            path: {
+                id: components["parameters"]["id"];
+            };
             cookie?: never;
         };
         requestBody?: never;
@@ -18603,90 +19246,71 @@ declare function createCertificateService(apiClient: AcademeApiClient): {
                 content: {
                     "application/json": {
                         status?: string;
-                        data?: components["schemas"]["Certificate"][];
+                        data?: components["schemas"]["Certificate"];
                     };
                 };
             };
+            400: components["responses"]["BadRequest"];
             401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
             500: components["responses"]["ServerError"];
         };
-    }, openapi_fetch.FetchOptions<{
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Download all certificates of a given user as a single merged PDF
+     */
+    downloadAll(userId: string): Promise<openapi_fetch.FetchResponse<{
         parameters: {
             query?: never;
             header?: never;
-            path?: never;
+            path: {
+                userId: string;
+            };
             cookie?: never;
         };
         requestBody?: never;
         responses: {
             200: {
                 headers: {
+                    "Content-Disposition"?: string;
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": {
-                        status?: string;
-                        data?: components["schemas"]["Certificate"][];
-                    };
+                    "application/pdf": string;
                 };
             };
             401: components["responses"]["Unauthorized"];
-            500: components["responses"]["ServerError"];
-        };
-    }> | undefined, `${string}/${string}`>>;
-    /**
-     * Get current user's certificates
-     */
-    getMyCertificates(query?: {
-        search?: string;
-        page?: number;
-        limit?: number;
-    }): Promise<openapi_fetch.FetchResponse<{
-        parameters: {
-            query?: {
-                search?: components["parameters"]["search"];
-                page?: components["parameters"]["page"];
-                limit?: components["parameters"]["limit"];
-            };
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            200: {
+            404: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
                     "application/json": {
                         status?: string;
-                        data?: components["schemas"]["Certificate"][];
-                        meta?: {
-                            total?: number;
-                            page?: number;
-                            limit?: number;
-                            totalPages?: number;
-                        };
+                        message?: string;
                     };
                 };
             };
-            401: components["responses"]["Unauthorized"];
             500: components["responses"]["ServerError"];
         };
     }, {
         params: {
-            query: {
-                search?: string;
-                page?: number;
-                limit?: number;
-            } | undefined;
+            path: {
+                userId: string;
+            };
         };
+        parseAs: "blob";
     }, `${string}/${string}`>>;
     /**
-     * Get certificate by ID
+     * Download certificate PDF
      */
-    getById(id: string): Promise<openapi_fetch.FetchResponse<{
+    download(id: string): Promise<openapi_fetch.FetchResponse<{
         parameters: {
             query?: never;
             header?: never;
@@ -18702,14 +19326,11 @@ declare function createCertificateService(apiClient: AcademeApiClient): {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": {
-                        status?: string;
-                        data?: components["schemas"]["Certificate"];
-                    };
+                    "application/pdf": string;
                 };
             };
-            400: components["responses"]["BadRequest"];
             401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
             500: components["responses"]["ServerError"];
         };
@@ -18744,7 +19365,6 @@ declare function createCertificateService(apiClient: AcademeApiClient): {
                     "application/json": {
                         status?: string;
                         data?: components["schemas"]["Certificate"];
-                        message?: string;
                     };
                 };
             };
@@ -18761,6 +19381,52 @@ declare function createCertificateService(apiClient: AcademeApiClient): {
             url?: string;
         };
     }, `${string}/${string}`>>;
+    /**
+     * Generate a certificate PDF server-side
+     */
+    generate(data: GenerateCertificateDto): Promise<openapi_fetch.FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["GenerateCertificateDto"];
+            };
+        };
+        responses: {
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: {
+                            certificate?: components["schemas"]["Certificate"];
+                            pdfUrl?: string;
+                        };
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        body: {
+            userId: string;
+            quizAttemptId?: string;
+            certificateTemplateId: string;
+            studentName: string;
+            quizTitle: string;
+            score?: number;
+            certificateNumber?: string;
+            issuedAt?: string;
+        };
+    }, `${string}/${string}`>>;
     /**
      * Update certificate
      */
@@ -18787,7 +19453,6 @@ declare function createCertificateService(apiClient: AcademeApiClient): {
                     "application/json": {
                         status?: string;
                         data?: components["schemas"]["Certificate"];
-                        message?: string;
                     };
                 };
             };
@@ -18823,16 +19488,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"];