@igrejanoah/noah-app 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,3105 @@
+import * as z from 'zod';
+import z__default from 'zod';
+
+declare const ListAttendanceRequestQuerySchema: z__default.ZodObject<{
+    studentId: z__default.ZodOptional<z__default.ZodInt>;
+    lessonId: z__default.ZodOptional<z__default.ZodInt>;
+    courseId: z__default.ZodOptional<z__default.ZodInt>;
+    editionId: z__default.ZodOptional<z__default.ZodInt>;
+}, z__default.z.core.$strip>;
+type ListAttendanceRequestQuery = z__default.infer<typeof ListAttendanceRequestQuerySchema>;
+declare const GetStudentAttendanceStatusRequestParamsSchema: z__default.ZodObject<{
+    studentId: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type GetStudentAttendanceStatusRequestParams = z__default.infer<typeof GetStudentAttendanceStatusRequestParamsSchema>;
+declare const GetStudentAttendanceStatusRequestQuerySchema: z__default.ZodUnion<readonly [z__default.ZodObject<{
+    courseId: z__default.ZodOptional<z__default.ZodInt>;
+    editionId: z__default.ZodOptional<z__default.ZodInt>;
+}, z__default.z.core.$strip>, z__default.ZodObject<{
+    courseId: z__default.ZodUndefined;
+    editionId: z__default.ZodUndefined;
+}, z__default.z.core.$strip>]>;
+type GetStudentAttendanceStatusRequestQuery = z__default.infer<typeof GetStudentAttendanceStatusRequestQuerySchema>;
+declare const GetLessonStatusRequestParamsSchema: z__default.ZodObject<{
+    lessonId: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type GetLessonStatusRequestParams = z__default.infer<typeof GetLessonStatusRequestParamsSchema>;
+declare const GetLessonsStatusBulkQuerySchema: z__default.ZodObject<{
+    lessonIds: z__default.ZodArray<z__default.ZodInt>;
+}, z__default.z.core.$strip>;
+type GetLessonsStatusBulkQuery = z__default.infer<typeof GetLessonsStatusBulkQuerySchema>;
+declare const AttendanceStatusSchema: z__default.ZodEnum<{
+    PRESENT: "PRESENT";
+    ABSENT: "ABSENT";
+    JUSTIFIED: "JUSTIFIED";
+}>;
+declare const AttendanceSchema: z__default.ZodObject<{
+    lessonId: z__default.ZodInt;
+    studentId: z__default.ZodInt;
+    status: z__default.ZodEnum<{
+        PRESENT: "PRESENT";
+        ABSENT: "ABSENT";
+        JUSTIFIED: "JUSTIFIED";
+    }>;
+}, z__default.z.core.$strip>;
+declare const UpdateAttendanceRequestBodySchema: z__default.ZodObject<{
+    lessonId: z__default.ZodInt;
+    studentId: z__default.ZodInt;
+    status: z__default.ZodEnum<{
+        PRESENT: "PRESENT";
+        ABSENT: "ABSENT";
+        JUSTIFIED: "JUSTIFIED";
+    }>;
+}, z__default.z.core.$strip>;
+type UpdateAttendenceRequestBody = z__default.infer<typeof UpdateAttendanceRequestBodySchema>;
+declare const DeleteAttendanceRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type DeleteAttendanceRequestParams = z__default.infer<typeof DeleteAttendanceRequestParamsSchema>;
+declare const CreateOrUpdateAttendancesBulkRequestBodySchema: z__default.ZodObject<{
+    lessonId: z__default.ZodInt;
+    attendances: z__default.ZodArray<z__default.ZodObject<{
+        studentId: z__default.ZodInt;
+        status: z__default.ZodEnum<{
+            readonly PRESENT: "PRESENT";
+            readonly ABSENT: "ABSENT";
+            readonly JUSTIFIED: "JUSTIFIED";
+        }>;
+    }, z__default.z.core.$strip>>;
+}, z__default.z.core.$strip>;
+type CreateOrUpdateAttendancesBulkRequestBody = z__default.infer<typeof CreateOrUpdateAttendancesBulkRequestBodySchema>;
+
+declare class Ok<T> {
+    readonly _tag = "ok";
+    value: T;
+    constructor(value: T);
+}
+declare class Err<E> {
+    readonly _tag = "err";
+    error: E;
+    constructor(error: E);
+}
+
+declare const CredentialsProvider: {
+    readonly FIREBASE: "FIREBASE";
+};
+type CredentialsProvider = (typeof CredentialsProvider)[keyof typeof CredentialsProvider];
+declare const Role: {
+    readonly USER: "USER";
+    readonly STUDENT: "STUDENT";
+    readonly TEACHER: "TEACHER";
+    readonly COORDINATOR: "COORDINATOR";
+    readonly ADMIN: "ADMIN";
+    readonly SUPERADMIN: "SUPERADMIN";
+};
+type Role = (typeof Role)[keyof typeof Role];
+declare const EditionStatus: {
+    readonly UPCOMING: "UPCOMING";
+    readonly ACTIVE: "ACTIVE";
+    readonly FINISHED: "FINISHED";
+};
+type EditionStatus = (typeof EditionStatus)[keyof typeof EditionStatus];
+declare const AttendanceStatus: {
+    readonly PRESENT: "PRESENT";
+    readonly ABSENT: "ABSENT";
+    readonly JUSTIFIED: "JUSTIFIED";
+};
+type AttendanceStatus = (typeof AttendanceStatus)[keyof typeof AttendanceStatus];
+declare const MaterialCategory: {
+    readonly GERAL: "GERAL";
+};
+type MaterialCategory = (typeof MaterialCategory)[keyof typeof MaterialCategory];
+declare const NotificationKind: {
+    readonly GENERAL: "GENERAL";
+    readonly REMINDER: "REMINDER";
+};
+type NotificationKind = (typeof NotificationKind)[keyof typeof NotificationKind];
+declare const ContentKind: {
+    readonly RECORDING: "RECORDING";
+    readonly SUPPORT: "SUPPORT";
+};
+type ContentKind = (typeof ContentKind)[keyof typeof ContentKind];
+declare const EnrollmentKind: {
+    readonly regular: "regular";
+    readonly reposicao: "reposicao";
+};
+type EnrollmentKind = (typeof EnrollmentKind)[keyof typeof EnrollmentKind];
+declare const PaymentStatus: {
+    readonly canceled: "canceled";
+    readonly pending: "pending";
+    readonly paid: "paid";
+};
+type PaymentStatus = (typeof PaymentStatus)[keyof typeof PaymentStatus];
+
+type BasicUserData = {
+    id: ID;
+    phone: bigint;
+    email: string | null;
+    roles: Role[];
+};
+type BasicRequest = {
+    headers: {
+        authorization?: string | undefined;
+    };
+    user?: BasicUserData | undefined;
+    params: unknown;
+    query: unknown;
+    body: unknown;
+};
+type AuthedRequest = Omit<BasicRequest, 'user'> & {
+    user: BasicUserData;
+};
+type TypedRequest<T extends {
+    params?: any;
+    query?: any;
+    body?: any;
+} = {}> = BasicRequest & {
+    params: 'params' extends keyof T ? T['params'] : unknown;
+    query: 'query' extends keyof T ? T['query'] : unknown;
+    body: 'body' extends keyof T ? T['body'] : unknown;
+};
+type TypedAuthedRequest<T extends {
+    params?: any;
+    query?: any;
+    body?: any;
+} = {}> = Omit<TypedRequest<T>, 'user'> & {
+    user: BasicUserData;
+};
+declare class UnauthenticatedError {
+    readonly _tag = "Unauthenticated";
+    message?: string;
+    constructor(message?: string);
+}
+declare class ForbiddenError {
+    readonly _tag = "Forbidden";
+    message?: string;
+    constructor(message?: string);
+}
+declare class UserNotFoundError {
+    readonly _tag = "UserNotFound";
+    message?: string;
+    constructor(message?: string);
+}
+declare class RoleRequiredError {
+    readonly _tag = "RoleRequired";
+    userRoles: Role[];
+    requiredRoles: Role[];
+    message?: string;
+    constructor(userRoles: Role[], requiredRoles: Role[], message?: string);
+}
+declare class ValidationError<W extends 'params' | 'body' | 'query', E> {
+    readonly _tag = "ValidationError";
+    where: W;
+    parseError: E;
+    message?: string;
+    constructor(where: W, parseError: E, message?: string);
+}
+declare class InternalServerError {
+    readonly _tag = "InternalServerError";
+    message: string;
+    constructor(message: string);
+}
+declare const IdSchema: z__default.ZodInt;
+type ID = z__default.infer<typeof IdSchema>;
+
+type AsyncReturn<T extends (arg0: any) => Promise<any>> = Awaited<ReturnType<T>>;
+
+declare const ListLessonsRequestQuerySchema: z__default.ZodUnion<readonly [z__default.ZodObject<{
+    startDate: z__default.ZodOptional<z__default.z.ZodCoercedDate<unknown>>;
+    endDate: z__default.ZodOptional<z__default.z.ZodCoercedDate<unknown>>;
+    teacherId: z__default.ZodOptional<z__default.ZodInt>;
+    courseId: z__default.ZodInt;
+    editionId: z__default.ZodInt;
+}, z__default.z.core.$strip>, z__default.ZodObject<{
+    startDate: z__default.ZodOptional<z__default.z.ZodCoercedDate<unknown>>;
+    endDate: z__default.ZodOptional<z__default.z.ZodCoercedDate<unknown>>;
+    teacherId: z__default.ZodOptional<z__default.ZodInt>;
+    courseId: z__default.ZodUndefined;
+    editionId: z__default.ZodUndefined;
+}, z__default.z.core.$strip>]>;
+type ListLessonsRequestQuery = z__default.infer<typeof ListLessonsRequestQuerySchema>;
+declare const GetLessonRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type GetLessonRequestParams = z__default.infer<typeof GetLessonRequestParamsSchema>;
+declare const CreateLessonRequestBodySchema: z__default.ZodUnion<readonly [z__default.ZodObject<{
+    courseId: z__default.ZodInt;
+    editionId: z__default.ZodInt;
+    date: z__default.z.ZodCoercedDate<unknown>;
+    title: z__default.ZodString;
+    teacherId: z__default.ZodInt;
+    liveUrl: z__default.ZodURL;
+    livePassword: z__default.ZodOptional<z__default.ZodString>;
+    liveStartTime: z__default.z.ZodISOTime;
+    liveEndTime: z__default.z.ZodISOTime;
+}, z__default.z.core.$strip>, z__default.ZodObject<{
+    courseId: z__default.ZodInt;
+    editionId: z__default.ZodInt;
+    date: z__default.z.ZodCoercedDate<unknown>;
+    title: z__default.ZodString;
+    teacherId: z__default.ZodInt;
+    liveUrl: z__default.ZodUndefined;
+    livePassword: z__default.ZodUndefined;
+    liveStartTime: z__default.ZodUndefined;
+    liveEndTime: z__default.ZodUndefined;
+}, z__default.z.core.$strip>]>;
+type CreateLessonRequestBody = z__default.infer<typeof CreateLessonRequestBodySchema>;
+declare const UpdateLessonRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type UpdateLessonRequestParams = z__default.infer<typeof UpdateLessonRequestParamsSchema>;
+declare const UpdateLessonRequestBodySchema: z__default.ZodObject<{
+    courseId: z__default.ZodOptional<z__default.ZodInt>;
+    editionId: z__default.ZodOptional<z__default.ZodInt>;
+    date: z__default.ZodOptional<z__default.z.ZodCoercedDate<unknown>>;
+    title: z__default.ZodOptional<z__default.ZodString>;
+    teacherId: z__default.ZodOptional<z__default.ZodInt>;
+    liveUrl: z__default.ZodOptional<z__default.ZodNullable<z__default.ZodURL>>;
+    livePassword: z__default.ZodOptional<z__default.ZodNullable<z__default.ZodString>>;
+    liveStartTime: z__default.ZodOptional<z__default.ZodNullable<z__default.z.ZodISOTime>>;
+    liveEndTime: z__default.ZodOptional<z__default.ZodNullable<z__default.z.ZodISOTime>>;
+}, z__default.z.core.$strip>;
+type UpdateLessonRequestBody = z__default.infer<typeof UpdateLessonRequestBodySchema>;
+declare const DeleteLessonRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type DeleteLessonRequestParams = z__default.infer<typeof DeleteLessonRequestParamsSchema>;
+
+declare const listLessonsRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    query: ListLessonsRequestQuery;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Ok<{
+    courseId: number;
+    editionId: number;
+    id: number;
+    createdAt: Date;
+    createdById: number;
+    updatedAt: Date;
+    updatedById: number;
+    date: Date;
+    title: string;
+    teacherId: number;
+    liveStartTime: Date | null;
+    liveEndTime: Date | null;
+    livePassword: string | null;
+    liveUrl: string | null;
+}[]> | Err<ValidationError<"query", z.ZodError<{
+    courseId: number;
+    editionId: number;
+    startDate?: Date;
+    endDate?: Date;
+    teacherId?: number;
+} | {
+    courseId: undefined;
+    editionId: undefined;
+    startDate?: Date;
+    endDate?: Date;
+    teacherId?: number;
+}>>>>;
+type ListLessonsResponseBody = AsyncReturn<typeof listLessonsRoute>;
+declare class LessonNotFoundError extends Error {
+    readonly _tag = "LessonNotFound";
+    id: ID;
+    message: string;
+    constructor(id: ID, message: string);
+}
+declare const getLessonRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: GetLessonRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<LessonNotFoundError> | Ok<{
+    courseId: number;
+    editionId: number;
+    id: number;
+    createdAt: Date;
+    createdById: number;
+    updatedAt: Date;
+    updatedById: number;
+    date: Date;
+    title: string;
+    teacherId: number;
+    liveStartTime: Date | null;
+    liveEndTime: Date | null;
+    livePassword: string | null;
+    liveUrl: string | null;
+}> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>>>;
+type GetLessonResponseBody = AsyncReturn<typeof getLessonRoute>;
+declare class LessonAssociatedDataDoesNotExistError extends Error {
+    readonly _tag = "LessonAssociatedDataDoesNotExist";
+    field: string;
+    message: string;
+    constructor(field: string, message: string);
+}
+declare const createLessonRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    body: CreateLessonRequestBody;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<LessonAssociatedDataDoesNotExistError> | Ok<{
+    message: "Aula criada com sucesso";
+    leson: {
+        courseId: number;
+        editionId: number;
+        id: number;
+        createdAt: Date;
+        createdById: number;
+        updatedAt: Date;
+        updatedById: number;
+        date: Date;
+        title: string;
+        teacherId: number;
+        liveStartTime: Date | null;
+        liveEndTime: Date | null;
+        livePassword: string | null;
+        liveUrl: string | null;
+    };
+}> | Err<ValidationError<"body", z.ZodError<{
+    courseId: number;
+    editionId: number;
+    date: Date;
+    title: string;
+    teacherId: number;
+    liveUrl: string;
+    liveStartTime: string;
+    liveEndTime: string;
+    livePassword?: string;
+} | {
+    courseId: number;
+    editionId: number;
+    date: Date;
+    title: string;
+    teacherId: number;
+    liveUrl: undefined;
+    livePassword: undefined;
+    liveStartTime: undefined;
+    liveEndTime: undefined;
+}>>>>;
+type CreateLessonResponseBody = AsyncReturn<typeof createLessonRoute>;
+declare class InconsistentLivePropertiesError extends Error {
+    readonly _tag = "InconsistentLiveProperties";
+    message: string;
+    constructor(message: string);
+}
+declare const updateLessonRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: UpdateLessonRequestParams;
+    body: UpdateLessonRequestBody;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<LessonNotFoundError> | Err<LessonAssociatedDataDoesNotExistError> | Err<InconsistentLivePropertiesError> | Ok<{
+    message: "Aula atualizada com sucesso";
+    lesson: {
+        courseId: number;
+        editionId: number;
+        id: number;
+        createdAt: Date;
+        createdById: number;
+        updatedAt: Date;
+        updatedById: number;
+        date: Date;
+        title: string;
+        teacherId: number;
+        liveStartTime: Date | null;
+        liveEndTime: Date | null;
+        livePassword: string | null;
+        liveUrl: string | null;
+    };
+}> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>> | Err<ValidationError<"body", z.ZodError<{
+    courseId?: number;
+    editionId?: number;
+    date?: Date;
+    title?: string;
+    teacherId?: number;
+    liveUrl?: string;
+    livePassword?: string;
+    liveStartTime?: string;
+    liveEndTime?: string;
+}>>>>;
+type UpdateLessonResponseBody = AsyncReturn<typeof updateLessonRoute>;
+declare class LessonHasAssociatedDataError extends Error {
+    readonly _tag = "LessonHasAssociatedData";
+    lessonId: ID;
+    field: string;
+    message: string;
+    constructor(lessonId: ID, field: string, message: string);
+}
+declare const deleteLessonRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: DeleteLessonRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<LessonNotFoundError> | Err<LessonHasAssociatedDataError> | Ok<{
+    message: "Aula removida com sucesso!";
+    lessonId: number;
+}> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>>>;
+type DeleteLessonResponseBody = AsyncReturn<typeof deleteLessonRoute>;
+
+declare const listAttendanceRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    query: ListAttendanceRequestQuery;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<ForbiddenError> | Err<InternalServerError> | Ok<{
+    studentId: number;
+    lessonId: number;
+    id: number;
+    status: AttendanceStatus;
+    createdAt: Date;
+    createdById: number;
+    updatedAt: Date;
+    updatedById: number;
+}[]> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<ValidationError<"query", z.ZodError<{
+    studentId?: number;
+    lessonId?: number;
+    courseId?: number;
+    editionId?: number;
+}>>> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError>>;
+type ListAttendenceResponseBody = AsyncReturn<typeof listAttendanceRoute>;
+declare const getLessonStatusRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: GetLessonStatusRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<LessonNotFoundError> | Ok<{
+    lessonId: number;
+    hasAttendance: boolean;
+    count: number;
+}> | Err<ValidationError<"params", z.ZodError<{
+    lessonId: number;
+}>>>>;
+type GetLessonStatusResponseBody = AsyncReturn<typeof getLessonStatusRoute>;
+declare const getLessonsStatusBulkRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    query: GetLessonsStatusBulkQuery;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<LessonNotFoundError> | Ok<Record<number, {
+    hasAttendance: boolean;
+    count: number;
+}>> | Err<ValidationError<"query", z.ZodError<{
+    lessonIds: number[];
+}>>>>;
+type GetLessonsStatusBulkResponse = AsyncReturn<typeof getLessonsStatusBulkRoute>;
+declare class AttendanceNotFoundError extends Error {
+    readonly _tag = "AttendanceNotFound";
+    id: ID;
+    message: string;
+    constructor(id: ID, message: string);
+}
+declare const getStudentAttendanceStatusRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: GetStudentAttendanceStatusRequestParams;
+    query: GetStudentAttendanceStatusRequestQuery;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<ForbiddenError> | Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Ok<{
+    studentId: number;
+    courseId: number | "all";
+    totalLessons: number;
+    present: number;
+    absent: number;
+    justified: number;
+    attendanceRate: number;
+    absenceRate: number;
+    isAtRisk: boolean;
+}> | Err<ValidationError<"params", z.ZodError<{
+    studentId: number;
+}>>> | Err<ValidationError<"query", z.ZodError<{
+    courseId?: number;
+    editionId?: number;
+} | {
+    courseId: undefined;
+    editionId: undefined;
+}>>>>;
+type GetStudentAttendanceStatusResponseBody = AsyncReturn<typeof getStudentAttendanceStatusRoute>;
+declare const updateAttendanceRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    body: UpdateAttendenceRequestBody;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Ok<{
+    id: number;
+}> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<ValidationError<"body", z.ZodError<{
+    lessonId: number;
+    studentId: number;
+    status: "PRESENT" | "ABSENT" | "JUSTIFIED";
+}>>>>;
+type UpdateAttendanceResponse = AsyncReturn<typeof updateAttendanceRoute>;
+declare const updateAttendancesBulkRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    body: CreateOrUpdateAttendancesBulkRequestBody;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<ForbiddenError> | Err<InternalServerError> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<LessonNotFoundError> | Ok<{
+    message: string;
+    count: number;
+    attendances: {
+        studentId: number;
+        lessonId: number;
+        id: number;
+        status: AttendanceStatus;
+        createdAt: Date;
+        createdById: number;
+        updatedAt: Date;
+        updatedById: number;
+    }[];
+}> | Err<ValidationError<"body", z.ZodError<{
+    lessonId: number;
+    attendances: {
+        studentId: number;
+        status: "PRESENT" | "ABSENT" | "JUSTIFIED";
+    }[];
+}>>>>;
+type CreateOrUpdateAttendancesBulkResponseBody = AsyncReturn<typeof updateAttendancesBulkRoute>;
+declare const deleteAttendanceRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: DeleteAttendanceRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<AttendanceNotFoundError> | Ok<{
+    message: string;
+}> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>>>;
+type DeleteAttendanceResponse = AsyncReturn<typeof deleteAttendanceRoute>;
+
+declare const VerifyPhoneRequestBodySchema: z__default.ZodObject<{
+    phone: z__default.ZodInt;
+}, z__default.z.core.$strip>;
+type VerifyPhoneRequestBody = z__default.infer<typeof VerifyPhoneRequestBodySchema>;
+declare const CreateCustomTokenRequestBodySchema: z__default.ZodObject<{
+    phone: z__default.ZodInt;
+}, z__default.z.core.$strip>;
+type CreateCustomTokenRequestBody = z__default.infer<typeof CreateCustomTokenRequestBodySchema>;
+
+declare class EmailNotLinked {
+    readonly _tag = "EmailNotLinked";
+    message: string;
+    constructor(message: string);
+}
+declare const verifyPhoneRoute: (req: Omit<TypedRequest<{
+    body: VerifyPhoneRequestBody;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+}) => Promise<Err<ValidationError<"params", z.ZodError<unknown>>> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<UserNotFoundError> | Ok<{
+    registered: boolean;
+    message: string;
+    userName: string;
+    roles: Role[];
+}> | Err<ValidationError<"body", z.ZodError<{
+    phone: number;
+}>>>>;
+type VerifyPhoneResponse = AsyncReturn<typeof verifyPhoneRoute>;
+declare const createCustomTokenRoute: (req: Omit<TypedRequest<{
+    body: CreateCustomTokenRequestBody;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<UserNotFoundError> | Err<EmailNotLinked> | Ok<{
+    customToken: unknown;
+    user: {
+        id: number;
+        credentialsProvider: "FIREBASE";
+        credentialsProviderId: string;
+        email: string;
+        phone: bigint;
+    };
+}> | Err<ValidationError<"body", z.ZodError<{
+    phone: number;
+}>>>>;
+type CreateCustomTokenResponse = AsyncReturn<typeof createCustomTokenRoute>;
+declare const getUserRoute$1: (req: Omit<AuthedRequest, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<UnauthenticatedError> | Ok<{
+    height: number;
+    id: number;
+    createdAt: Date;
+    createdById: number;
+    updatedAt: Date;
+    updatedById: number;
+    name: string;
+    credentialsProvider: CredentialsProvider;
+    credentialsProviderId: string | null;
+    email: string | null;
+    phone: bigint;
+    cellLeader: string | null;
+    discipler: string | null;
+    roles: Role[];
+    active: boolean;
+}>>;
+type GetUserResponse = AsyncReturn<typeof getUserRoute$1>;
+declare const validateRoute: (req: Omit<AuthedRequest, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<UnauthenticatedError> | Ok<{
+    valid: boolean;
+    user: {
+        height: number;
+        id: number;
+        createdAt: Date;
+        createdById: number;
+        updatedAt: Date;
+        updatedById: number;
+        name: string;
+        credentialsProvider: CredentialsProvider;
+        credentialsProviderId: string | null;
+        email: string | null;
+        phone: bigint;
+        cellLeader: string | null;
+        discipler: string | null;
+        roles: Role[];
+        active: boolean;
+    };
+}>>;
+type ValidateResponse = AsyncReturn<typeof validateRoute>;
+
+declare const ListContentsRequestQuerySchema: z__default.ZodObject<{
+    courseId: z__default.ZodOptional<z__default.ZodInt>;
+    kind: z__default.ZodOptional<z__default.ZodEnum<{
+        readonly RECORDING: "RECORDING";
+        readonly SUPPORT: "SUPPORT";
+    }>>;
+    category: z__default.ZodOptional<z__default.ZodString>;
+}, z__default.z.core.$strip>;
+type ListContentsRequestQuery = z__default.infer<typeof ListContentsRequestQuerySchema>;
+declare const GetContentRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type GetContentRequestParams = z__default.infer<typeof GetContentRequestParamsSchema>;
+declare const CreateContentRequestBodySchema: z__default.ZodObject<{
+    courseId: z__default.ZodInt;
+    title: z__default.ZodString;
+    url: z__default.ZodString;
+    description: z__default.ZodOptional<z__default.ZodString>;
+    kind: z__default.ZodEnum<{
+        readonly RECORDING: "RECORDING";
+        readonly SUPPORT: "SUPPORT";
+    }>;
+    category: z__default.ZodOptional<z__default.ZodString>;
+}, z__default.z.core.$strip>;
+type CreateContentRequestBody = z__default.infer<typeof CreateContentRequestBodySchema>;
+declare const UpdateContentRequestBodySchema: z__default.ZodObject<{
+    courseId: z__default.ZodOptional<z__default.ZodInt>;
+    title: z__default.ZodOptional<z__default.ZodString>;
+    url: z__default.ZodOptional<z__default.ZodString>;
+    description: z__default.ZodOptional<z__default.ZodString>;
+    kind: z__default.ZodOptional<z__default.ZodEnum<{
+        readonly RECORDING: "RECORDING";
+        readonly SUPPORT: "SUPPORT";
+    }>>;
+    category: z__default.ZodOptional<z__default.ZodNullable<z__default.ZodString>>;
+}, z__default.z.core.$strip>;
+type UpdateContentRequestBody = z__default.infer<typeof UpdateContentRequestBodySchema>;
+declare const UpdateContentRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type UpdateContentRequestParams = z__default.infer<typeof UpdateContentRequestParamsSchema>;
+declare const DeleteContentRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type DeleteContentRequestParams = z__default.infer<typeof DeleteContentRequestParamsSchema>;
+
+declare const GetCourseRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type GetCourseRequestParams = z__default.infer<typeof GetCourseRequestParamsSchema>;
+declare const CreateCourseRequestBodySchema: z__default.ZodObject<{
+    name: z__default.ZodString;
+    duration: z__default.ZodInt;
+}, z__default.z.core.$strip>;
+type CreateCourseRequestBody = z__default.infer<typeof CreateCourseRequestBodySchema>;
+declare const UpdateCourseRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type UpdateCourseRequestParams = z__default.infer<typeof UpdateCourseRequestParamsSchema>;
+declare const UpdateCourseRequestBodySchema: z__default.ZodObject<{
+    name: z__default.ZodOptional<z__default.ZodString>;
+    duration: z__default.ZodOptional<z__default.ZodInt>;
+}, z__default.z.core.$strip>;
+type UpdateCourseRequestBody = z__default.infer<typeof UpdateCourseRequestBodySchema>;
+declare const DeleteCourseRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type DeleteCourseRequestParams = z__default.infer<typeof DeleteCourseRequestParamsSchema>;
+
+declare const getCoursesRoute: (req: Omit<AuthedRequest, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<UnauthenticatedError> | Ok<{
+    id: number;
+    createdAt: Date;
+    createdById: number;
+    updatedAt: Date;
+    updatedById: number;
+    name: string;
+    duration: number;
+}[]>>;
+type GetCoursesResponse = AsyncReturn<typeof getCoursesRoute>;
+declare class CourseNotFoundError extends Error {
+    readonly _tag = "CourseNotFound";
+    id: ID;
+    message: string;
+    constructor(id: ID, message: string);
+}
+declare const getCourseRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: GetCourseRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<CourseNotFoundError> | Ok<{
+    id: number;
+    createdAt: Date;
+    createdById: number;
+    updatedAt: Date;
+    updatedById: number;
+    name: string;
+    duration: number;
+}> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>>>;
+type GetCourseResponse = AsyncReturn<typeof getCourseRoute>;
+declare const createCourseRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    body: CreateCourseRequestBody;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Ok<{
+    message: string;
+    course: {
+        id: number;
+        createdAt: Date;
+        createdById: number;
+        updatedAt: Date;
+        updatedById: number;
+        name: string;
+        duration: number;
+    };
+}> | Err<ValidationError<"body", z.ZodError<{
+    name: string;
+    duration: number;
+}>>>>;
+type CreateCourseResponse = AsyncReturn<typeof createCourseRoute>;
+declare const updateCourseRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: UpdateCourseRequestParams;
+    body: UpdateCourseRequestBody;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<CourseNotFoundError> | Ok<{
+    message: string;
+    course: {
+        id: number;
+        createdAt: Date;
+        createdById: number;
+        updatedAt: Date;
+        updatedById: number;
+        name: string;
+        duration: number;
+    };
+}> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>> | Err<ValidationError<"body", z.ZodError<{
+    name?: string;
+    duration?: number;
+}>>>>;
+type UpdateCourseResponse = AsyncReturn<typeof updateCourseRoute>;
+declare const deleteCourseRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: DeleteCourseRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<CourseNotFoundError> | Ok<{
+    message: string;
+}> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>>>;
+type DeleteCourseResponse = AsyncReturn<typeof deleteCourseRoute>;
+
+declare const getContentsRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    query: ListContentsRequestQuery;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Ok<{
+    courseId: number | null;
+    id: number;
+    createdAt: Date;
+    createdById: number;
+    updatedAt: Date;
+    updatedById: number;
+    title: string;
+    description: string;
+    kind: ContentKind;
+    category: string | null;
+    url: string;
+}[]> | Err<ValidationError<"query", z.ZodError<{
+    courseId?: number;
+    kind?: "RECORDING" | "SUPPORT";
+    category?: string;
+}>>>>;
+type ListContentsResponseBody = AsyncReturn<typeof getContentsRoute>;
+declare class ContentNotFoundError extends Error {
+    readonly _tag = "ContentNotFound";
+    message: string;
+    constructor(message: string);
+}
+declare const getContentRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: GetContentRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Ok<{
+    courseId: number | null;
+    id: number;
+    createdAt: Date;
+    createdById: number;
+    updatedAt: Date;
+    updatedById: number;
+    title: string;
+    description: string;
+    kind: ContentKind;
+    category: string | null;
+    url: string;
+}> | Err<ContentNotFoundError> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>>>;
+type GetContentResponse = AsyncReturn<typeof getContentRoute>;
+declare const createContentRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    body: CreateContentRequestBody;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<CourseNotFoundError> | Ok<{
+    message: string;
+    content: {
+        courseId: number | null;
+        id: number;
+        createdAt: Date;
+        createdById: number;
+        updatedAt: Date;
+        updatedById: number;
+        title: string;
+        description: string;
+        kind: ContentKind;
+        category: string | null;
+        url: string;
+    };
+}> | Err<ValidationError<"body", z.ZodError<{
+    courseId: number;
+    title: string;
+    url: string;
+    kind: "RECORDING" | "SUPPORT";
+    description?: string;
+    category?: string;
+}>>>>;
+type CreateContentResponseBody = AsyncReturn<typeof createContentRoute>;
+declare const updateContentRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: UpdateContentRequestParams;
+    body: UpdateContentRequestBody;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<CourseNotFoundError> | Ok<{
+    message: string;
+    content: {
+        courseId: number | null;
+        id: number;
+        createdAt: Date;
+        createdById: number;
+        updatedAt: Date;
+        updatedById: number;
+        title: string;
+        description: string;
+        kind: ContentKind;
+        category: string | null;
+        url: string;
+    };
+}> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>> | Err<ValidationError<"body", z.ZodError<{
+    courseId?: number;
+    title?: string;
+    url?: string;
+    description?: string;
+    kind?: "RECORDING" | "SUPPORT";
+    category?: string;
+}>>>>;
+type UpdateContentResponseBody = AsyncReturn<typeof updateContentRoute>;
+declare const deleteContentRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: DeleteContentRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Ok<{
+    message: string;
+}> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>>>;
+type DeleteContentResponseBody = AsyncReturn<typeof deleteContentRoute>;
+
+declare const ListEditionsRequestQuerySchema: z__default.ZodObject<{
+    status: z__default.ZodOptional<z__default.ZodEnum<{
+        readonly UPCOMING: "UPCOMING";
+        readonly ACTIVE: "ACTIVE";
+        readonly FINISHED: "FINISHED";
+    }>>;
+}, z__default.z.core.$strip>;
+type ListEditionsRequestQuery = z__default.infer<typeof ListEditionsRequestQuerySchema>;
+declare const GetEditionRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type GetEditionRequestParams = z__default.infer<typeof GetEditionRequestParamsSchema>;
+declare const CreateEditionRequestBodySchema: z__default.ZodObject<{
+    name: z__default.ZodString;
+    shortName: z__default.ZodString;
+    startDate: z__default.z.ZodCoercedDate<unknown>;
+    endDate: z__default.z.ZodCoercedDate<unknown>;
+    status: z__default.ZodEnum<{
+        readonly UPCOMING: "UPCOMING";
+        readonly ACTIVE: "ACTIVE";
+        readonly FINISHED: "FINISHED";
+    }>;
+}, z__default.z.core.$strip>;
+type CreateEditionRequestBody = z__default.infer<typeof CreateEditionRequestBodySchema>;
+declare const UpdateEditionRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type UpdateEditionRequestParams = z__default.infer<typeof UpdateEditionRequestParamsSchema>;
+declare const UpdateEditionRequestBodySchema: z__default.ZodObject<{
+    name: z__default.ZodOptional<z__default.ZodString>;
+    shortName: z__default.ZodOptional<z__default.ZodString>;
+    startDate: z__default.ZodOptional<z__default.z.ZodCoercedDate<unknown>>;
+    endDate: z__default.ZodOptional<z__default.z.ZodCoercedDate<unknown>>;
+    status: z__default.ZodOptional<z__default.ZodEnum<{
+        readonly UPCOMING: "UPCOMING";
+        readonly ACTIVE: "ACTIVE";
+        readonly FINISHED: "FINISHED";
+    }>>;
+}, z__default.z.core.$strip>;
+type UpdateEditionRequestBody = z__default.infer<typeof UpdateEditionRequestBodySchema>;
+declare const DeleteEditionRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type DeleteEditionRequestParams = z__default.infer<typeof DeleteEditionRequestParamsSchema>;
+declare const GetEditionStatsRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type GetEditionStatsRequestParams = z__default.infer<typeof GetEditionStatsRequestParamsSchema>;
+
+declare const listEditionsRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    query: ListEditionsRequestQuery;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Ok<{
+    id: number;
+    status: EditionStatus;
+    createdAt: Date;
+    createdById: number;
+    updatedAt: Date;
+    updatedById: number;
+    name: string;
+    shortName: string;
+    startDate: Date;
+    endDate: Date;
+}[]> | Err<ValidationError<"query", z.ZodError<{
+    status?: "UPCOMING" | "ACTIVE" | "FINISHED";
+}>>>>;
+type ListEditionsResponseBody = AsyncReturn<typeof listEditionsRoute>;
+declare class EditionNotFoundError extends Error {
+    readonly _tag = "EditionNotFound";
+    id: ID;
+    message: string;
+    constructor(id: ID, message: string);
+}
+declare const getEditionRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: GetEditionRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Ok<{
+    id: number;
+    status: EditionStatus;
+    createdAt: Date;
+    createdById: number;
+    updatedAt: Date;
+    updatedById: number;
+    name: string;
+    shortName: string;
+    startDate: Date;
+    endDate: Date;
+}> | Err<EditionNotFoundError> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>>>;
+type GetEditionResponseBody = AsyncReturn<typeof getEditionRoute>;
+declare const createEditionRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    body: CreateEditionRequestBody;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Ok<{
+    message: string;
+    edition: {
+        id: number;
+        status: EditionStatus;
+        createdAt: Date;
+        createdById: number;
+        updatedAt: Date;
+        updatedById: number;
+        name: string;
+        shortName: string;
+        startDate: Date;
+        endDate: Date;
+    };
+}> | Err<ValidationError<"body", z.ZodError<{
+    name: string;
+    shortName: string;
+    startDate: Date;
+    endDate: Date;
+    status: "UPCOMING" | "ACTIVE" | "FINISHED";
+}>>>>;
+type CreateEditionResponseBody = AsyncReturn<typeof createEditionRoute>;
+declare const updateEditionRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: UpdateEditionRequestParams;
+    body: UpdateEditionRequestBody;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<EditionNotFoundError> | Ok<{
+    message: string;
+    edition: {
+        id: number;
+        status: EditionStatus;
+        createdAt: Date;
+        createdById: number;
+        updatedAt: Date;
+        updatedById: number;
+        name: string;
+        shortName: string;
+        startDate: Date;
+        endDate: Date;
+    };
+}> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>> | Err<ValidationError<"body", z.ZodError<{
+    name?: string;
+    shortName?: string;
+    startDate?: Date;
+    endDate?: Date;
+    status?: "UPCOMING" | "ACTIVE" | "FINISHED";
+}>>>>;
+type UpdateEditionResponseBody = AsyncReturn<typeof updateEditionRoute>;
+declare class EditionHasAssociatedDataError extends Error {
+    readonly _tag = "EditionHasAssociatedData";
+    editionId: ID;
+    field: string;
+    message: string;
+    constructor(editionId: ID, field: string, message: string);
+}
+declare const deleteEditionRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: DeleteEditionRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<EditionNotFoundError> | Err<EditionHasAssociatedDataError> | Ok<{
+    message: string;
+    editionId: number;
+}> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>>>;
+type DeleteEditionResponseBody = AsyncReturn<typeof deleteEditionRoute>;
+declare const getEditionStatsRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: GetEditionStatsRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<EditionNotFoundError> | Ok<{
+    edition: {
+        lessons: any;
+        enrollments: any;
+        id: number;
+        status: EditionStatus;
+        createdAt: Date;
+        createdById: number;
+        updatedAt: Date;
+        updatedById: number;
+        name: string;
+        shortName: string;
+        startDate: Date;
+        endDate: Date;
+    };
+    stats: {
+        totalLessons: number;
+        totalStudents: number;
+        lessonsByCourse: Map<number, number>;
+    };
+}> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>>>;
+type GetEditionStatsResponseBody = AsyncReturn<typeof getEditionStatsRoute>;
+
+declare const ListEnrollmentsRequestQuerySchema: z__default.ZodObject<{
+    courseId: z__default.ZodOptional<z__default.ZodInt>;
+    editionId: z__default.ZodOptional<z__default.ZodInt>;
+}, z__default.z.core.$strip>;
+type ListEnrollmentsRequestQuery = z__default.infer<typeof ListEnrollmentsRequestQuerySchema>;
+declare const ListUserEnrollmentsRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type ListUserEnrollmentsRequestParams = z__default.infer<typeof ListUserEnrollmentsRequestParamsSchema>;
+declare const GetEnrollmentRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type GetEnrollmentRequestParams = z__default.infer<typeof GetEnrollmentRequestParamsSchema>;
+declare const CreateEnrollmentRequestBodySchema: z__default.ZodObject<{
+    enrollmentDate: z__default.ZodOptional<z__default.z.ZodCoercedDate<unknown>>;
+    kind: z__default.ZodEnum<{
+        readonly regular: "regular";
+        readonly reposicao: "reposicao";
+    }>;
+    paymentStatus: z__default.ZodOptional<z__default.ZodEnum<{
+        readonly canceled: "canceled";
+        readonly pending: "pending";
+        readonly paid: "paid";
+    }>>;
+    studentId: z__default.ZodInt;
+    courseId: z__default.ZodInt;
+    editionId: z__default.ZodInt;
+}, z__default.z.core.$strip>;
+type CreateEnrollmentRequestBody = z__default.infer<typeof CreateEnrollmentRequestBodySchema>;
+declare const UpdateEnrollmentRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type UpdateEnrollmentRequestParams = z__default.infer<typeof UpdateEnrollmentRequestParamsSchema>;
+declare const UpdateEnrollmentRequestBodySchema: z__default.ZodObject<{
+    enrollmentDate: z__default.ZodOptional<z__default.z.ZodCoercedDate<unknown>>;
+    kind: z__default.ZodOptional<z__default.ZodEnum<{
+        readonly regular: "regular";
+        readonly reposicao: "reposicao";
+    }>>;
+    paymentStatus: z__default.ZodOptional<z__default.ZodEnum<{
+        readonly canceled: "canceled";
+        readonly pending: "pending";
+        readonly paid: "paid";
+    }>>;
+    studentId: z__default.ZodOptional<z__default.ZodInt>;
+    courseId: z__default.ZodOptional<z__default.ZodInt>;
+    editionId: z__default.ZodOptional<z__default.ZodInt>;
+}, z__default.z.core.$strip>;
+type UpdateEnrollmentRequestBody = z__default.infer<typeof UpdateEnrollmentRequestBodySchema>;
+declare const DeleteEnrollmentRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type DeleteEnrollmentRequestParams = z__default.infer<typeof DeleteEnrollmentRequestParamsSchema>;
+
+declare const GetPaymentsSummaryRequestQuerySchema: z__default.ZodUnion<readonly [z__default.ZodObject<{
+    courseId: z__default.ZodInt;
+    editionId: z__default.ZodInt;
+}, z__default.z.core.$strip>, z__default.ZodObject<{
+    courseId: z__default.ZodUndefined;
+    editionId: z__default.ZodUndefined;
+}, z__default.z.core.$strip>]>;
+type GetPaymentsSummaryRequestQuery = z__default.infer<typeof GetPaymentsSummaryRequestQuerySchema>;
+declare const ListUsersRequestQuerySchema: z__default.ZodUnion<readonly [z__default.ZodObject<{
+    roles: z__default.ZodOptional<z__default.ZodArray<z__default.ZodEnum<{
+        readonly USER: "USER";
+        readonly STUDENT: "STUDENT";
+        readonly TEACHER: "TEACHER";
+        readonly COORDINATOR: "COORDINATOR";
+        readonly ADMIN: "ADMIN";
+        readonly SUPERADMIN: "SUPERADMIN";
+    }>>>;
+    courseId: z__default.ZodInt;
+    editionId: z__default.ZodInt;
+}, z__default.z.core.$strip>, z__default.ZodObject<{
+    roles: z__default.ZodOptional<z__default.ZodArray<z__default.ZodEnum<{
+        readonly USER: "USER";
+        readonly STUDENT: "STUDENT";
+        readonly TEACHER: "TEACHER";
+        readonly COORDINATOR: "COORDINATOR";
+        readonly ADMIN: "ADMIN";
+        readonly SUPERADMIN: "SUPERADMIN";
+    }>>>;
+    courseId: z__default.ZodUndefined;
+    editionId: z__default.ZodUndefined;
+}, z__default.z.core.$strip>]>;
+type ListUsersRequestQuery = z__default.infer<typeof ListUsersRequestQuerySchema>;
+declare const GetUserRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type GetUserRequestParams = z__default.infer<typeof GetUserRequestParamsSchema>;
+declare const CreateUserRequestBodySchema: z__default.ZodObject<{
+    phone: z__default.ZodInt;
+    email: z__default.ZodOptional<z__default.ZodEmail>;
+    name: z__default.ZodString;
+    cellLeader: z__default.ZodOptional<z__default.ZodString>;
+    discipler: z__default.ZodOptional<z__default.ZodString>;
+    height: z__default.ZodNumber;
+    roles: z__default.ZodOptional<z__default.ZodArray<z__default.ZodEnum<{
+        readonly USER: "USER";
+        readonly STUDENT: "STUDENT";
+        readonly TEACHER: "TEACHER";
+        readonly COORDINATOR: "COORDINATOR";
+        readonly ADMIN: "ADMIN";
+        readonly SUPERADMIN: "SUPERADMIN";
+    }>>>;
+}, z__default.z.core.$strip>;
+type CreateUserRequestBody = z__default.infer<typeof CreateUserRequestBodySchema>;
+declare const UpdateUserRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type UpdateUserRequestParams = z__default.infer<typeof UpdateUserRequestParamsSchema>;
+declare const UpdateUserRequestBodySchema: z__default.ZodObject<{
+    phone: z__default.ZodOptional<z__default.ZodInt>;
+    email: z__default.ZodOptional<z__default.ZodNullable<z__default.ZodEmail>>;
+    name: z__default.ZodOptional<z__default.ZodString>;
+    cellLeader: z__default.ZodOptional<z__default.ZodNullable<z__default.ZodString>>;
+    discipler: z__default.ZodOptional<z__default.ZodNullable<z__default.ZodString>>;
+    height: z__default.ZodOptional<z__default.ZodNumber>;
+    roles: z__default.ZodOptional<z__default.ZodArray<z__default.ZodEnum<{
+        readonly USER: "USER";
+        readonly STUDENT: "STUDENT";
+        readonly TEACHER: "TEACHER";
+        readonly COORDINATOR: "COORDINATOR";
+        readonly ADMIN: "ADMIN";
+        readonly SUPERADMIN: "SUPERADMIN";
+    }>>>;
+}, z__default.z.core.$strip>;
+type UpdateUserRequestBody = z__default.infer<typeof UpdateUserRequestBodySchema>;
+declare const PatchPaymentStatusRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type PatchPaymentStatusRequestParams = z__default.infer<typeof PatchPaymentStatusRequestParamsSchema>;
+declare const PatchPaymentStatusRequestBodySchema: z__default.ZodObject<{
+    courseId: z__default.ZodInt;
+    editionId: z__default.ZodInt;
+    paymentStatus: z__default.ZodEnum<{
+        readonly canceled: "canceled";
+        readonly pending: "pending";
+        readonly paid: "paid";
+    }>;
+}, z__default.z.core.$strip>;
+type PatchPaymentStatusRequestBody = z__default.infer<typeof PatchPaymentStatusRequestBodySchema>;
+declare const DeleteUserRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type DeleteUserRequestParams = z__default.infer<typeof DeleteUserRequestParamsSchema>;
+
+declare const getPaymentsSummaryRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    query: GetPaymentsSummaryRequestQuery;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Ok<{
+    byCourse: Map<number, Map<number, Map<PaymentStatus, number>>>;
+    clear(): void;
+    delete(key: PaymentStatus): boolean;
+    forEach(callbackfn: (value: number, key: PaymentStatus, map: Map<PaymentStatus, number>) => void, thisArg?: any): void;
+    get(key: PaymentStatus): number;
+    has(key: PaymentStatus): boolean;
+    set(key: PaymentStatus, value: number): Map<PaymentStatus, number>;
+    size: number;
+    entries(): MapIterator<[PaymentStatus, number]>;
+    keys(): MapIterator<PaymentStatus>;
+    values(): MapIterator<number>;
+    [Symbol.iterator](): MapIterator<[PaymentStatus, number]>;
+    [Symbol.toStringTag]: string;
+    total: number;
+}> | Err<ValidationError<"query", z.ZodError<{
+    courseId: number;
+    editionId: number;
+} | {
+    courseId: undefined;
+    editionId: undefined;
+}>>>>;
+type GetPaymentsSummaryResponseBody = AsyncReturn<typeof getPaymentsSummaryRoute>;
+declare const listUsersRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    query: ListUsersRequestQuery;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<ForbiddenError> | Err<InternalServerError> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Ok<{
+    height: number;
+    enrollments: {
+        studentId: number;
+        courseId: number;
+        editionId: number;
+        id: number;
+        createdAt: Date;
+        createdById: number;
+        updatedAt: Date;
+        updatedById: number;
+        enrollmentDate: Date;
+        enrollmentKind: EnrollmentKind;
+        paymentStatus: PaymentStatus;
+    }[];
+    id: number;
+    createdAt: Date;
+    createdById: number;
+    updatedAt: Date;
+    updatedById: number;
+    name: string;
+    credentialsProvider: CredentialsProvider;
+    credentialsProviderId: string | null;
+    email: string | null;
+    phone: bigint;
+    cellLeader: string | null;
+    discipler: string | null;
+    roles: Role[];
+    active: boolean;
+}[]> | Err<ValidationError<"query", z.ZodError<{
+    courseId: number;
+    editionId: number;
+    roles?: ("USER" | "STUDENT" | "TEACHER" | "COORDINATOR" | "ADMIN" | "SUPERADMIN")[];
+} | {
+    courseId: undefined;
+    editionId: undefined;
+    roles?: ("USER" | "STUDENT" | "TEACHER" | "COORDINATOR" | "ADMIN" | "SUPERADMIN")[];
+}>>>>;
+type ListUsersResponseBody = AsyncReturn<typeof listUsersRoute>;
+declare const getUserRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: GetUserRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<ForbiddenError> | Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<UserNotFoundError> | Ok<{
+    height: number;
+    id: number;
+    createdAt: Date;
+    createdById: number;
+    updatedAt: Date;
+    updatedById: number;
+    name: string;
+    credentialsProvider: CredentialsProvider;
+    credentialsProviderId: string | null;
+    email: string | null;
+    phone: bigint;
+    cellLeader: string | null;
+    discipler: string | null;
+    roles: Role[];
+    active: boolean;
+}> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>>>;
+type GetUserResponseBody = AsyncReturn<typeof getUserRoute>;
+declare class UserAlreadyExistsError extends Error {
+    readonly _tag = "UserAlreadyExists";
+    field: string;
+    message: string;
+    constructor(field: string, message: string);
+}
+declare const createUserRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    body: CreateUserRequestBody;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<UserAlreadyExistsError> | Ok<{
+    message: string;
+    user: {
+        height: number;
+        id: number;
+        createdAt: Date;
+        createdById: number;
+        updatedAt: Date;
+        updatedById: number;
+        name: string;
+        credentialsProvider: CredentialsProvider;
+        credentialsProviderId: string | null;
+        email: string | null;
+        phone: bigint;
+        cellLeader: string | null;
+        discipler: string | null;
+        roles: Role[];
+        active: boolean;
+    };
+}> | Err<ValidationError<"body", z.ZodError<{
+    phone: number;
+    name: string;
+    height: number;
+    email?: string;
+    cellLeader?: string;
+    discipler?: string;
+    roles?: ("USER" | "STUDENT" | "TEACHER" | "COORDINATOR" | "ADMIN" | "SUPERADMIN")[];
+}>>>>;
+type CreateUserResponseBody = AsyncReturn<typeof createUserRoute>;
+declare const updateUserRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: UpdateUserRequestParams;
+    body: UpdateUserRequestBody;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<ForbiddenError> | Err<InternalServerError> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<UserAlreadyExistsError> | Ok<{
+    message: string;
+    user: {
+        height: number;
+        id: number;
+        createdAt: Date;
+        createdById: number;
+        updatedAt: Date;
+        updatedById: number;
+        name: string;
+        credentialsProvider: CredentialsProvider;
+        credentialsProviderId: string | null;
+        email: string | null;
+        phone: bigint;
+        cellLeader: string | null;
+        discipler: string | null;
+        roles: Role[];
+        active: boolean;
+    };
+}> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>> | Err<ValidationError<"body", z.ZodError<{
+    phone?: number;
+    email?: string;
+    name?: string;
+    cellLeader?: string;
+    discipler?: string;
+    height?: number;
+    roles?: ("USER" | "STUDENT" | "TEACHER" | "COORDINATOR" | "ADMIN" | "SUPERADMIN")[];
+}>>>>;
+type UpdateUserResponseBody = AsyncReturn<typeof updateUserRoute>;
+declare class EnrollmentNotFoundError extends Error {
+    readonly _tag = "EnrollmentNotFound";
+    message: string;
+    constructor(message: string);
+}
+declare const patchPaymentStatusRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: PatchPaymentStatusRequestParams;
+    body: PatchPaymentStatusRequestBody;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<EnrollmentNotFoundError> | Ok<{
+    message: string;
+}> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>> | Err<ValidationError<"body", z.ZodError<{
+    courseId: number;
+    editionId: number;
+    paymentStatus: "canceled" | "pending" | "paid";
+}>>>>;
+type PatchPaymentStatusResponseBody = AsyncReturn<typeof patchPaymentStatusRoute>;
+declare const deleteUserRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: DeleteUserRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<ForbiddenError> | Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Ok<{
+    message: string;
+}> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>>>;
+type DeleteUserResponseBody = AsyncReturn<typeof deleteUserRoute>;
+
+declare const listEnrollmentsRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    query: ListEnrollmentsRequestQuery;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Ok<{
+    studentId: number;
+    courseId: number;
+    editionId: number;
+    id: number;
+    createdAt: Date;
+    createdById: number;
+    updatedAt: Date;
+    updatedById: number;
+    enrollmentDate: Date;
+    enrollmentKind: EnrollmentKind;
+    paymentStatus: PaymentStatus;
+}[]> | Err<ValidationError<"query", z.ZodError<{
+    courseId?: number;
+    editionId?: number;
+}>>>>;
+type ListEnrollmentsResponseBody = AsyncReturn<typeof listEnrollmentsRoute>;
+declare const listUserEnrollmentsRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: ListUserEnrollmentsRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<ForbiddenError> | Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Ok<{
+    studentId: number;
+    courseId: number;
+    editionId: number;
+    id: number;
+    createdAt: Date;
+    createdById: number;
+    updatedAt: Date;
+    updatedById: number;
+    enrollmentDate: Date;
+    enrollmentKind: EnrollmentKind;
+    paymentStatus: PaymentStatus;
+}[]> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>>>;
+type ListUserEnrollmentsResponseBody = AsyncReturn<typeof listUserEnrollmentsRoute>;
+declare const getEnrollmentRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: GetEnrollmentRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<ForbiddenError> | Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Ok<{
+    studentId: number;
+    courseId: number;
+    editionId: number;
+    id: number;
+    createdAt: Date;
+    createdById: number;
+    updatedAt: Date;
+    updatedById: number;
+    enrollmentDate: Date;
+    enrollmentKind: EnrollmentKind;
+    paymentStatus: PaymentStatus;
+}> | Err<EnrollmentNotFoundError> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>>>;
+type GetEnrollmentResponseBody = AsyncReturn<typeof getEnrollmentRoute>;
+declare const createEnrollmentRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    body: CreateEnrollmentRequestBody;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<UserNotFoundError> | Err<CourseNotFoundError> | Err<EditionNotFoundError> | Ok<{
+    message: string;
+    enrollment: {
+        studentId: number;
+        courseId: number;
+        editionId: number;
+        id: number;
+        createdAt: Date;
+        createdById: number;
+        updatedAt: Date;
+        updatedById: number;
+        enrollmentDate: Date;
+        enrollmentKind: EnrollmentKind;
+        paymentStatus: PaymentStatus;
+    };
+}> | Err<ValidationError<"body", z.ZodError<{
+    kind: "regular" | "reposicao";
+    studentId: number;
+    courseId: number;
+    editionId: number;
+    enrollmentDate?: Date;
+    paymentStatus?: "canceled" | "pending" | "paid";
+}>>>>;
+type CreateEnrollmentResponseBody = AsyncReturn<typeof createEnrollmentRoute>;
+declare const updateEnrollmentRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: UpdateEnrollmentRequestParams;
+    body: UpdateEnrollmentRequestBody;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<UserNotFoundError> | Err<CourseNotFoundError> | Err<EditionNotFoundError> | Err<EnrollmentNotFoundError> | Ok<{
+    message: string;
+    enrollment: {
+        studentId: number;
+        courseId: number;
+        editionId: number;
+        id: number;
+        createdAt: Date;
+        createdById: number;
+        updatedAt: Date;
+        updatedById: number;
+        enrollmentDate: Date;
+        enrollmentKind: EnrollmentKind;
+        paymentStatus: PaymentStatus;
+    };
+}> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>> | Err<ValidationError<"body", z.ZodError<{
+    enrollmentDate?: Date;
+    kind?: "regular" | "reposicao";
+    paymentStatus?: "canceled" | "pending" | "paid";
+    studentId?: number;
+    courseId?: number;
+    editionId?: number;
+}>>>>;
+type UpdateEnrollmentResponseBody = AsyncReturn<typeof updateEnrollmentRoute>;
+declare const deleteEnrollmentRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: DeleteEnrollmentRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Ok<{
+    message: string;
+}> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>>>;
+type DeleteEnrollmentResponseBody = AsyncReturn<typeof deleteEnrollmentRoute>;
+
+declare const ConfirmFileUploadRequestParamsSchema: z__default.ZodObject<{
+    fileId: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type ConfirmFileUploadRequestParams = z__default.infer<typeof ConfirmFileUploadRequestParamsSchema>;
+
+declare class FileNotFoundError extends Error {
+    readonly _tag = "FileNotFound";
+    id: ID;
+    message: string;
+    constructor(id: ID, message: string);
+}
+declare class FileWasNotUploadedError extends Error {
+    readonly _tag = "FileWasNotUploaded";
+    message: string;
+    constructor(message: string);
+}
+declare const confirmFileUploadRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: ConfirmFileUploadRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<ForbiddenError> | Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<FileNotFoundError> | Err<FileWasNotUploadedError> | Ok<{
+    message: string;
+}> | Err<ValidationError<"params", z.ZodError<{
+    fileId: number;
+}>>>>;
+type ConfirmFileUploadResponseBody = AsyncReturn<typeof confirmFileUploadRoute>;
+
+declare const ListJustificationsRequestQuerySchema: z__default.ZodUnion<readonly [z__default.ZodObject<{
+    courseId: z__default.ZodInt;
+    editionId: z__default.ZodInt;
+}, z__default.z.core.$strip>, z__default.ZodObject<{
+    courseId: z__default.ZodUndefined;
+    editionId: z__default.ZodUndefined;
+}, z__default.z.core.$strip>]>;
+type ListJustificationsRequestQuery = z__default.infer<typeof ListJustificationsRequestQuerySchema>;
+declare const UpdateJustificationRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type UpdateJustificationRequestParams = z__default.infer<typeof UpdateJustificationRequestParamsSchema>;
+declare const UpdateJustificationRequestBodySchema: z__default.ZodIntersection<z__default.ZodObject<{
+    attendanceId: z__default.ZodOptional<z__default.ZodInt>;
+    reason: z__default.ZodOptional<z__default.ZodString>;
+}, z__default.z.core.$strip>, z__default.ZodUnion<readonly [z__default.ZodObject<{
+    provider: z__default.ZodUndefined;
+    url: z__default.ZodUndefined;
+    mimetype: z__default.ZodUndefined;
+    kind: z__default.ZodUndefined;
+}, z__default.z.core.$strip>, z__default.ZodObject<{
+    provider: z__default.ZodLiteral<"PUBLIC_URL">;
+    url: z__default.ZodURL;
+    mimetype: z__default.ZodEnum<{
+        readonly PPTX: "PPTX";
+        readonly PDF: "PDF";
+    }>;
+    kind: z__default.ZodEnum<{
+        readonly DOCUMENT: "DOCUMENT";
+        readonly VIDEO: "VIDEO";
+    }>;
+}, z__default.z.core.$strip>, z__default.ZodObject<{
+    provider: z__default.ZodLiteral<"S3_GARAGE">;
+    url: z__default.ZodUndefined;
+    mimetype: z__default.ZodEnum<{
+        readonly PPTX: "PPTX";
+        readonly PDF: "PDF";
+    }>;
+    kind: z__default.ZodEnum<{
+        readonly DOCUMENT: "DOCUMENT";
+        readonly VIDEO: "VIDEO";
+    }>;
+}, z__default.z.core.$strip>]>>;
+type UpdateJustificationRequestBody = z__default.infer<typeof UpdateJustificationRequestBodySchema>;
+
+declare const listJustificationsRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    query: ListJustificationsRequestQuery;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Ok<any[]> | Err<ValidationError<"query", z.ZodError<{
+    courseId: number;
+    editionId: number;
+} | {
+    courseId: undefined;
+    editionId: undefined;
+}>>>>;
+type ListJustificationsResponseBody = AsyncReturn<typeof listJustificationsRoute>;
+declare class JustificationNotFoundError extends Error {
+    readonly _tag = "JustificationNotFound";
+    id: ID;
+    message: string;
+    constructor(id: ID, message: string);
+}
+declare const updateJustificationRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: UpdateJustificationRequestParams;
+    body: UpdateJustificationRequestBody;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<AttendanceNotFoundError> | Err<JustificationNotFoundError> | Ok<{
+    id: number;
+    createdAt: Date;
+    createdById: number;
+    updatedAt: Date;
+    updatedById: number;
+    reason: string | null;
+    attendanceId: number;
+    attachmentId: number | null;
+    confirmedAt: Date | null;
+    confirmedById: number | null;
+}> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>> | Err<ValidationError<"body", z.ZodError<{
+    attendanceId?: number;
+    reason?: string;
+} & ({
+    provider: undefined;
+    url: undefined;
+    mimetype: undefined;
+    kind: undefined;
+} | {
+    provider: "PUBLIC_URL";
+    url: string;
+    mimetype: "PPTX" | "PDF";
+    kind: "DOCUMENT" | "VIDEO";
+} | {
+    provider: "S3_GARAGE";
+    url: undefined;
+    mimetype: "PPTX" | "PDF";
+    kind: "DOCUMENT" | "VIDEO";
+})>>>>;
+type UpdateJustificationResponseBody = AsyncReturn<typeof updateJustificationRoute>;
+
+declare const SendMagicLinkRequestBodySchema: z__default.ZodObject<{
+    email: z__default.ZodEmail;
+}, z__default.z.core.$strip>;
+type SendMagicLinkRequestBody = z__default.infer<typeof SendMagicLinkRequestBodySchema>;
+declare const VerifyMagicLinkRequestQuerySchema: z__default.ZodObject<{
+    token: z__default.ZodString;
+}, z__default.z.core.$strip>;
+type VerifyMagicLinkRequestQuery = z__default.infer<typeof VerifyMagicLinkRequestQuerySchema>;
+
+declare const sendMagicLinkRoute: (req: Omit<TypedRequest<{
+    body: SendMagicLinkRequestBody;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<ValidationError<"query", z.ZodError<unknown>>> | Ok<{
+    success: boolean;
+    message: string;
+}> | Err<ValidationError<"body", z.ZodError<{
+    email: string;
+}>>>>;
+type SendMagicLinkResponseBody = AsyncReturn<typeof sendMagicLinkRoute>;
+declare class TokenNotFoundError extends Error {
+    readonly _tag = "TokenNotFound";
+    token: string;
+    message: string;
+    constructor(token: string, message: string);
+}
+declare class TokenExpiredError extends Error {
+    readonly _tag = "TokenExpired";
+    token: string;
+    message: string;
+    constructor(token: string, message: string);
+}
+declare class TokenAlreadyUsedError extends Error {
+    readonly _tag = "TokenAlreadyUsed";
+    token: string;
+    message: string;
+    constructor(token: string, message: string);
+}
+declare const verifyMagicLinkRoute: (req: Omit<TypedRequest<{
+    query: VerifyMagicLinkRequestQuery;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<TokenNotFoundError> | Err<TokenExpiredError> | Err<TokenAlreadyUsedError> | Ok<{
+    customToken: unknown;
+    user: {
+        id: number;
+        credentialsProvider: "FIREBASE";
+        credentialsProviderId: string;
+        email: string;
+        phone: bigint;
+    };
+}> | Err<ValidationError<"query", z.ZodError<{
+    token: string;
+}>>>>;
+type VerifyMagicLinkResponseBody = AsyncReturn<typeof verifyMagicLinkRoute>;
+declare const cleanupMagicLinksRoute: (req: Omit<Omit<BasicRequest, "user"> & {
+    user: BasicUserData;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Ok<{
+    message: string;
+    deleted: number;
+}>>;
+type CleanupMagicLinksResponseBody = AsyncReturn<typeof cleanupMagicLinksRoute>;
+
+declare const ListMaterialsRequestQuerySchema: z__default.ZodObject<{
+    courseId: z__default.ZodOptional<z__default.ZodInt>;
+    lessonId: z__default.ZodOptional<z__default.ZodInt>;
+    mimetype: z__default.ZodOptional<z__default.ZodEnum<{
+        readonly PPTX: "PPTX";
+        readonly PDF: "PDF";
+    }>>;
+    category: z__default.ZodOptional<z__default.ZodEnum<{
+        readonly GERAL: "GERAL";
+    }>>;
+    visibleToStudents: z__default.ZodOptional<z__default.ZodBoolean>;
+}, z__default.z.core.$strip>;
+type ListMaterialsRequestQuery = z__default.infer<typeof ListMaterialsRequestQuerySchema>;
+declare const GetMaterialRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type GetMaterialRequestParams = z__default.infer<typeof GetMaterialRequestParamsSchema>;
+declare const CreateMaterialRequestBodySchema: z__default.ZodIntersection<z__default.ZodObject<{
+    title: z__default.ZodString;
+    description: z__default.ZodString;
+    mimetype: z__default.ZodEnum<{
+        readonly PPTX: "PPTX";
+        readonly PDF: "PDF";
+    }>;
+    category: z__default.ZodEnum<{
+        readonly GERAL: "GERAL";
+    }>;
+    visibleToStudents: z__default.ZodBoolean;
+}, z__default.z.core.$strip>, z__default.ZodIntersection<z__default.ZodDiscriminatedUnion<[z__default.ZodObject<{
+    provider: z__default.ZodLiteral<"PUBLIC_URL">;
+    url: z__default.ZodURL;
+}, z__default.z.core.$strip>, z__default.ZodObject<{
+    provider: z__default.ZodLiteral<"S3_GARAGE">;
+    url: z__default.ZodUndefined;
+}, z__default.z.core.$strip>], "provider">, z__default.ZodUnion<readonly [z__default.ZodObject<{
+    courseId: z__default.ZodInt;
+    lessonId: z__default.ZodUndefined;
+}, z__default.z.core.$strip>, z__default.ZodObject<{
+    courseId: z__default.ZodUndefined;
+    lessonId: z__default.ZodInt;
+}, z__default.z.core.$strip>]>>>;
+type CreateMaterialRequestBody = z__default.infer<typeof CreateMaterialRequestBodySchema>;
+declare const UpdateMaterialRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type UpdateMaterialRequestParams = z__default.infer<typeof UpdateMaterialRequestParamsSchema>;
+declare const UpdateMaterialRequestBodySchema: z__default.ZodDiscriminatedUnion<[z__default.ZodObject<{
+    title: z__default.ZodOptional<z__default.ZodString>;
+    description: z__default.ZodOptional<z__default.ZodString>;
+    category: z__default.ZodOptional<z__default.ZodEnum<{
+        readonly GERAL: "GERAL";
+    }>>;
+    visibleToStudents: z__default.ZodOptional<z__default.ZodBoolean>;
+    courseId: z__default.ZodInt;
+    lessonId: z__default.ZodNull;
+}, z__default.z.core.$strip>, z__default.ZodObject<{
+    title: z__default.ZodOptional<z__default.ZodString>;
+    description: z__default.ZodOptional<z__default.ZodString>;
+    category: z__default.ZodOptional<z__default.ZodEnum<{
+        readonly GERAL: "GERAL";
+    }>>;
+    visibleToStudents: z__default.ZodOptional<z__default.ZodBoolean>;
+    courseId: z__default.ZodNull;
+    lessonId: z__default.ZodInt;
+}, z__default.z.core.$strip>, z__default.ZodObject<{
+    title: z__default.ZodOptional<z__default.ZodString>;
+    description: z__default.ZodOptional<z__default.ZodString>;
+    category: z__default.ZodOptional<z__default.ZodEnum<{
+        readonly GERAL: "GERAL";
+    }>>;
+    visibleToStudents: z__default.ZodOptional<z__default.ZodBoolean>;
+    courseId: z__default.ZodUndefined;
+    lessonId: z__default.ZodUndefined;
+}, z__default.z.core.$strip>], "courseId">;
+type UpdateMaterialRequestBody = z__default.infer<typeof UpdateMaterialRequestBodySchema>;
+declare const DeleteMaterialRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type DeleteMaterialRequestParams = z__default.infer<typeof DeleteMaterialRequestParamsSchema>;
+
+declare const listMaterialsRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    query: ListMaterialsRequestQuery;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Ok<any[]> | Err<ValidationError<"query", z.ZodError<{
+    courseId?: number;
+    lessonId?: number;
+    mimetype?: "PPTX" | "PDF";
+    category?: "GERAL";
+    visibleToStudents?: boolean;
+}>>>>;
+type ListMaterialsResponseBody = AsyncReturn<typeof listMaterialsRoute>;
+declare class MaterialNotFoundError extends Error {
+    readonly _tag = "MaterialNotFound";
+    message: string;
+    constructor(message: string);
+}
+declare const getMaterialRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: GetMaterialRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<ForbiddenError> | Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<MaterialNotFoundError> | Ok<{
+    fileId: any;
+    file: any;
+    url: string;
+    lessonId: number | null;
+    courseId: number | null;
+    id: number;
+    createdAt: Date;
+    createdById: number;
+    updatedAt: Date;
+    updatedById: number;
+    category: MaterialCategory;
+    visibleToStudents: boolean;
+}> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>>>;
+type GetMaterialResponseBody = AsyncReturn<typeof getMaterialRoute>;
+declare const createMaterialRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    body: CreateMaterialRequestBody;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<ForbiddenError> | Err<InternalServerError> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Ok<{
+    fileId: any;
+    url: string;
+    confirmationUrl: string;
+    lessonId: number | null;
+    courseId: number | null;
+    id: number;
+    createdAt: Date;
+    createdById: number;
+    updatedAt: Date;
+    updatedById: number;
+    category: MaterialCategory;
+    visibleToStudents: boolean;
+}> | Err<ValidationError<"body", z.ZodError<{
+    title: string;
+    description: string;
+    mimetype: "PPTX" | "PDF";
+    category: "GERAL";
+    visibleToStudents: boolean;
+} & (({
+    provider: "PUBLIC_URL";
+    url: string;
+} | {
+    provider: "S3_GARAGE";
+    url: undefined;
+}) & ({
+    courseId: number;
+    lessonId: undefined;
+} | {
+    courseId: undefined;
+    lessonId: number;
+}))>>>>;
+type CreateMaterialResponseBody = AsyncReturn<typeof createMaterialRoute>;
+declare const updateMaterialRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: UpdateMaterialRequestParams;
+    body: UpdateMaterialRequestBody;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<ForbiddenError> | Err<InternalServerError> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<LessonNotFoundError> | Err<MaterialNotFoundError> | Ok<{
+    message: string;
+    material: {
+        lessonId: number | null;
+        courseId: number | null;
+        id: number;
+        createdAt: Date;
+        createdById: number;
+        updatedAt: Date;
+        updatedById: number;
+        category: MaterialCategory;
+        fileId: number;
+        visibleToStudents: boolean;
+    };
+}> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>> | Err<ValidationError<"body", z.ZodError<{
+    courseId: number;
+    lessonId: null;
+    title?: string;
+    description?: string;
+    category?: "GERAL";
+    visibleToStudents?: boolean;
+} | {
+    courseId: null;
+    lessonId: number;
+    title?: string;
+    description?: string;
+    category?: "GERAL";
+    visibleToStudents?: boolean;
+} | {
+    courseId: undefined;
+    lessonId: undefined;
+    title?: string;
+    description?: string;
+    category?: "GERAL";
+    visibleToStudents?: boolean;
+}>>>>;
+type UpdateMaterialResponseBody = AsyncReturn<typeof updateMaterialRoute>;
+declare const deleteMaterialRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: DeleteMaterialRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<ForbiddenError> | Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<MaterialNotFoundError> | Ok<{
+    message: string;
+}> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>>>;
+type DeleteMaterialResponseBody = AsyncReturn<typeof deleteMaterialRoute>;
+
+declare const ListNotificationsRequestQuerySchema: z__default.ZodObject<{
+    userId: z__default.ZodOptional<z__default.ZodInt>;
+    unreadOnly: z__default.ZodOptional<z__default.ZodBoolean>;
+}, z__default.z.core.$strip>;
+type ListNotificationsRequestQuery = z__default.infer<typeof ListNotificationsRequestQuerySchema>;
+declare const GetNotificationRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type GetNotificationRequestParams = z__default.infer<typeof GetNotificationRequestParamsSchema>;
+declare const CountNotificationsRequestParamsSchema: z__default.ZodObject<{
+    userId: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type CountNotificationsRequestParams = z__default.infer<typeof CountNotificationsRequestParamsSchema>;
+declare const CreateNotificationRequestBodySchema: z__default.ZodObject<{
+    userId: z__default.ZodInt;
+    title: z__default.ZodString;
+    message: z__default.ZodString;
+    kind: z__default.ZodOptional<z__default.ZodEnum<{
+        readonly GENERAL: "GENERAL";
+        readonly REMINDER: "REMINDER";
+    }>>;
+}, z__default.z.core.$strip>;
+type CreateNotificationRequestBody = z__default.infer<typeof CreateNotificationRequestBodySchema>;
+declare const CreateNotificationsBulkRequestBodySchema: z__default.ZodObject<{
+    userIds: z__default.ZodArray<z__default.ZodInt>;
+    title: z__default.ZodString;
+    message: z__default.ZodString;
+    kind: z__default.ZodOptional<z__default.ZodEnum<{
+        readonly GENERAL: "GENERAL";
+        readonly REMINDER: "REMINDER";
+    }>>;
+}, z__default.z.core.$strip>;
+type CreateNotificationsBulkRequestBody = z__default.infer<typeof CreateNotificationsBulkRequestBodySchema>;
+declare const ReadNotificationRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type ReadNotificationRequestParams = z__default.infer<typeof ReadNotificationRequestParamsSchema>;
+declare const ReadAllNotificationsRequestParamsSchema: z__default.ZodObject<{
+    userId: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type ReadAllNotificationsRequestParams = z__default.infer<typeof ReadAllNotificationsRequestParamsSchema>;
+declare const DeleteNotificationRequestParamsSchema: z__default.ZodObject<{
+    id: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type DeleteNotificationRequestParams = z__default.infer<typeof DeleteNotificationRequestParamsSchema>;
+declare const DeleteAllNotificationsRequestParamsSchema: z__default.ZodObject<{
+    userId: z__default.z.ZodCoercedNumber<unknown>;
+}, z__default.z.core.$strip>;
+type DeleteAllNotificationsRequestParams = z__default.infer<typeof DeleteAllNotificationsRequestParamsSchema>;
+
+declare const listNotificationsRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    query: ListNotificationsRequestQuery;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<ForbiddenError> | Err<InternalServerError> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Ok<{
+    id: number;
+    createdAt: Date;
+    createdById: number;
+    updatedAt: Date;
+    updatedById: number;
+    date: Date;
+    title: string;
+    message: string;
+    kind: NotificationKind;
+    userId: number;
+    read: boolean;
+}[]> | Err<ValidationError<"query", z.ZodError<{
+    userId?: number;
+    unreadOnly?: boolean;
+}>>>>;
+type ListNotificationsResponseBody = AsyncReturn<typeof listNotificationsRoute>;
+declare class NotificationNotFoundError extends Error {
+    readonly _tag = "NotificationNotFound";
+    message: string;
+    constructor(message: string);
+}
+declare const getNotificationRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: GetNotificationRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<ForbiddenError> | Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Ok<{
+    id: number;
+    createdAt: Date;
+    createdById: number;
+    updatedAt: Date;
+    updatedById: number;
+    date: Date;
+    title: string;
+    message: string;
+    kind: NotificationKind;
+    userId: number;
+    read: boolean;
+}> | Err<NotificationNotFoundError> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>>>;
+type GetNotificationResponseBody = AsyncReturn<typeof getNotificationRoute>;
+declare const countNotificationsRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: CountNotificationsRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<ForbiddenError> | Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Ok<{
+    unreadCount: number;
+}> | Err<ValidationError<"params", z.ZodError<{
+    userId: number;
+}>>>>;
+type CountNotificationsResponseBody = AsyncReturn<typeof countNotificationsRoute>;
+declare const createNotificationRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    body: CreateNotificationRequestBody;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Ok<{
+    message: string;
+    id: number;
+}> | Err<ValidationError<"body", z.ZodError<{
+    userId: number;
+    title: string;
+    message: string;
+    kind?: "GENERAL" | "REMINDER";
+}>>>>;
+type CreateNotificationResponseBody = AsyncReturn<typeof createNotificationRoute>;
+declare const createNotificationsBulkRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    body: CreateNotificationsBulkRequestBody;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+} & {
+    user: BasicUserData;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<InternalServerError> | Err<ValidationError<"params", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<RoleRequiredError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<UserNotFoundError> | Ok<{
+    message: string;
+    count: number;
+    ids: number[];
+}> | Err<ValidationError<"body", z.ZodError<{
+    userIds: number[];
+    title: string;
+    message: string;
+    kind?: "GENERAL" | "REMINDER";
+}>>>>;
+type CreateNotificationsBulkResponseBody = AsyncReturn<typeof createNotificationsBulkRoute>;
+declare const readNotificationRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: ReadNotificationRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<ForbiddenError> | Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<NotificationNotFoundError> | Ok<{
+    message: string;
+}> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>>>;
+type ReadNotificationResponseBody = AsyncReturn<typeof readNotificationRoute>;
+declare const readAllNotificationsRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: ReadAllNotificationsRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<ForbiddenError> | Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Ok<{
+    message: string;
+    count: number;
+}> | Err<ValidationError<"params", z.ZodError<{
+    userId: number;
+}>>>>;
+type ReadAllNotificationsResponseBody = AsyncReturn<typeof readAllNotificationsRoute>;
+declare const deleteNotificationRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: DeleteNotificationRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<ForbiddenError> | Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Err<NotificationNotFoundError> | Ok<{
+    message: string;
+}> | Err<ValidationError<"params", z.ZodError<{
+    id: number;
+}>>>>;
+type DeleteNotificationResponseBody = AsyncReturn<typeof deleteNotificationRoute>;
+declare const deleteAllNotificationsRoute: (req: Omit<Omit<TypedAuthedRequest<{
+    params: DeleteAllNotificationsRequestParams;
+}>, "params" | "query" | "body"> & {
+    params: unknown;
+    query: unknown;
+    body: unknown;
+}, "user"> & {
+    user: BasicUserData | undefined;
+}) => Promise<Err<ForbiddenError> | Err<InternalServerError> | Err<ValidationError<"body", z.ZodError<unknown>>> | Err<UnauthenticatedError> | Err<ValidationError<"query", z.ZodError<unknown>>> | Ok<{
+    message: string;
+    count: number;
+}> | Err<ValidationError<"params", z.ZodError<{
+    userId: number;
+}>>>>;
+type DeleteAllNotificationsResponseBody = AsyncReturn<typeof deleteAllNotificationsRoute>;
+
+type ApiRoutes = {
+    /**
+     * Routes for taking attendance
+     */
+    '/attendance': {
+        '/': {
+            /**
+             * List attendances
+             */
+            'GET': {
+                query: ListAttendanceRequestQuery;
+                response: ListAttendenceResponseBody;
+            };
+            /**
+             * Create attendance record
+             */
+            'POST': {
+                body: UpdateAttendenceRequestBody;
+                response: UpdateAttendanceResponse;
+            };
+        };
+        '/:id': {
+            /**
+             * Delete attendance record
+             */
+            'DELETE': {
+                params: DeleteAttendanceRequestParams;
+                reponse: DeleteAttendanceResponse;
+            };
+        };
+        '/bulk': {
+            /**
+             * Create many attendance records for a lesson
+             */
+            'POST': {
+                body: CreateOrUpdateAttendancesBulkRequestBody;
+                response: CreateOrUpdateAttendancesBulkResponseBody;
+            };
+        };
+        '/lesson/:lessonId/status': {
+            /**
+             * Get attendance summary for a given lesson
+             */
+            'GET': {
+                params: GetLessonStatusRequestParams;
+                response: GetLessonStatusResponseBody;
+            };
+        };
+        '/lessons/status': {
+            /**
+             * Get attendance summary for all lessons of a course edition
+             */
+            'GET': {
+                query: GetLessonsStatusBulkQuery;
+                response: GetLessonsStatusBulkResponse;
+            };
+        };
+        '/student/:studentId/stats': {
+            /**
+             * Get attendance summary for a gien student
+             */
+            'GET': {
+                params: GetStudentAttendanceStatusRequestParams;
+                query: GetStudentAttendanceStatusRequestQuery;
+                response: GetStudentAttendanceStatusResponseBody;
+            };
+        };
+    };
+    /**
+     * Routes for user signup
+     */
+    '/auth': {
+        '/verify-phone': {
+            'POST': {
+                body: VerifyPhoneRequestBody;
+                response: VerifyPhoneResponse;
+            };
+        };
+        '/create-custom-token': {
+            'POST': {
+                body: CreateCustomTokenRequestBody;
+                response: CreateCustomTokenResponse;
+            };
+        };
+        '/get-user': {
+            'POST': {
+                response: GetUserResponse;
+            };
+        };
+        '/validate': {
+            'GET': {
+                response: ValidateResponse;
+            };
+        };
+    };
+    /**
+     * Routes for content management
+     */
+    '/contents': {
+        '/': {
+            /**
+             * List contents (optionally filter by course, kind and category)
+             */
+            'GET': {
+                query: ListContentsRequestQuery;
+                response: ListContentsResponseBody;
+            };
+            /**
+             * Create a new content (admin and coordinator only)
+             */
+            'POST': {
+                body: CreateContentRequestBody;
+                response: CreateContentResponseBody;
+            };
+        };
+        '/:id': {
+            /**
+             * Get a specific content by id
+             */
+            'GET': {
+                params: GetContentRequestParams;
+                response: GetContentResponse;
+            };
+            /**
+             * Update a content (admin and coordinator only)
+             */
+            'PUT': {
+                params: UpdateContentRequestParams;
+                body: UpdateContentRequestBody;
+                response: UpdateContentResponseBody;
+            };
+            /**
+             * Delete a content (admin only)
+             */
+            'DELETE': {
+                params: DeleteContentRequestParams;
+                response: DeleteContentResponseBody;
+            };
+        };
+    };
+    /**
+     * Routes for course management
+     */
+    '/courses': {
+        '/': {
+            /**
+             * List all courses
+             */
+            'GET': {
+                response: GetCoursesResponse;
+            };
+            /**
+             * Create a new course (admin only)
+             */
+            'POST': {
+                body: CreateCourseRequestBody;
+                response: CreateCourseResponse;
+            };
+        };
+        '/:id': {
+            /**
+             * Get a specific course by id
+             */
+            'GET': {
+                params: GetCourseRequestParams;
+                response: GetCourseResponse;
+            };
+            /**
+             * Update a course (admin only)
+             */
+            'PUT': {
+                params: UpdateCourseRequestParams;
+                body: UpdateCourseRequestBody;
+                response: UpdateCourseResponse;
+            };
+            /**
+             * Delete a course (admin only)
+             */
+            'DELETE': {
+                params: DeleteCourseRequestParams;
+                response: DeleteCourseResponse;
+            };
+        };
+    };
+    /**
+     * Routes for course edition management
+     */
+    '/editions': {
+        '/': {
+            /**
+             * List all editions
+             */
+            'GET': {
+                query: ListEditionsRequestQuery;
+                response: ListEditionsResponseBody;
+            };
+            /**
+             * Create a new edition (admin only)
+             */
+            'POST': {
+                body: CreateEditionRequestBody;
+                response: CreateEditionResponseBody;
+            };
+        };
+        '/:id': {
+            /**
+             * Get a specific edition by id
+             */
+            'GET': {
+                params: GetEditionRequestParams;
+                response: GetEditionResponseBody;
+            };
+            /**
+             * Update an edition (admin only)
+             */
+            'PUT': {
+                params: UpdateEditionRequestParams;
+                body: UpdateEditionRequestBody;
+                response: UpdateEditionResponseBody;
+            };
+            /**
+             * Delete an edition (admin only). Fails if there are associated lessons/enrollments
+             */
+            'DELETE': {
+                params: DeleteEditionRequestParams;
+                response: DeleteEditionResponseBody;
+            };
+        };
+        '/:id/stats': {
+            /**
+             * Get statistics for an edition (total lessons, students, lessons by course)
+             */
+            'GET': {
+                params: GetEditionStatsRequestParams;
+                response: GetEditionStatsResponseBody;
+            };
+        };
+    };
+    /**
+     * Routes for enrollment management
+     */
+    '/enrollments': {
+        '/': {
+            /**
+             * List enrollments. Scoped to what the user has access to
+             * (admins/coordinators see all, teachers see their lessons' enrollments,
+             * students see only their own)
+             */
+            'GET': {
+                query: ListEnrollmentsRequestQuery;
+                response: ListEnrollmentsResponseBody;
+            };
+            /**
+             * Create a new enrollment (admin and coordinator only)
+             */
+            'POST': {
+                body: CreateEnrollmentRequestBody;
+                response: CreateEnrollmentResponseBody;
+            };
+        };
+        '/user/:id': {
+            /**
+             * List enrollments for a specific user. Users can only view their own
+             * enrollments unless they are admin/coordinator
+             */
+            'GET': {
+                params: ListUserEnrollmentsRequestParams;
+                response: ListUserEnrollmentsResponseBody;
+            };
+        };
+        '/:id': {
+            /**
+             * Get a specific enrollment. Requires full access role or ownership
+             */
+            'GET': {
+                params: GetEnrollmentRequestParams;
+                response: GetEnrollmentResponseBody;
+            };
+            /**
+             * Update an enrollment (admin and coordinator only)
+             */
+            'PUT': {
+                params: UpdateEnrollmentRequestParams;
+                body: UpdateEnrollmentRequestBody;
+                response: UpdateEnrollmentResponseBody;
+            };
+            /**
+             * Delete an enrollment (admin and coordinator only)
+             */
+            'DELETE': {
+                params: DeleteEnrollmentRequestParams;
+                response: DeleteEnrollmentResponseBody;
+            };
+        };
+    };
+    /**
+     * Routes for file upload management
+     */
+    '/files': {
+        '/:fileId/confirmUpload': {
+            /**
+             * Confirm that a file upload was completed successfully.
+             * Only the file owner can confirm it (no-op for externally hosted files)
+             */
+            'POST': {
+                params: ConfirmFileUploadRequestParams;
+                response: ConfirmFileUploadResponseBody;
+            };
+        };
+    };
+    /**
+     * Routes for attendance justification management
+     */
+    '/justifications': {
+        '/': {
+            /**
+             * List justifications for a course/edition, with resolved attachment
+             * preview URLs (admin, coordinator only)
+             */
+            'GET': {
+                query: ListJustificationsRequestQuery;
+                response: ListJustificationsResponseBody;
+            };
+        };
+        '/:id': {
+            /**
+             * Update a justification (reason, attendance, and/or attachment).
+             * Creates or replaces the attachment file when a provider is given
+             * (admin, coordinator only)
+             */
+            'PUT': {
+                params: UpdateJustificationRequestParams;
+                body: UpdateJustificationRequestBody;
+                response: UpdateJustificationResponseBody;
+            };
+        };
+    };
+    /**
+     * Routes for lesson management
+     */
+    '/lessons': {
+        '/': {
+            /**
+             * List lessons (can filter by teacher, course, edition and date range)
+             */
+            'GET': {
+                query: ListLessonsRequestQuery;
+                response: ListLessonsResponseBody;
+            };
+            /**
+             * Create a new lesson (admin and coordinator only)
+             */
+            'POST': {
+                body: CreateLessonRequestBody;
+                response: CreateLessonResponseBody;
+            };
+        };
+        '/:id': {
+            /**
+             * Get a specific lesson
+             */
+            'GET': {
+                params: GetLessonRequestParams;
+                response: GetLessonResponseBody;
+            };
+            /**
+             * Update a lesson, including live class properties (admin and coordinator only)
+             */
+            'PUT': {
+                params: UpdateLessonRequestParams;
+                body: UpdateLessonRequestBody;
+                response: UpdateLessonResponseBody;
+            };
+            /**
+             * Delete a lesson (admin only). Fails if there is associated data
+             */
+            'DELETE': {
+                params: DeleteLessonRequestParams;
+                response: DeleteLessonResponseBody;
+            };
+        };
+    };
+    /**
+     * Routes for magic link authentication
+     */
+    '/magiclink': {
+        '/send': {
+            /**
+             * Send a magic link to the user's email if it's registered.
+             * Always returns a generic success message to avoid leaking which emails exist
+             */
+            'POST': {
+                body: SendMagicLinkRequestBody;
+                response: SendMagicLinkResponseBody;
+            };
+        };
+        '/verify': {
+            /**
+             * Verify a magic link token and issue a custom auth token for the user
+             */
+            'GET': {
+                query: VerifyMagicLinkRequestQuery;
+                response: VerifyMagicLinkResponseBody;
+            };
+        };
+        '/cleanup': {
+            /**
+             * Delete expired magic link tokens (admin only)
+             */
+            'DELETE': {
+                response: CleanupMagicLinksResponseBody;
+            };
+        };
+    };
+    /**
+     * Routes for course/lesson material management
+     */
+    '/materials': {
+        '/': {
+            /**
+             * List materials the user has access to (students see only materials
+             * for courses/lessons they're enrolled in; teachers see their lessons')
+             */
+            'GET': {
+                query: ListMaterialsRequestQuery;
+                response: ListMaterialsResponseBody;
+            };
+            /**
+             * Create a new material, uploading a file if needed. Teachers can
+             * only attach materials to their own lessons
+             */
+            'POST': {
+                body: CreateMaterialRequestBody;
+                response: CreateMaterialResponseBody;
+            };
+        };
+        '/:id': {
+            /**
+             * Get a specific material with its resolved file URL, if the user has access
+             */
+            'GET': {
+                params: GetMaterialRequestParams;
+                response: GetMaterialResponseBody;
+            };
+            /**
+             * Update a material. Teachers can only update materials of their own lessons
+             */
+            'PUT': {
+                params: UpdateMaterialRequestParams;
+                body: UpdateMaterialRequestBody;
+                response: UpdateMaterialResponseBody;
+            };
+            /**
+             * Delete a material and its file. Teachers can only delete materials of their own lessons
+             */
+            'DELETE': {
+                params: DeleteMaterialRequestParams;
+                response: DeleteMaterialResponseBody;
+            };
+        };
+    };
+    /**
+     * Routes for user notification management
+     */
+    '/notifications': {
+        '/': {
+            /**
+             * List notifications for a user (own notifications, or any user's if admin)
+             */
+            'GET': {
+                query: ListNotificationsRequestQuery;
+                response: ListNotificationsResponseBody;
+            };
+            /**
+             * Create a notification for a single user (admin only)
+             */
+            'POST': {
+                body: CreateNotificationRequestBody;
+                response: CreateNotificationResponseBody;
+            };
+        };
+        '/:id': {
+            /**
+             * Get a specific notification (own notification, or any if admin)
+             */
+            'GET': {
+                params: GetNotificationRequestParams;
+                response: GetNotificationResponseBody;
+            };
+            /**
+             * Delete a notification (own notification, or any if admin)
+             */
+            'DELETE': {
+                params: DeleteNotificationRequestParams;
+                response: DeleteNotificationResponseBody;
+            };
+        };
+        '/:id/read': {
+            /**
+             * Mark a notification as read (own notification, or any if admin)
+             */
+            'PUT': {
+                params: ReadNotificationRequestParams;
+                response: ReadNotificationResponseBody;
+            };
+        };
+        '/bulk': {
+            /**
+             * Create the same notification for multiple users (admin only)
+             */
+            'POST': {
+                body: CreateNotificationsBulkRequestBody;
+                response: CreateNotificationsBulkResponseBody;
+            };
+        };
+        '/user/:userId/count': {
+            /**
+             * Count unread notifications for a user (own count, or any if admin)
+             */
+            'GET': {
+                params: CountNotificationsRequestParams;
+                response: CountNotificationsResponseBody;
+            };
+        };
+        '/user/:userId/read-all': {
+            /**
+             * Mark all notifications as read for a user (own notifications, or any if admin)
+             */
+            'PUT': {
+                params: ReadAllNotificationsRequestParams;
+                response: ReadAllNotificationsResponseBody;
+            };
+        };
+        '/user/:userId/all': {
+            /**
+             * Delete all notifications for a user (own notifications, or any if admin)
+             */
+            'DELETE': {
+                params: DeleteAllNotificationsRequestParams;
+                response: DeleteAllNotificationsResponseBody;
+            };
+        };
+    };
+    /**
+     * Routes for user management
+     */
+    '/users': {
+        '/': {
+            /**
+             * List users (admin/coordinator only; coordinators are restricted to students)
+             */
+            'GET': {
+                query: ListUsersRequestQuery;
+                response: ListUsersResponseBody;
+            };
+            /**
+             * Create a new user (admin only)
+             */
+            'POST': {
+                body: CreateUserRequestBody;
+                response: CreateUserResponseBody;
+            };
+        };
+        '/:id': {
+            /**
+             * Get a specific user (own data, or any user if admin/coordinator with restrictions)
+             */
+            'GET': {
+                params: GetUserRequestParams;
+                response: GetUserResponseBody;
+            };
+            /**
+             * Update a user (own data, or any user if admin)
+             */
+            'PUT': {
+                params: UpdateUserRequestParams;
+                body: UpdateUserRequestBody;
+                response: UpdateUserResponseBody;
+            };
+            /**
+             * Delete a user (soft delete: anonymizes personal data and deactivates account).
+             * Own account, or any user if admin
+             */
+            'DELETE': {
+                params: DeleteUserRequestParams;
+                response: DeleteUserResponseBody;
+            };
+        };
+        '/:id/payment': {
+            /**
+             * Update payment status of a user's enrollment in a course/edition (admin and coordinator only)
+             */
+            'PATCH': {
+                params: PatchPaymentStatusRequestParams;
+                body: PatchPaymentStatusRequestBody;
+                response: PatchPaymentStatusResponseBody;
+            };
+        };
+        '/payments/summary': {
+            /**
+             * Get a summary of enrollment payment statuses, optionally broken down by course/edition
+             * (admin and coordinator only)
+             */
+            'GET': {
+                query: GetPaymentsSummaryRequestQuery;
+                response: GetPaymentsSummaryResponseBody;
+            };
+        };
+    };
+};
+
+export { type ApiRoutes, AttendanceSchema, AttendanceStatusSchema, type CleanupMagicLinksResponseBody, type ConfirmFileUploadRequestParams, ConfirmFileUploadRequestParamsSchema, type ConfirmFileUploadResponseBody, type CountNotificationsRequestParams, CountNotificationsRequestParamsSchema, type CountNotificationsResponseBody, type CreateContentRequestBody, CreateContentRequestBodySchema, type CreateContentResponseBody, type CreateCourseRequestBody, CreateCourseRequestBodySchema, type CreateCourseResponse, type CreateCustomTokenRequestBody, CreateCustomTokenRequestBodySchema, type CreateCustomTokenResponse, type CreateEditionRequestBody, CreateEditionRequestBodySchema, type CreateEditionResponseBody, type CreateEnrollmentRequestBody, CreateEnrollmentRequestBodySchema, type CreateEnrollmentResponseBody, type CreateLessonRequestBody, CreateLessonRequestBodySchema, type CreateLessonResponseBody, type CreateMaterialRequestBody, CreateMaterialRequestBodySchema, type CreateMaterialResponseBody, type CreateNotificationRequestBody, CreateNotificationRequestBodySchema, type CreateNotificationResponseBody, type CreateNotificationsBulkRequestBody, CreateNotificationsBulkRequestBodySchema, type CreateNotificationsBulkResponseBody, type CreateOrUpdateAttendancesBulkRequestBody, CreateOrUpdateAttendancesBulkRequestBodySchema, type CreateOrUpdateAttendancesBulkResponseBody, type CreateUserRequestBody, CreateUserRequestBodySchema, type CreateUserResponseBody, type DeleteAllNotificationsRequestParams, DeleteAllNotificationsRequestParamsSchema, type DeleteAllNotificationsResponseBody, type DeleteAttendanceRequestParams, DeleteAttendanceRequestParamsSchema, type DeleteAttendanceResponse, type DeleteContentRequestParams, DeleteContentRequestParamsSchema, type DeleteContentResponseBody, type DeleteCourseRequestParams, DeleteCourseRequestParamsSchema, type DeleteCourseResponse, type DeleteEditionRequestParams, DeleteEditionRequestParamsSchema, type DeleteEditionResponseBody, type DeleteEnrollmentRequestParams, DeleteEnrollmentRequestParamsSchema, type DeleteEnrollmentResponseBody, type DeleteLessonRequestParams, DeleteLessonRequestParamsSchema, type DeleteLessonResponseBody, type DeleteMaterialRequestParams, DeleteMaterialRequestParamsSchema, type DeleteMaterialResponseBody, type DeleteNotificationRequestParams, DeleteNotificationRequestParamsSchema, type DeleteNotificationResponseBody, type DeleteUserRequestParams, DeleteUserRequestParamsSchema, type DeleteUserResponseBody, type GetContentRequestParams, GetContentRequestParamsSchema, type GetContentResponse, type GetCourseRequestParams, GetCourseRequestParamsSchema, type GetCourseResponse, type GetCoursesResponse, type GetEditionRequestParams, GetEditionRequestParamsSchema, type GetEditionResponseBody, type GetEditionStatsRequestParams, GetEditionStatsRequestParamsSchema, type GetEditionStatsResponseBody, type GetEnrollmentRequestParams, GetEnrollmentRequestParamsSchema, type GetEnrollmentResponseBody, type GetLessonRequestParams, GetLessonRequestParamsSchema, type GetLessonResponseBody, type GetLessonStatusRequestParams, GetLessonStatusRequestParamsSchema, type GetLessonStatusResponseBody, type GetLessonsStatusBulkQuery, GetLessonsStatusBulkQuerySchema, type GetLessonsStatusBulkResponse, type GetMaterialRequestParams, GetMaterialRequestParamsSchema, type GetMaterialResponseBody, type GetNotificationRequestParams, GetNotificationRequestParamsSchema, type GetNotificationResponseBody, type GetPaymentsSummaryRequestQuery, GetPaymentsSummaryRequestQuerySchema, type GetPaymentsSummaryResponseBody, type GetStudentAttendanceStatusRequestParams, GetStudentAttendanceStatusRequestParamsSchema, type GetStudentAttendanceStatusRequestQuery, GetStudentAttendanceStatusRequestQuerySchema, type GetStudentAttendanceStatusResponseBody, type GetUserRequestParams, GetUserRequestParamsSchema, type GetUserResponse, type GetUserResponseBody, type ListAttendanceRequestQuery, ListAttendanceRequestQuerySchema, type ListAttendenceResponseBody, type ListContentsRequestQuery, ListContentsRequestQuerySchema, type ListContentsResponseBody, type ListEditionsRequestQuery, ListEditionsRequestQuerySchema, type ListEditionsResponseBody, type ListEnrollmentsRequestQuery, ListEnrollmentsRequestQuerySchema, type ListEnrollmentsResponseBody, type ListJustificationsRequestQuery, ListJustificationsRequestQuerySchema, type ListJustificationsResponseBody, type ListLessonsRequestQuery, ListLessonsRequestQuerySchema, type ListLessonsResponseBody, type ListMaterialsRequestQuery, ListMaterialsRequestQuerySchema, type ListMaterialsResponseBody, type ListNotificationsRequestQuery, ListNotificationsRequestQuerySchema, type ListNotificationsResponseBody, type ListUserEnrollmentsRequestParams, ListUserEnrollmentsRequestParamsSchema, type ListUserEnrollmentsResponseBody, type ListUsersRequestQuery, ListUsersRequestQuerySchema, type ListUsersResponseBody, type PatchPaymentStatusRequestBody, PatchPaymentStatusRequestBodySchema, type PatchPaymentStatusRequestParams, PatchPaymentStatusRequestParamsSchema, type PatchPaymentStatusResponseBody, type ReadAllNotificationsRequestParams, ReadAllNotificationsRequestParamsSchema, type ReadAllNotificationsResponseBody, type ReadNotificationRequestParams, ReadNotificationRequestParamsSchema, type ReadNotificationResponseBody, type SendMagicLinkRequestBody, SendMagicLinkRequestBodySchema, type SendMagicLinkResponseBody, UpdateAttendanceRequestBodySchema, type UpdateAttendanceResponse, type UpdateAttendenceRequestBody, type UpdateContentRequestBody, UpdateContentRequestBodySchema, type UpdateContentRequestParams, UpdateContentRequestParamsSchema, type UpdateContentResponseBody, type UpdateCourseRequestBody, UpdateCourseRequestBodySchema, type UpdateCourseRequestParams, UpdateCourseRequestParamsSchema, type UpdateCourseResponse, type UpdateEditionRequestBody, UpdateEditionRequestBodySchema, type UpdateEditionRequestParams, UpdateEditionRequestParamsSchema, type UpdateEditionResponseBody, type UpdateEnrollmentRequestBody, UpdateEnrollmentRequestBodySchema, type UpdateEnrollmentRequestParams, UpdateEnrollmentRequestParamsSchema, type UpdateEnrollmentResponseBody, type UpdateJustificationRequestBody, UpdateJustificationRequestBodySchema, type UpdateJustificationRequestParams, UpdateJustificationRequestParamsSchema, type UpdateJustificationResponseBody, type UpdateLessonRequestBody, UpdateLessonRequestBodySchema, type UpdateLessonRequestParams, UpdateLessonRequestParamsSchema, type UpdateLessonResponseBody, type UpdateMaterialRequestBody, UpdateMaterialRequestBodySchema, type UpdateMaterialRequestParams, UpdateMaterialRequestParamsSchema, type UpdateMaterialResponseBody, type UpdateUserRequestBody, UpdateUserRequestBodySchema, type UpdateUserRequestParams, UpdateUserRequestParamsSchema, type UpdateUserResponseBody, type ValidateResponse, type VerifyMagicLinkRequestQuery, VerifyMagicLinkRequestQuerySchema, type VerifyMagicLinkResponseBody, type VerifyPhoneRequestBody, VerifyPhoneRequestBodySchema, type VerifyPhoneResponse };