academe-kit 0.1.9 → 0.2.2

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

@@ -0,0 +1,438 @@
+import type { AcademeApiClient } from './index';
+import type { components } from '../types/academe-api';
+type CreateUserBody = {
+    firstName: string;
+    lastName: string;
+    email: string;
+    password: string;
+    phone?: string;
+    document?: number;
+    gender?: 'male' | 'female' | 'other';
+    birthdate?: string;
+};
+type UpdateUserDto = components['schemas']['UpdateUserDto'];
+type GetUsersParams = {
+    email?: string;
+    document?: number;
+    only_students?: boolean;
+    institution_id?: string;
+    search?: string;
+    page?: number;
+    limit?: number;
+};
+export declare function createUserService(apiClient: AcademeApiClient): {
+    /**
+     * Get current authenticated user
+     */
+    getMe(): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["User"];
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["ServerError"];
+        };
+    }, import("openapi-fetch").FetchOptions<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["User"];
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["ServerError"];
+        };
+    }> | undefined, `${string}/${string}`>>;
+    /**
+     * List all users with optional filters
+     */
+    getUsers(params?: GetUsersParams): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: {
+                email?: string;
+                document?: number;
+                only_students?: boolean;
+                institution_id?: string;
+                search?: string;
+                page?: components["parameters"]["page"];
+                limit?: components["parameters"]["limit"];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UserListResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            query: GetUsersParams | undefined;
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Get user by ID
+     */
+    getUserById(id: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["User"];
+                    };
+                };
+            };
+            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 user
+     */
+    createUser(body: CreateUserBody): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    firstName: string;
+                    lastName: string;
+                    email: string;
+                    password: string;
+                    phone?: string;
+                    document?: number;
+                    gender?: "male" | "female" | "other";
+                    birthdate?: string;
+                };
+            };
+        };
+        responses: {
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["User"];
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        body: CreateUserBody;
+    }, `${string}/${string}`>>;
+    /**
+     * Update user information
+     */
+    updateUser(id: string, body: UpdateUserDto): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["id"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateUserDto"];
+            };
+        };
+        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"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+        body: {
+            firstName?: string;
+            lastName?: string;
+            email?: string;
+            phone?: string;
+            document?: number;
+            gender?: "male" | "female" | "other";
+            birthdate?: string;
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Delete user
+     */
+    deleteUser(id: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        message?: string;
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Get user's groups
+     */
+    getUserGroups(id: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["Group"][];
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Get user's certificates
+     */
+    getUserCertificates(id: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["Certificate"][];
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Get user's institutions
+     */
+    getUserInstitutions(id: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["Institution"][];
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Sync user with Keycloak
+     */
+    syncUser(id: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        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"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+};
+export type UserService = ReturnType<typeof createUserService>;
+export {};

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

@@ -0,0 +1,30 @@
+import type { paths } from '../types/academe-api';
+import createClient from 'openapi-fetch';
+import { type UserService } from './UserService';
+import { type InstitutionService } from './InstitutionService';
+import { type ReportService } from './ReportService';
+import { type ClassroomService } from './ClassroomService';
+import { type OrganizationService } from './OrganizationService';
+import { type SerieService } from './SerieService';
+import { type ShiftService } from './ShiftService';
+import { type GuardianService } from './GuardianService';
+export type AcademeApiClient = ReturnType<typeof createClient<paths>>;
+export declare function createAcademeApiClient(baseUrl: string): AcademeApiClient;
+export interface AcademeServices {
+    user: UserService;
+    institution: InstitutionService;
+    report: ReportService;
+    classroom: ClassroomService;
+    organization: OrganizationService;
+    serie: SerieService;
+    shift: ShiftService;
+    guardian: GuardianService;
+}
+export declare function createAcademeServices(apiClient: AcademeApiClient): AcademeServices;
+export { createUserService, type UserService } from './UserService';
+export { createReportService, type ReportService } from './ReportService';
+export { createClassroomService, type ClassroomService } from './ClassroomService';
+export { createOrganizationService, type OrganizationService } from './OrganizationService';
+export { createSerieService, type SerieService } from './SerieService';
+export { createShiftService, type ShiftService } from './ShiftService';
+export { createGuardianService, type GuardianService } from './GuardianService';