academe-kit 0.9.3 → 0.9.5

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

@@ -0,0 +1,215 @@
+import type { AcademeApiClient } from "./index";
+import type { paths } from "../types/academe-api";
+type GetStepsParams = paths["/steps"]["get"]["parameters"]["query"];
+type CreateStepBody = paths["/steps"]["post"]["requestBody"]["content"]["application/json"];
+type UpdateStepBody = paths["/steps/{id}"]["patch"]["requestBody"]["content"]["application/json"];
+export declare function createStepService(apiClient: AcademeApiClient): {
+    /**
+     * List the step catalog (filterable by type / isActive)
+     */
+    getAll(params?: GetStepsParams): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: {
+                type?: "challenge" | "course" | "tutorial" | "publication" | "evaluation" | "certificate";
+                isActive?: boolean;
+            };
+            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"]["Step"][];
+                    };
+                };
+            };
+            401: import("../types/academe-api").components["responses"]["Unauthorized"];
+            500: import("../types/academe-api").components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            query: {
+                type?: "challenge" | "course" | "tutorial" | "publication" | "evaluation" | "certificate";
+                isActive?: boolean;
+            } | undefined;
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Get a step by ID
+     */
+    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"]["Step"];
+                    };
+                };
+            };
+            400: import("../types/academe-api").components["responses"]["BadRequest"];
+            401: import("../types/academe-api").components["responses"]["Unauthorized"];
+            404: import("../types/academe-api").components["responses"]["NotFound"];
+            500: import("../types/academe-api").components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Create a new step in the catalog
+     */
+    create(data: CreateStepBody): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    name: string;
+                    color: string;
+                    icon: string;
+                    type: "challenge" | "course" | "tutorial" | "publication" | "evaluation" | "certificate";
+                    isActive?: boolean;
+                };
+            };
+        };
+        responses: {
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: import("../types/academe-api").components["schemas"]["Step"];
+                    };
+                };
+            };
+            400: import("../types/academe-api").components["responses"]["BadRequest"];
+            401: import("../types/academe-api").components["responses"]["Unauthorized"];
+            500: import("../types/academe-api").components["responses"]["ServerError"];
+        };
+    }, {
+        body: {
+            name: string;
+            color: string;
+            icon: string;
+            type: "challenge" | "course" | "tutorial" | "publication" | "evaluation" | "certificate";
+            isActive?: boolean;
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Update a step
+     */
+    update(id: string, data: UpdateStepBody): 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": {
+                    name?: string;
+                    color?: string;
+                    icon?: string;
+                    type?: "challenge" | "course" | "tutorial" | "publication" | "evaluation" | "certificate";
+                    isActive?: boolean;
+                };
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: import("../types/academe-api").components["schemas"]["Step"];
+                    };
+                };
+            };
+            400: import("../types/academe-api").components["responses"]["BadRequest"];
+            401: import("../types/academe-api").components["responses"]["Unauthorized"];
+            404: import("../types/academe-api").components["responses"]["NotFound"];
+            500: import("../types/academe-api").components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+        body: {
+            name?: string;
+            color?: string;
+            icon?: string;
+            type?: "challenge" | "course" | "tutorial" | "publication" | "evaluation" | "certificate";
+            isActive?: boolean;
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Delete a step
+     */
+    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;
+            };
+            400: import("../types/academe-api").components["responses"]["BadRequest"];
+            401: import("../types/academe-api").components["responses"]["Unauthorized"];
+            404: import("../types/academe-api").components["responses"]["NotFound"];
+            500: import("../types/academe-api").components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+};
+export type StepService = ReturnType<typeof createStepService>;
+export {};

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

@@ -18,6 +18,8 @@ import { type ProductService } from "./ProductService";
 import { type CourseService } from './CourseService';
 import { type CategoryService } from './CategoryService';
 import { type StorageFileService } from './StorageFileService';
+import { type ChallengeService } from './ChallengeService';
+import { type StepService } from './StepService';
 export type AcademeApiClient = ReturnType<typeof createClient<paths>>;
 export declare function createAcademeApiClient(baseUrl: string): AcademeApiClient;
 export interface AcademeServices {
@@ -39,6 +41,8 @@ export interface AcademeServices {
     seatCode: SeatCodeService;
     product: ProductService;
     storageFile: StorageFileService;
+    challenge: ChallengeService;
+    step: StepService;
 }
 export declare function createAcademeServices(apiClient: AcademeApiClient): AcademeServices;
 export { createUserService, type UserService } from "./userService";
@@ -58,3 +62,5 @@ export { createProductService, type ProductService } from "./ProductService";
 export { createCourseService, type CourseService } from './CourseService';
 export { createCategoryService, type CategoryService } from './CategoryService';
 export { createStorageFileService, type StorageFileService } from './StorageFileService';
+export { createChallengeService, type ChallengeService } from './ChallengeService';
+export { createStepService, type StepService } from './StepService';

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

@@ -338,62 +338,9 @@ export declare function createUserService(apiClient: AcademeApiClient): {
             404: components["responses"]["NotFound"];
             500: components["responses"]["ServerError"];
         };
-    }, import("openapi-fetch").FetchOptions<{
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        requestBody: {
-            content: {
-                "application/json": {
-                    email?: string;
-                    firstName?: string;
-                    lastName?: string;
-                    phone?: string;
-                    document?: string;
-                    gender?: "male" | "female" | "other";
-                    birthdate?: string;
-                    avatarFileId?: string;
-                    address?: {
-                        address?: string;
-                        number?: number;
-                        zip?: string;
-                        neighborhood?: string;
-                        city?: string;
-                        state?: string;
-                        latitude?: number;
-                        longitude?: number;
-                    };
-                    pushToken?: {
-                        token: string;
-                        platform: "ios" | "android" | "web";
-                        deviceId?: string;
-                        provider?: "firebase" | "apns" | "fcm";
-                    };
-                };
-            };
-        };
-        responses: {
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": {
-                        status?: string;
-                        data?: components["schemas"]["User"];
-                        message?: string;
-                    };
-                };
-            };
-            400: components["responses"]["BadRequest"];
-            401: components["responses"]["Unauthorized"];
-            404: components["responses"]["NotFound"];
-            500: components["responses"]["ServerError"];
-        };
-    }>, `${string}/${string}`>>;
+    }, {
+        body: any;
+    }, `${string}/${string}`>>;
     /**
      * Delete user
      */