academe-kit 0.9.6 → 0.9.7

package/dist/types/services/CertificateService.d.ts

@@ -132,7 +132,6 @@ export declare function createCertificateService(apiClient: AcademeApiClient): {
                     "application/json": {
                         status?: string;
                         data?: components["schemas"]["Certificate"];
-                        message?: string;
                     };
                 };
             };
@@ -179,7 +178,6 @@ export declare function createCertificateService(apiClient: AcademeApiClient): {
                     "application/json": {
                         status?: string;
                         data?: components["schemas"]["Certificate"];
-                        message?: string;
                     };
                 };
             };
@@ -215,16 +213,11 @@ export 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"];

package/dist/types/services/SubmissionService.d.ts

@@ -0,0 +1,349 @@
+import type { AcademeApiClient } from "./index";
+import type { paths } from "../types/academe-api";
+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"];
+export declare function createSubmissionService(apiClient: AcademeApiClient): {
+    /**
+     * List submissions with filters and pagination
+     */
+    getAll(params?: GetSubmissionsParams): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: {
+                challengeId?: string;
+                userId?: string;
+                groupId?: string;
+                institutionId?: string;
+                status?: "submitted" | "ai_evaluated" | "approved" | "rejected";
+                page?: import("../types/academe-api").components["parameters"]["page"];
+                limit?: import("../types/academe-api").components["parameters"]["limit"];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: import("../types/academe-api").components["schemas"]["Submission"][];
+                        meta?: import("../types/academe-api").components["schemas"]["PaginationMeta"];
+                    };
+                };
+            };
+            401: import("../types/academe-api").components["responses"]["Unauthorized"];
+        };
+    }, {
+        params: {
+            query: {
+                challengeId?: string;
+                userId?: string;
+                groupId?: string;
+                institutionId?: string;
+                status?: "submitted" | "ai_evaluated" | "approved" | "rejected";
+                page?: import("../types/academe-api").components["parameters"]["page"];
+                limit?: import("../types/academe-api").components["parameters"]["limit"];
+            } | undefined;
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Get submission with files and per-criterion scores
+     */
+    getById(id: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: import("../types/academe-api").components["parameters"]["id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: import("../types/academe-api").components["schemas"]["Submission"] & {
+                            files?: import("../types/academe-api").components["schemas"]["SubmissionFile"][];
+                            criterionScores?: import("../types/academe-api").components["schemas"]["SubmissionCriterionScore"][];
+                        };
+                    };
+                };
+            };
+            401: import("../types/academe-api").components["responses"]["Unauthorized"];
+            404: import("../types/academe-api").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<import("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?: import("../types/academe-api").components["schemas"]["Submission"];
+                    };
+                };
+            };
+            400: import("../types/academe-api").components["responses"]["BadRequest"];
+            403: import("../types/academe-api").components["responses"]["Forbidden"];
+            404: import("../types/academe-api").components["responses"]["NotFound"];
+            409: import("../types/academe-api").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<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: import("../types/academe-api").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?: import("../types/academe-api").components["schemas"]["SubmissionFile"][];
+                    };
+                };
+            };
+            400: import("../types/academe-api").components["responses"]["BadRequest"];
+            404: import("../types/academe-api").components["responses"]["NotFound"];
+            409: import("../types/academe-api").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<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: import("../types/academe-api").components["parameters"]["id"];
+                fileRowId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            400: import("../types/academe-api").components["responses"]["BadRequest"];
+            404: import("../types/academe-api").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<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: import("../types/academe-api").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?: import("../types/academe-api").components["schemas"]["Submission"];
+                    };
+                };
+            };
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import("../types/academe-api").components["schemas"]["Error"];
+                };
+            };
+            404: import("../types/academe-api").components["responses"]["NotFound"];
+            409: import("../types/academe-api").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<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: import("../types/academe-api").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?: import("../types/academe-api").components["schemas"]["Submission"];
+                    };
+                };
+            };
+            400: import("../types/academe-api").components["responses"]["BadRequest"];
+            404: import("../types/academe-api").components["responses"]["NotFound"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+        body: {
+            status: "approved" | "rejected";
+            teacherScore?: number;
+            teacherFeedback?: string;
+        };
+    }, `${string}/${string}`>>;
+};
+export type SubmissionService = ReturnType<typeof createSubmissionService>;
+export {};

package/dist/types/services/index.d.ts

@@ -20,6 +20,7 @@ import { type CategoryService } from './CategoryService';
 import { type StorageFileService } from './StorageFileService';
 import { type ChallengeService } from './ChallengeService';
 import { type StepService } from './StepService';
+import { type SubmissionService } from './SubmissionService';
 export type AcademeApiClient = ReturnType<typeof createClient<paths>>;
 export declare function createAcademeApiClient(baseUrl: string): AcademeApiClient;
 export interface AcademeServices {
@@ -43,6 +44,7 @@ export interface AcademeServices {
     storageFile: StorageFileService;
     challenge: ChallengeService;
     step: StepService;
+    submission: SubmissionService;
 }
 export declare function createAcademeServices(apiClient: AcademeApiClient): AcademeServices;
 export { createUserService, type UserService } from "./userService";
@@ -64,3 +66,4 @@ export { createCategoryService, type CategoryService } from './CategoryService';
 export { createStorageFileService, type StorageFileService } from './StorageFileService';
 export { createChallengeService, type ChallengeService } from './ChallengeService';
 export { createStepService, type StepService } from './StepService';
+export { createSubmissionService, type SubmissionService } from './SubmissionService';