academe-kit 0.3.8 → 0.4.0

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

@@ -0,0 +1,225 @@
+import type { AcademeApiClient } from "./index";
+import type { components } from "../types/academe-api";
+type CreateProductBody = components["schemas"]["CreateProductDto"];
+type UpdateProductDto = components["schemas"]["UpdateProductDto"];
+type GetProductsParams = {
+    name?: string;
+    search?: string;
+    page?: number;
+    limit?: number;
+};
+export declare function createProductService(apiClient: AcademeApiClient): {
+    /**
+     * List all products with optional filters
+     */
+    getProducts(params?: GetProductsParams): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: {
+                name?: string;
+                search?: string;
+                page?: number;
+                limit?: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["Product"][];
+                        meta?: {
+                            total?: number;
+                            page?: number;
+                            limit?: number;
+                            totalPages?: number;
+                        };
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            query: GetProductsParams | undefined;
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Get product by ID
+     */
+    getProductById(id: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["Product"];
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Create a new product
+     */
+    createProduct(body: CreateProductBody): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateProductDto"];
+            };
+        };
+        responses: {
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["Product"];
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        message?: string;
+                    };
+                };
+            };
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        body: {
+            id?: string;
+            name: string;
+            description?: string;
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Update product information
+     */
+    updateProduct(id: string, body: UpdateProductDto): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateProductDto"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["Product"];
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+        body: {
+            name?: string;
+            description?: string;
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Delete product
+     */
+    deleteProduct(id: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+};
+export type ProductService = ReturnType<typeof createProductService>;
+export {};

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

@@ -214,6 +214,7 @@ export declare function createUserService(apiClient: AcademeApiClient): {
             birthdate?: string;
             groupId?: string;
             institutionId?: string;
+            guardianId?: string;
         };
     }, `${string}/${string}`>>;
     createPublicUser(body: CreateUserBody): Promise<import("openapi-fetch").FetchResponse<{
@@ -290,6 +291,7 @@ export declare function createUserService(apiClient: AcademeApiClient): {
             birthdate?: string;
             groupId?: string;
             institutionId?: string;
+            guardianId?: string;
         };
     }, `${string}/${string}`>>;
     /**

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

@@ -13,6 +13,8 @@ import { type GroupService } from "./GroupService";
 import { type QuizService } from "./QuizService";
 import { type CertificateService } from "./CertificateService";
 import { type SeatCodeService } from "./SeatCodeService";
+import { type ProductService } from "./ProductService";
+import { type CourseService } from './CourseService';
 export type AcademeApiClient = ReturnType<typeof createClient<paths>>;
 export declare function createAcademeApiClient(baseUrl: string): AcademeApiClient;
 export interface AcademeServices {
@@ -24,11 +26,13 @@ export interface AcademeServices {
     serie: SerieService;
     shift: ShiftService;
     guardian: GuardianService;
+    course: CourseService;
     auth: AuthService;
     group: GroupService;
     quiz: QuizService;
     certificate: CertificateService;
     seatCode: SeatCodeService;
+    product: ProductService;
 }
 export declare function createAcademeServices(apiClient: AcademeApiClient): AcademeServices;
 export { createUserService, type UserService } from "./UserService";
@@ -43,3 +47,5 @@ export { createGroupService, type GroupService } from "./GroupService";
 export { createQuizService, type QuizService } from "./QuizService";
 export { createCertificateService, type CertificateService } from "./CertificateService";
 export { createSeatCodeService, type SeatCodeService } from "./SeatCodeService";
+export { createProductService, type ProductService } from "./ProductService";
+export { createCourseService, type CourseService } from './CourseService';