academe-kit 0.3.7 → 0.3.9

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

@@ -0,0 +1,456 @@
+import type { AcademeApiClient } from "./index";
+import type { components, paths } from "../types/academe-api";
+type CreateSeatCodesDto = components["schemas"]["CreateSeatCodesDto"];
+type UpdateSeatCodeDto = components["schemas"]["UpdateSeatCodeDto"];
+type SendCodeDto = components["schemas"]["SendCodeDto"];
+export type GetSeatCodesQueryParams = paths["/institutions/{institutionId}/seat-codes"]["get"]["parameters"]["query"];
+export declare function createSeatCodeService(apiClient: AcademeApiClient): {
+    getAll(institutionId: string, options?: GetSeatCodesQueryParams): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: {
+                seatId?: string;
+                search?: string;
+                status?: "reserved" | "active" | "available";
+                page?: number;
+                limit?: number;
+            };
+            header?: never;
+            path: {
+                institutionId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["SeatCode"][];
+                        meta?: {
+                            total?: number;
+                            page?: number;
+                            limit?: number;
+                            totalPages?: number;
+                        };
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                institutionId: string;
+            };
+            query: {
+                seatId?: string;
+                search?: string;
+                status?: "reserved" | "active" | "available";
+                page?: number;
+                limit?: number;
+            } | undefined;
+        };
+    }, `${string}/${string}`>>;
+    generate(institutionId: string, data: CreateSeatCodesDto): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                institutionId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateSeatCodesDto"];
+            };
+        };
+        responses: {
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["SeatCode"][];
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                institutionId: string;
+            };
+        };
+        body: {
+            seatId: string;
+            quantity: number;
+        };
+    }, `${string}/${string}`>>;
+    getById(institutionId: string, seatCodeId: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                institutionId: string;
+                seatCodeId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["SeatCode"];
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                institutionId: string;
+                seatCodeId: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    update(institutionId: string, seatCodeId: string, data: UpdateSeatCodeDto): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                institutionId: string;
+                seatCodeId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateSeatCodeDto"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["SeatCode"];
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                institutionId: string;
+                seatCodeId: string;
+            };
+        };
+        body: {
+            isReserved?: boolean;
+        };
+    }, `${string}/${string}`>>;
+    delete(institutionId: string, seatCodeId: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                institutionId: string;
+                seatCodeId: 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: {
+                institutionId: string;
+                seatCodeId: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    getBySeatId(institutionId: string, seatId: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                institutionId: string;
+                seatId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["SeatCode"][];
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                institutionId: string;
+                seatId: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    deleteAllBySeatId(institutionId: string, seatId: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                institutionId: string;
+                seatId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: {
+                            deletedCount?: number;
+                        };
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                institutionId: string;
+                seatId: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    getAvailableBySeatId(institutionId: string, seatId: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                institutionId: string;
+                seatId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["SeatCode"][];
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                institutionId: string;
+                seatId: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    validate(code: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                code: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["SeatCodeWithInstitution"];
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                code: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    reserve(code: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                code: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["SeatCodeWithInstitution"];
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        message?: string;
+                    };
+                };
+            };
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                code: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    sendCode(data: SendCodeDto): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SendCodeDto"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["SeatCodeWithInstitution"];
+                    };
+                };
+            };
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        message?: string;
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        message?: string;
+                    };
+                };
+            };
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        body: {
+            phone: string;
+            name?: string;
+            code?: string;
+            seatId?: string;
+        };
+    }, `${string}/${string}`>>;
+};
+export type SeatCodeService = ReturnType<typeof createSeatCodeService>;
+export {};

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

@@ -1,16 +1,7 @@
-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'];
+import type { AcademeApiClient } from "./index";
+import type { components } from "../types/academe-api";
+type CreateUserBody = components["schemas"]["CreateUserDto"];
+type UpdateUserDto = components["schemas"]["UpdateUserDto"];
 type GetUsersParams = {
     email?: string;
     document?: number;
@@ -163,9 +154,12 @@ export declare function createUserService(apiClient: AcademeApiClient): {
                     email: string;
                     password: string;
                     phone?: string;
-                    document?: number;
+                    document: string;
                     gender?: "male" | "female" | "other";
                     birthdate?: string;
+                    seatCodeId?: string;
+                    groupId?: string;
+                    institutionId?: string;
                 };
             };
         };
@@ -181,8 +175,100 @@ export declare function createUserService(apiClient: AcademeApiClient): {
                     };
                 };
             };
-            400: components["responses"]["BadRequest"];
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
             401: components["responses"]["Unauthorized"];
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        body: {
+            firstName: string;
+            lastName: string;
+            email: string;
+            password: string;
+            phone?: string;
+            document: string;
+            gender?: "male" | "female" | "other";
+            birthdate?: string;
+            groupId?: string;
+            institutionId?: string;
+            guardianId?: string;
+        };
+    }, `${string}/${string}`>>;
+    createPublicUser(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: string;
+                    gender?: "male" | "female" | "other";
+                    birthdate?: string;
+                    seatCodeId?: string;
+                    groupId?: string;
+                    institutionId?: string;
+                };
+            };
+        };
+        responses: {
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["User"];
+                    };
+                };
+            };
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
             409: {
                 headers: {
                     [name: string]: unknown;
@@ -194,7 +280,19 @@ export declare function createUserService(apiClient: AcademeApiClient): {
             500: components["responses"]["ServerError"];
         };
     }, {
-        body: CreateUserBody;
+        body: {
+            firstName: string;
+            lastName: string;
+            email: string;
+            password: string;
+            phone?: string;
+            document: string;
+            gender?: "male" | "female" | "other";
+            birthdate?: string;
+            groupId?: string;
+            institutionId?: string;
+            guardianId?: string;
+        };
     }, `${string}/${string}`>>;
     /**
      * Update user information

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

@@ -1,13 +1,19 @@
-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';
+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";
+import { type AuthService } from "./AuthService";
+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";
 export type AcademeApiClient = ReturnType<typeof createClient<paths>>;
 export declare function createAcademeApiClient(baseUrl: string): AcademeApiClient;
 export interface AcademeServices {
@@ -19,12 +25,24 @@ export interface AcademeServices {
     serie: SerieService;
     shift: ShiftService;
     guardian: GuardianService;
+    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';
-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';
+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";
+export { createAuthService, type AuthService } from "./AuthService";
+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";