academe-kit 0.9.2 → 0.9.4

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

@@ -0,0 +1,748 @@
+import type { AcademeApiClient } from "./index";
+import type { paths } from "../types/academe-api";
+type GetChallengesParams = paths["/challenges"]["get"]["parameters"]["query"];
+type CreateChallengeBody = paths["/challenges"]["post"]["requestBody"]["content"]["application/json"];
+type UpdateChallengeBody = paths["/challenges/{id}"]["patch"]["requestBody"]["content"]["application/json"];
+type CloneChallengeBody = paths["/challenges/{id}/clone"]["post"]["requestBody"]["content"]["application/json"];
+type CreateChallengeStepBody = paths["/challenges/{id}/steps"]["post"]["requestBody"]["content"]["application/json"];
+export interface UpdateChallengeStepBody {
+    name?: string;
+    description?: string;
+    index?: number;
+    courseId?: string;
+    courseModuleId?: string;
+    tutorialTitle?: string;
+    tutorialDescription?: string;
+    tutorialVideoUrl?: string;
+    isActive?: boolean;
+}
+type CreateChallengeMediaBody = paths["/challenges/{id}/media"]["post"]["requestBody"]["content"]["application/json"];
+type CreateDeliveryStepBody = paths["/challenges/{id}/delivery-steps"]["post"]["requestBody"]["content"]["application/json"];
+export interface UpdateDeliveryStepBody {
+    title?: string;
+    description?: string;
+    index?: number;
+}
+type CreateEvaluationCriterionBody = paths["/challenges/{id}/evaluation-criteria"]["post"]["requestBody"]["content"]["application/json"];
+export interface UpdateEvaluationCriterionBody {
+    title?: string;
+    description?: string;
+    index?: number;
+}
+export declare function createChallengeService(apiClient: AcademeApiClient): {
+    /**
+     * List challenges with filters and pagination
+     */
+    getAll(params?: GetChallengesParams): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: {
+                institutionId?: string;
+                serieId?: string;
+                isActive?: boolean;
+                templatesOnly?: boolean;
+                search?: string;
+                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"]["Challenge"][];
+                        meta?: import("../types/academe-api").components["schemas"]["PaginationMeta"];
+                    };
+                };
+            };
+            401: import("../types/academe-api").components["responses"]["Unauthorized"];
+            500: import("../types/academe-api").components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            query: {
+                institutionId?: string;
+                serieId?: string;
+                isActive?: boolean;
+                templatesOnly?: boolean;
+                search?: string;
+                page?: import("../types/academe-api").components["parameters"]["page"];
+                limit?: import("../types/academe-api").components["parameters"]["limit"];
+            } | undefined;
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Get challenge by ID with full details (steps, media, deliverySteps, evaluationCriteria)
+     */
+    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"]["Challenge"] & {
+                            steps?: import("../types/academe-api").components["schemas"]["ChallengeStep"][];
+                            media?: import("../types/academe-api").components["schemas"]["ChallengeMedia"][];
+                            deliverySteps?: import("../types/academe-api").components["schemas"]["ChallengeDeliveryStep"][];
+                            evaluationCriteria?: import("../types/academe-api").components["schemas"]["ChallengeEvaluationCriterion"][];
+                        };
+                    };
+                };
+            };
+            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 challenge
+     */
+    create(data: CreateChallengeBody): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    title: string;
+                    description: string;
+                    objective?: string;
+                    isGroup?: boolean;
+                    maxGroupMembers?: number;
+                    isInviteOnly?: boolean;
+                    institutionId?: string | null;
+                    serieId?: string;
+                    index?: number;
+                    templateChallengeId?: string;
+                    submissionType: "images" | "videos" | "audio" | "files" | "links";
+                    maxSubmissionsAttempts?: number;
+                    coverFileId?: string;
+                    audioFileId?: string;
+                    exampleFileId?: string;
+                    isActive?: boolean;
+                };
+            };
+        };
+        responses: {
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: import("../types/academe-api").components["schemas"]["Challenge"];
+                    };
+                };
+            };
+            400: import("../types/academe-api").components["responses"]["BadRequest"];
+            401: import("../types/academe-api").components["responses"]["Unauthorized"];
+            409: import("../types/academe-api").components["responses"]["Conflict"];
+            500: import("../types/academe-api").components["responses"]["ServerError"];
+        };
+    }, {
+        body: {
+            title: string;
+            description: string;
+            objective?: string;
+            isGroup?: boolean;
+            maxGroupMembers?: number;
+            isInviteOnly?: boolean;
+            institutionId?: string | null;
+            serieId?: string;
+            index?: number;
+            templateChallengeId?: string;
+            submissionType: "images" | "videos" | "audio" | "files" | "links";
+            maxSubmissionsAttempts?: number;
+            coverFileId?: string;
+            audioFileId?: string;
+            exampleFileId?: string;
+            isActive?: boolean;
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Update a challenge
+     */
+    update(id: string, data: UpdateChallengeBody): 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": {
+                    title?: string;
+                    description?: string;
+                    objective?: string;
+                    isGroup?: boolean;
+                    maxGroupMembers?: number;
+                    isInviteOnly?: boolean;
+                    serieId?: string;
+                    index?: number;
+                    submissionType?: "images" | "videos" | "audio" | "files" | "links";
+                    maxSubmissionsAttempts?: number;
+                    coverFileId?: string;
+                    audioFileId?: string;
+                    exampleFileId?: string;
+                    isActive?: boolean;
+                };
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: import("../types/academe-api").components["schemas"]["Challenge"];
+                    };
+                };
+            };
+            400: import("../types/academe-api").components["responses"]["BadRequest"];
+            401: import("../types/academe-api").components["responses"]["Unauthorized"];
+            404: import("../types/academe-api").components["responses"]["NotFound"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+        body: {
+            title?: string;
+            description?: string;
+            objective?: string;
+            isGroup?: boolean;
+            maxGroupMembers?: number;
+            isInviteOnly?: boolean;
+            serieId?: string;
+            index?: number;
+            submissionType?: "images" | "videos" | "audio" | "files" | "links";
+            maxSubmissionsAttempts?: number;
+            coverFileId?: string;
+            audioFileId?: string;
+            exampleFileId?: string;
+            isActive?: boolean;
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Soft-delete a challenge (sets is_active=false)
+     */
+    delete(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: {
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            401: import("../types/academe-api").components["responses"]["Unauthorized"];
+            404: import("../types/academe-api").components["responses"]["NotFound"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Clone a global template into an institution
+     */
+    clone(id: string, data: CloneChallengeBody): 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": {
+                    institutionId: string;
+                    title?: string;
+                };
+            };
+        };
+        responses: {
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: import("../types/academe-api").components["schemas"]["Challenge"];
+                    };
+                };
+            };
+            400: import("../types/academe-api").components["responses"]["BadRequest"];
+            404: import("../types/academe-api").components["responses"]["NotFound"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+        body: {
+            institutionId: string;
+            title?: string;
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Add a step to the challenge
+     */
+    addStep(challengeId: string, data: CreateChallengeStepBody): 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": {
+                    stepId: string;
+                    name: string;
+                    description?: string;
+                    index: number;
+                    courseId?: string;
+                    courseModuleId?: string;
+                    tutorialTitle?: string;
+                    tutorialDescription?: string;
+                    tutorialVideoUrl?: string;
+                    isActive?: boolean;
+                };
+            };
+        };
+        responses: {
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: import("../types/academe-api").components["schemas"]["ChallengeStep"];
+                    };
+                };
+            };
+            400: import("../types/academe-api").components["responses"]["BadRequest"];
+            409: import("../types/academe-api").components["responses"]["Conflict"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+        body: {
+            stepId: string;
+            name: string;
+            description?: string;
+            index: number;
+            courseId?: string;
+            courseModuleId?: string;
+            tutorialTitle?: string;
+            tutorialDescription?: string;
+            tutorialVideoUrl?: string;
+            isActive?: boolean;
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Update a challenge step
+     */
+    updateStep(challengeId: string, stepId: string, data: UpdateChallengeStepBody): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: import("../types/academe-api").components["parameters"]["id"];
+                subId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: import("../types/academe-api").components["schemas"]["ChallengeStep"];
+                    };
+                };
+            };
+            404: import("../types/academe-api").components["responses"]["NotFound"];
+        };
+    }, never, `${string}/${string}`>>;
+    /**
+     * Remove a challenge step
+     */
+    removeStep(challengeId: string, stepId: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: import("../types/academe-api").components["parameters"]["id"];
+                subId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            404: import("../types/academe-api").components["responses"]["NotFound"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+                subId: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Attach a media file to the challenge
+     */
+    addMedia(challengeId: string, data: CreateChallengeMediaBody): 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": {
+                    fileId: string;
+                    index?: number;
+                };
+            };
+        };
+        responses: {
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: import("../types/academe-api").components["schemas"]["ChallengeMedia"];
+                    };
+                };
+            };
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+        body: {
+            fileId: string;
+            index?: number;
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Remove a media item
+     */
+    removeMedia(challengeId: string, mediaId: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: import("../types/academe-api").components["parameters"]["id"];
+                subId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            404: import("../types/academe-api").components["responses"]["NotFound"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+                subId: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Add a delivery checklist item
+     */
+    addDeliveryStep(challengeId: string, data: CreateDeliveryStepBody): 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": {
+                    title: string;
+                    description?: string;
+                    index?: number;
+                };
+            };
+        };
+        responses: {
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: import("../types/academe-api").components["schemas"]["ChallengeDeliveryStep"];
+                    };
+                };
+            };
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+        body: {
+            title: string;
+            description?: string;
+            index?: number;
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Update a delivery checklist item
+     */
+    updateDeliveryStep(challengeId: string, deliveryStepId: string, data: UpdateDeliveryStepBody): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: import("../types/academe-api").components["parameters"]["id"];
+                subId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: import("../types/academe-api").components["schemas"]["ChallengeDeliveryStep"];
+                    };
+                };
+            };
+            404: import("../types/academe-api").components["responses"]["NotFound"];
+        };
+    }, never, `${string}/${string}`>>;
+    /**
+     * Remove a delivery checklist item
+     */
+    removeDeliveryStep(challengeId: string, deliveryStepId: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: import("../types/academe-api").components["parameters"]["id"];
+                subId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            404: import("../types/academe-api").components["responses"]["NotFound"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+                subId: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Add an evaluation criterion
+     */
+    addCriterion(challengeId: string, data: CreateEvaluationCriterionBody): 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": {
+                    title: string;
+                    description?: string;
+                    index?: number;
+                };
+            };
+        };
+        responses: {
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: import("../types/academe-api").components["schemas"]["ChallengeEvaluationCriterion"];
+                    };
+                };
+            };
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+        body: {
+            title: string;
+            description?: string;
+            index?: number;
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Update an evaluation criterion
+     */
+    updateCriterion(challengeId: string, criterionId: string, data: UpdateEvaluationCriterionBody): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: import("../types/academe-api").components["parameters"]["id"];
+                subId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: import("../types/academe-api").components["schemas"]["ChallengeEvaluationCriterion"];
+                    };
+                };
+            };
+            404: import("../types/academe-api").components["responses"]["NotFound"];
+        };
+    }, never, `${string}/${string}`>>;
+    /**
+     * Remove an evaluation criterion
+     */
+    removeCriterion(challengeId: string, criterionId: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: import("../types/academe-api").components["parameters"]["id"];
+                subId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            404: import("../types/academe-api").components["responses"]["NotFound"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+                subId: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+};
+export type ChallengeService = ReturnType<typeof createChallengeService>;
+export {};